app

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

giftwrap-builder.spec.ts (9072B)


      1 import { expect, test, type Page } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { fileURLToPath } from 'node:url';
      4 import { createHash } from 'node:crypto';
      5 import { createStaticHarness } from '../integration/harness/static.ts';
      6 import type * as Wraps from './harness/giftwrap-builder.ts';
      7 declare global {
      8   interface Window {
      9     hcp076: typeof Wraps;
     10     hcp076Fixture: Awaited<ReturnType<typeof Wraps.makeFixture>>;
     11   }
     12 }
     13 let server: Awaited<ReturnType<typeof createStaticHarness>>, bundle: string;
     14 test.beforeAll(async () => {
     15   server = await createStaticHarness();
     16   const result = await build({
     17     configFile: false,
     18     logLevel: 'silent',
     19     build: {
     20       write: false,
     21       minify: false,
     22       lib: {
     23         entry: fileURLToPath(
     24           new URL('./harness/giftwrap-builder.ts', import.meta.url)
     25         ),
     26         name: 'hcp076',
     27         formats: ['iife']
     28       }
     29     }
     30   });
     31   const output = Array.isArray(result) ? result[0] : result;
     32   if (!('output' in output)) throw Error('missing bundle');
     33   const chunks = output.output.filter((x) => x.type === 'chunk');
     34   expect(chunks).toHaveLength(1);
     35   bundle = chunks[0].code;
     36   console.log(
     37     JSON.stringify({
     38       fixture: 'HCP076_ACTUAL_SDK_WRAPPER_CRYPTO',
     39       bundleSha256: createHash('sha256').update(bundle).digest('hex'),
     40       moduleIds: Object.keys(chunks[0].modules),
     41       qualification:
     42         'Controlled SDK provider and real IDB/WebLocks; not installed extensions/relay/clientQ'
     43     })
     44   );
     45 });
     46 test.afterAll(async () => server.close());
     47 async function load(page: Page) {
     48   await page.goto(server.url + '/search');
     49   await page.addScriptTag({ content: bundle });
     50   await page.evaluate(async () => {
     51     window.hcp076Fixture = await window.hcp076.makeFixture();
     52   });
     53 }
     54 for (const role of ['peer', 'self'] as const)
     55   test(`actual ${role}1059 decrypts to exact sender seal and original same rumor`, async ({
     56     page
     57   }) => {
     58     await load(page);
     59     const result = await page.evaluate(async (role) => {
     60       const f = window.hcp076Fixture,
     61         s = window.hcp076;
     62       try {
     63         const op = f.operation(role);
     64         if (!op) throw Error('missing operation');
     65         const seal = await s.buildPrivateSeal(op);
     66         if (seal.status !== 'sealed') throw Error('missing seal');
     67         const inner = s.privateSealSnapshot(seal.seal)!;
     68         const before = f.counts(),
     69           token = s.buildPrivateGiftwrap(seal.seal, 'reviewed_private_wrap');
     70         if (!token) throw Error('missing wrap');
     71         const saved = s.privateGiftwrapSnapshot(token)!,
     72           outer = JSON.parse(saved.wire) as {
     73             kind: number;
     74             tags: string[][];
     75             pubkey: string;
     76             created_at: number;
     77           };
     78         const plain = f.decryptWrap(saved.wire, role),
     79           decrypted = f.decrypt(plain, role),
     80           stored = await f.stored();
     81         return {
     82           kind: outer.kind,
     83           tags: outer.tags,
     84           target: inner.destination,
     85           exactSeal: plain === inner.wire,
     86           sameRumor: decrypted.equal,
     87           disposable: outer.pubkey !== f.owner && outer.pubkey !== f.peer,
     88           seven: Object.keys(outer).length,
     89           changedCalls: JSON.stringify(before) !== JSON.stringify(f.counts()),
     90           noPlain:
     91             !saved.wire.includes('sentinel') && !stored.includes('sentinel'),
     92           bounded: new TextEncoder().encode(saved.wire).length <= 32768,
     93           time: outer.created_at,
     94           now: Math.floor(Date.now() / 1000),
     95           role: saved.role,
     96           owner: saved.owner,
     97           peer: saved.peer
     98         };
     99       } finally {
    100         f.close();
    101       }
    102     }, role);
    103     expect(result.kind).toBe(1059);
    104     expect(result.tags).toEqual([['p', result.target]]);
    105     expect(result.exactSeal).toBe(true);
    106     expect(result.sameRumor).toBe(true);
    107     expect(result.disposable).toBe(true);
    108     expect(result.seven).toBe(7);
    109     expect(result.changedCalls).toBe(false);
    110     expect(result.noPlain).toBe(true);
    111     expect(result.bounded).toBe(true);
    112     expect(result.time).toBeLessThanOrEqual(result.now);
    113     expect(result.time).toBeGreaterThanOrEqual(result.now - 3600);
    114     expect(result.role).toBe(role);
    115   });
    116 test('distinct disposable wrappers preserve the exact original seal without retargeting or identity effects', async ({
    117   page
    118 }) => {
    119   await load(page);
    120   const result = await page.evaluate(async () => {
    121     const f = window.hcp076Fixture,
    122       s = window.hcp076;
    123     try {
    124       const seal = await s.buildPrivateSeal(f.operation()!);
    125       if (seal.status !== 'sealed') throw Error('missing seal');
    126       const before = f.counts(),
    127         a = s.privateGiftwrapSnapshot(
    128           s.buildPrivateGiftwrap(seal.seal, 'reviewed_private_wrap')!
    129         )!,
    130         b = s.privateGiftwrapSnapshot(
    131           s.buildPrivateGiftwrap(seal.seal, 'reviewed_private_wrap')!
    132         )!;
    133       const ae = JSON.parse(a.wire) as { id: string; pubkey: string },
    134         be = JSON.parse(b.wire) as { id: string; pubkey: string };
    135       return {
    136         fresh: ae.pubkey !== be.pubkey && ae.id !== be.id,
    137         equal: f.decryptWrap(a.wire, 'peer') === f.decryptWrap(b.wire, 'peer'),
    138         sameBinding:
    139           a.command === b.command &&
    140           a.rumorHash === b.rumorHash &&
    141           a.destination === b.destination,
    142         calls: JSON.stringify(before) === JSON.stringify(f.counts())
    143       };
    144     } finally {
    145       f.close();
    146     }
    147   });
    148   expect(result).toEqual({
    149     fresh: true,
    150     equal: true,
    151     sameBinding: true,
    152     calls: true
    153   });
    154 });
    155 test('wrong review, cast/copy wire and stopped genuine operation do not mint wrappers', async ({
    156   page
    157 }) => {
    158   await load(page);
    159   const result = await page.evaluate(async () => {
    160     const f = window.hcp076Fixture,
    161       s = window.hcp076;
    162     try {
    163       const op = f.operation()!,
    164         seal = await s.buildPrivateSeal(op);
    165       if (seal.status !== 'sealed') throw Error('missing seal');
    166       const snapshot = s.privateSealSnapshot(seal.seal)!;
    167       const wrong = s.buildPrivateGiftwrap(seal.seal, 'connect'),
    168         cast = s.buildPrivateGiftwrap(
    169           snapshot as unknown as typeof seal.seal,
    170           'reviewed_private_wrap'
    171         );
    172       s.stopPrivateSeal(op);
    173       const stopped = s.buildPrivateGiftwrap(
    174         seal.seal,
    175         'reviewed_private_wrap'
    176       );
    177       return {
    178         wrong: wrong === undefined,
    179         cast: cast === undefined,
    180         stopped: stopped === undefined
    181       };
    182     } finally {
    183       f.close();
    184     }
    185   });
    186   expect(result).toEqual({ wrong: true, cast: true, stopped: true });
    187 });
    188 test('disconnect removes wrapper lifetime access and cannot turn ciphertext metadata into a token', async ({
    189   page
    190 }) => {
    191   await load(page);
    192   const result = await page.evaluate(async () => {
    193     const f = window.hcp076Fixture,
    194       s = window.hcp076;
    195     try {
    196       const seal = await s.buildPrivateSeal(f.operation()!);
    197       if (seal.status !== 'sealed') throw Error('missing seal');
    198       const wrap = s.buildPrivateGiftwrap(seal.seal, 'reviewed_private_wrap')!,
    199         saved = s.privateGiftwrapSnapshot(wrap)!;
    200       const cast = s.privateGiftwrapSnapshot(saved as unknown as typeof wrap);
    201       f.disconnect();
    202       return {
    203         cast: cast === undefined,
    204         stale: s.privateGiftwrapSnapshot(wrap) === undefined,
    205         noResume:
    206           s.buildPrivateGiftwrap(seal.seal, 'reviewed_private_wrap') ===
    207           undefined
    208       };
    209     } finally {
    210       f.close();
    211     }
    212   });
    213   expect(result).toEqual({ cast: true, stale: true, noResume: true });
    214 });
    215 
    216 test('peer and self outer copies preserve one genuine reserved rumor and route only to that pair', async ({
    217   page
    218 }) => {
    219   await load(page);
    220   const result = await page.evaluate(async () => {
    221     const f = window.hcp076Fixture,
    222       s = window.hcp076;
    223     try {
    224       const selfSeal = await s.buildPrivateSeal(f.operation('self')!),
    225         peerSeal = await s.buildPrivateSeal(f.operation('peer')!);
    226       if (selfSeal.status !== 'sealed' || peerSeal.status !== 'sealed')
    227         throw Error('missing pair seals');
    228       const self = s.privateGiftwrapSnapshot(
    229           s.buildPrivateGiftwrap(selfSeal.seal, 'reviewed_private_wrap')!
    230         )!,
    231         peer = s.privateGiftwrapSnapshot(
    232           s.buildPrivateGiftwrap(peerSeal.seal, 'reviewed_private_wrap')!
    233         )!;
    234       const selfInner = f.decryptWrap(self.wire, 'self'),
    235         peerInner = f.decryptWrap(peer.wire, 'peer');
    236       return {
    237         selfEqual: f.decrypt(selfInner, 'self').equal,
    238         peerEqual: f.decrypt(peerInner, 'peer').equal,
    239         same:
    240           self.rumorHash === peer.rumorHash && self.command === peer.command,
    241         targets: self.destination === f.owner && peer.destination === f.peer,
    242         roles: self.role === 'self' && peer.role === 'peer',
    243         distinct: self.wire !== peer.wire
    244       };
    245     } finally {
    246       f.close();
    247     }
    248   });
    249   expect(result).toEqual({
    250     selfEqual: true,
    251     peerEqual: true,
    252     same: true,
    253     targets: true,
    254     roles: true,
    255     distinct: true
    256   });
    257 });