app

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

envelope-preparation.spec.ts (13662B)


      1 import { test, expect, type Page } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { fileURLToPath } from 'node:url';
      4 import { createStaticHarness } from '../integration/harness/static.ts';
      5 import type * as Pair from './harness/envelope-preparation.ts';
      6 declare global {
      7   interface Window {
      8     hcp078: typeof Pair;
      9     hcp078Fixture: Awaited<ReturnType<typeof Pair.makeFixture>>;
     10     hcp078Pair: NonNullable<ReturnType<typeof Pair.captureEnvelopePreparation>>;
     11     hcp078Job: ReturnType<typeof Pair.prepareEnvelopeRole>;
     12   }
     13 }
     14 let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string;
     15 test.beforeAll(async () => {
     16   server = await createStaticHarness();
     17   const result = await build({
     18     configFile: false,
     19     logLevel: 'silent',
     20     build: {
     21       write: false,
     22       minify: false,
     23       lib: {
     24         entry: fileURLToPath(
     25           new URL('./harness/envelope-preparation.ts', import.meta.url)
     26         ),
     27         name: 'hcp078',
     28         formats: ['iife']
     29       }
     30     }
     31   });
     32   const output = Array.isArray(result) ? result[0] : result;
     33   if (!('output' in output)) throw Error('missing bundle');
     34   const chunks = output.output.filter((x) => x.type === 'chunk');
     35   expect(chunks).toHaveLength(1);
     36   bundle = chunks[0].code;
     37 });
     38 test.afterAll(async () => server.close());
     39 async function load(page: Page) {
     40   await page.goto(server.url + '/search');
     41   await page.addScriptTag({ content: bundle });
     42   await page.evaluate(async () => {
     43     const s = window.hcp078,
     44       f = await s.makeFixture();
     45     window.hcp078Fixture = f;
     46     const pair = s.captureEnvelopePreparation(
     47       f.identity,
     48       f.reserved,
     49       'reviewed_envelope_pair'
     50     );
     51     if (!pair) throw Error('missing pair');
     52     window.hcp078Pair = pair;
     53   });
     54 }
     55 test('self first and peer second decrypt to the same original, wrong routes and repeats spend no prompts', async ({
     56   page
     57 }) => {
     58   await load(page);
     59   const result = await page.evaluate(async () => {
     60     const s = window.hcp078,
     61       f = window.hcp078Fixture,
     62       p = window.hcp078Pair;
     63     try {
     64       const before = f.counts();
     65       const early = await s.prepareEnvelopeRole(
     66           p,
     67           'peer',
     68           'reviewed_pair_role'
     69         ),
     70         wrong = await s.prepareEnvelopeRole(p, 'third', 'reviewed_pair_role'),
     71         review = await s.prepareEnvelopeRole(p, 'self', 'wrong');
     72       const blockedUnchanged =
     73         JSON.stringify(before) === JSON.stringify(f.counts());
     74       const first = await s.prepareEnvelopeRole(
     75           p,
     76           'self',
     77           'reviewed_pair_role'
     78         ),
     79         prefix = s.envelopePreparationSnapshot(p);
     80       if (!prefix?.self) throw Error('missing prefix');
     81       const afterSelf = f.counts();
     82       const second = await s.prepareEnvelopeRole(
     83           p,
     84           'peer',
     85           'reviewed_pair_role'
     86         ),
     87         complete = s.envelopePreparationSnapshot(p);
     88       if (!complete?.self || !complete.peer) throw Error('missing pair');
     89       const after = f.counts();
     90       const repeatedSelf = await s.prepareEnvelopeRole(
     91           p,
     92           'self',
     93           'reviewed_pair_role'
     94         ),
     95         repeatedPeer = await s.prepareEnvelopeRole(
     96           p,
     97           'peer',
     98           'reviewed_pair_role'
     99         );
    100       const selfSeal = f.decryptWrap(complete.self.wire, 'self'),
    101         peerSeal = f.decryptWrap(complete.peer.wire, 'peer');
    102       const selfOuter = JSON.parse(complete.self.wire) as {
    103           id: string;
    104           tags: string[][];
    105         },
    106         peerOuter = JSON.parse(complete.peer.wire) as {
    107           id: string;
    108           tags: string[][];
    109         };
    110       return {
    111         early: early.status,
    112         wrong: wrong.status,
    113         review: review.status,
    114         blockedUnchanged,
    115         first: first.status,
    116         phase: prefix.phase,
    117         selfSigns: afterSelf.signs - before.signs,
    118         selfEncrypts: afterSelf.encrypts - before.encrypts,
    119         second: second.status,
    120         complete: complete.phase,
    121         samePrefix: prefix.self.wire === complete.self.wire,
    122         sameRumor: complete.self.rumorHash === complete.peer.rumorHash,
    123         selfEqual: f.decrypt(selfSeal, 'self').equal,
    124         peerEqual: f.decrypt(peerSeal, 'peer').equal,
    125         selfTags: selfOuter.tags,
    126         peerTags: peerOuter.tags,
    127         owner: f.owner,
    128         peer: f.peer,
    129         differentOuter: selfOuter.id !== peerOuter.id,
    130         repeatedSelf: repeatedSelf.status,
    131         repeatedPeer: repeatedPeer.status,
    132         repeatedUnchanged: JSON.stringify(after) === JSON.stringify(f.counts())
    133       };
    134     } finally {
    135       f.close();
    136     }
    137   });
    138   expect(result).toMatchObject({
    139     early: 'out_of_order',
    140     wrong: 'invalid',
    141     review: 'invalid',
    142     blockedUnchanged: true,
    143     first: 'prepared',
    144     phase: 'peer',
    145     selfSigns: 1,
    146     selfEncrypts: 1,
    147     second: 'complete',
    148     complete: 'complete',
    149     samePrefix: true,
    150     sameRumor: true,
    151     selfEqual: true,
    152     peerEqual: true,
    153     differentOuter: true,
    154     repeatedSelf: 'complete',
    155     repeatedPeer: 'complete',
    156     repeatedUnchanged: true
    157   });
    158   expect(result.selfTags).toEqual([['p', result.owner]]);
    159   expect(result.peerTags).toEqual([['p', result.peer]]);
    160 });
    161 test('peer refusal preserves the exact self proof and only explicit retry resumes the original pair', async ({
    162   page
    163 }) => {
    164   await load(page);
    165   const result = await page.evaluate(async () => {
    166     const s = window.hcp078,
    167       f = window.hcp078Fixture,
    168       p = window.hcp078Pair;
    169     try {
    170       await s.prepareEnvelopeRole(p, 'self', 'reviewed_pair_role');
    171       const prefix = s.envelopePreparationSnapshot(p),
    172         proof = s.preparedEnvelopeProof(p, 'self');
    173       f.mode('declined');
    174       const failed = await s.prepareEnvelopeRole(
    175           p,
    176           'peer',
    177           'reviewed_pair_role'
    178         ),
    179         paused = s.envelopePreparationSnapshot(p),
    180         counts = f.counts();
    181       f.mode('normal');
    182       const retried = await s.prepareEnvelopeRole(
    183           p,
    184           'peer',
    185           'reviewed_pair_role'
    186         ),
    187         done = s.envelopePreparationSnapshot(p);
    188       if (!done?.self || !done.peer) throw Error('missing completed pair');
    189       return {
    190         failed: failed.status,
    191         phase: paused?.phase,
    192         busy: paused?.busy,
    193         unchanged:
    194           prefix?.self?.wire === paused?.self?.wire &&
    195           paused?.self?.wire === done.self.wire,
    196         sameProof: proof === s.preparedEnvelopeProof(p, 'self'),
    197         retry: retried.status,
    198         retrySigns: f.counts().signs - counts.signs,
    199         retryEncrypts: f.counts().encrypts - counts.encrypts,
    200         selfEqual: f.decrypt(f.decryptWrap(done.self.wire, 'self'), 'self')
    201           .equal,
    202         peerEqual: f.decrypt(f.decryptWrap(done.peer.wire, 'peer'), 'peer')
    203           .equal
    204       };
    205     } finally {
    206       f.close();
    207     }
    208   });
    209   expect(result).toEqual({
    210     failed: 'refused',
    211     phase: 'peer',
    212     busy: false,
    213     unchanged: true,
    214     sameProof: true,
    215     retry: 'complete',
    216     retrySigns: 1,
    217     retryEncrypts: 1,
    218     selfEqual: true,
    219     peerEqual: true
    220   });
    221 });
    222 for (const action of ['stop', 'expire'] as const)
    223   test(`${action} pending peer keeps admission and real lock until settlement and preserves completed self`, async ({
    224     page
    225   }) => {
    226     await load(page);
    227     const prefix = await page.evaluate(async () => {
    228       const s = window.hcp078,
    229         f = window.hcp078Fixture,
    230         p = window.hcp078Pair;
    231       await s.prepareEnvelopeRole(p, 'self', 'reviewed_pair_role');
    232       const wire = s.envelopePreparationSnapshot(p)?.self?.wire;
    233       f.mode('hold_decrypt');
    234       window.hcp078Job = s.prepareEnvelopeRole(p, 'peer', 'reviewed_pair_role');
    235       return wire;
    236     });
    237     await expect
    238       .poll(() => page.evaluate(() => window.hcp078Fixture.slot()))
    239       .toMatchObject({ state: 'active', pending: 'decrypt' });
    240     const pending = await page.evaluate(async (action) => {
    241       const s = window.hcp078,
    242         f = window.hcp078Fixture,
    243         p = window.hcp078Pair;
    244       if (action === 'expire') s.expireEnvelopePreparationWait(p);
    245       else s.stopEnvelopePreparation(p);
    246       const contender = f.operation();
    247       if (!contender) throw Error('missing contender');
    248       return {
    249         busy: s.envelopePreparationSnapshot(p)?.busy,
    250         pairBusy: (await s.prepareEnvelopeRole(p, 'peer', 'reviewed_pair_role'))
    251           .status,
    252         lockBusy: (await s.buildPrivateSeal(contender)).status,
    253         slot: f.slot(),
    254         wire: s.envelopePreparationSnapshot(p)?.self?.wire
    255       };
    256     }, action);
    257     expect(pending).toMatchObject({
    258       busy: true,
    259       pairBusy: 'busy',
    260       lockBusy: 'busy',
    261       slot: { state: 'active', pending: 'decrypt' },
    262       wire: prefix
    263     });
    264     const settled = await page.evaluate(async () => {
    265       const s = window.hcp078,
    266         f = window.hcp078Fixture,
    267         p = window.hcp078Pair,
    268         before = f.counts();
    269       try {
    270         f.settle();
    271         const stopped = await window.hcp078Job,
    272           paused = s.envelopePreparationSnapshot(p),
    273           noLate = JSON.stringify(before) === JSON.stringify(f.counts());
    274         f.mode('normal');
    275         const result = await s.prepareEnvelopeRole(
    276             p,
    277             'peer',
    278             'reviewed_pair_role'
    279           ),
    280           done = s.envelopePreparationSnapshot(p);
    281         return {
    282           status: stopped.status,
    283           phase: paused?.phase,
    284           busy: paused?.busy,
    285           wire: paused?.self?.wire,
    286           noLate,
    287           slot: f.slot(),
    288           resumed: result.status,
    289           sameSelf: done?.self?.wire === paused?.self?.wire
    290         };
    291       } finally {
    292         f.close();
    293       }
    294     });
    295     expect(settled).toEqual({
    296       status: 'stopped',
    297       phase: 'peer',
    298       busy: false,
    299       wire: prefix,
    300       noLate: true,
    301       slot: { state: 'idle' },
    302       resumed: 'complete',
    303       sameSelf: true
    304     });
    305   });
    306 for (const action of ['close', 'disconnect'] as const)
    307   test(`${action} retires prefix and pending peer permanently without releasing unsettled work early`, async ({
    308     page
    309   }) => {
    310     await load(page);
    311     await page.evaluate(async () => {
    312       const s = window.hcp078,
    313         f = window.hcp078Fixture,
    314         p = window.hcp078Pair;
    315       await s.prepareEnvelopeRole(p, 'self', 'reviewed_pair_role');
    316       f.mode('hold_decrypt');
    317       window.hcp078Job = s.prepareEnvelopeRole(p, 'peer', 'reviewed_pair_role');
    318     });
    319     await expect
    320       .poll(() => page.evaluate(() => window.hcp078Fixture.slot()))
    321       .toMatchObject({ state: 'active', pending: 'decrypt' });
    322     const pending = await page.evaluate((action) => {
    323       const s = window.hcp078,
    324         f = window.hcp078Fixture,
    325         p = window.hcp078Pair;
    326       if (action === 'close') {
    327         s.closeEnvelopePreparation(p);
    328         s.closeEnvelopePreparation(p);
    329       } else f.disconnect();
    330       return {
    331         retired: !s.envelopePreparationSnapshot(p),
    332         proofGone: !s.preparedEnvelopeProof(p, 'self'),
    333         slot: f.slot()
    334       };
    335     }, action);
    336     expect(pending).toEqual({
    337       retired: true,
    338       proofGone: true,
    339       slot: { state: 'active', pending: 'decrypt', phase: 'stopped' }
    340     });
    341     const settled = await page.evaluate(async (action) => {
    342       const s = window.hcp078,
    343         f = window.hcp078Fixture,
    344         p = window.hcp078Pair,
    345         before = f.counts();
    346       try {
    347         f.settle();
    348         const result = await window.hcp078Job,
    349           noLate = JSON.stringify(before) === JSON.stringify(f.counts());
    350         f.mode('normal');
    351         if (action === 'disconnect') {
    352           await s.connectIdentity(f.identity);
    353           await s.probeIdentityMessaging(f.identity, 'reviewed_self_copy');
    354         }
    355         return {
    356           status: result.status,
    357           noLate,
    358           slot: f.slot(),
    359           oldRetired: !s.envelopePreparationSnapshot(p),
    360           retry: (await s.prepareEnvelopeRole(p, 'peer', 'reviewed_pair_role'))
    361             .status
    362         };
    363       } finally {
    364         f.close();
    365       }
    366     }, action);
    367     expect(settled).toEqual({
    368       status: 'stopped',
    369       noLate: true,
    370       slot: { state: 'idle' },
    371       oldRetired: true,
    372       retry: 'stopped'
    373     });
    374   });
    375 test('detached snapshots and cast reservations cannot become another preparation controller', async ({
    376   page
    377 }) => {
    378   await load(page);
    379   const result = await page.evaluate(async () => {
    380     const s = window.hcp078,
    381       f = window.hcp078Fixture,
    382       p = window.hcp078Pair;
    383     try {
    384       await s.prepareEnvelopeRole(p, 'self', 'reviewed_pair_role');
    385       const observed = s.envelopePreparationSnapshot(p);
    386       if (!observed) throw Error('missing snapshot');
    387       const cast = observed as unknown as typeof p,
    388         second = await f.reserveAgain();
    389       const other = s.captureEnvelopePreparation(
    390         f.identity,
    391         second,
    392         'reviewed_envelope_pair'
    393       );
    394       return {
    395         cast: (await s.prepareEnvelopeRole(cast, 'peer', 'reviewed_pair_role'))
    396           .status,
    397         detached: !s.captureEnvelopePreparation(
    398           f.identity,
    399           {} as typeof f.reserved,
    400           'reviewed_envelope_pair'
    401         ),
    402         sameReservation: second === f.reserved,
    403         newPair: !!other,
    404         newPairHasNoPrefix: !!other && !s.preparedEnvelopeProof(other, 'self'),
    405         originalPrefix: !!s.preparedEnvelopeProof(p, 'self')
    406       };
    407     } finally {
    408       f.close();
    409     }
    410   });
    411   expect(result).toEqual({
    412     cast: 'invalid',
    413     detached: true,
    414     sameReservation: false,
    415     newPair: true,
    416     newPairHasNoPrefix: true,
    417     originalPrefix: true
    418   });
    419 });