app

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

head-resolution.test.ts (6654B)


      1 import test from 'node:test';
      2 import assert from 'node:assert/strict';
      3 import { once } from 'node:events';
      4 import { readFile } from 'node:fs/promises';
      5 import { finalizeEvent } from 'applesauce-core/helpers';
      6 import WebSocket, { WebSocketServer } from 'ws';
      7 import { validateRelayPolicy } from '../../src/lib/config/relays.ts';
      8 import {
      9   createPublicRuntimeContext,
     10   mountPublicRuntime,
     11   createPublicView,
     12   beginPublicViewRun,
     13   closePublicRuntime
     14 } from '../../src/lib/runtime/public-runtime.ts';
     15 import { publicRunSnapshot } from '../../src/lib/nostr/request-scope.ts';
     16 import { verifyEnvelope } from '../../src/lib/nostr/verified-envelope.ts';
     17 import { createPublicHeadCandidate } from '../../src/lib/catalog/heads.ts';
     18 import {
     19   createPublicViewHeadResolver,
     20   resolveHeads,
     21   headResolutionSnapshot
     22 } from '../../src/lib/catalog/resolve-head.ts';
     23 
     24 await test('actual SDK exact-coordinate and author deletion queries share one bounded run and retain suppressed newest evidence', async () => {
     25   const corpus = JSON.parse(
     26     await readFile(
     27       new URL(
     28         '../../../contracts/interop/food_availability/corpus.v1.json',
     29         import.meta.url
     30       ),
     31       'utf8'
     32     )
     33   ) as { vectors: { id: string; signed_wires: Record<string, string> }[] };
     34   const base = JSON.parse(
     35     corpus.vectors.find((v) => v.id.endsWith('_032'))!.signed_wires.previous
     36   ) as { tags: string[][]; content: string; created_at: number };
     37   const key = crypto.getRandomValues(new Uint8Array(32));
     38   const previous = finalizeEvent(
     39     {
     40       kind: 30402,
     41       created_at: base.created_at,
     42       tags: base.tags,
     43       content: base.content
     44     },
     45     key
     46   );
     47   const current = finalizeEvent(
     48     {
     49       kind: 30402,
     50       created_at: base.created_at + 1,
     51       tags: base.tags.map((t) =>
     52         t[0] === 'status'
     53           ? ['status', 'sold']
     54           : t[0] === 'title'
     55             ? ['title', 'Renamed celery']
     56             : [...t]
     57       ),
     58       content: base.content
     59     },
     60     key
     61   );
     62   const deletion = finalizeEvent(
     63     {
     64       kind: 5,
     65       created_at: base.created_at - 1,
     66       tags: [['e', current.id]],
     67       content: ''
     68     },
     69     key
     70   );
     71   key.fill(0);
     72   const origin = 'wss://one.example.org',
     73     server = new WebSocketServer({
     74       host: '127.0.0.1',
     75       port: 0,
     76       maxPayload: 4096
     77     });
     78   const sockets: WebSocket[] = [];
     79   const filters: Record<string, unknown>[] = [];
     80   let sent = () => {};
     81   const sentBoth = new Promise<void>((resolve) => {
     82     sent = resolve;
     83   });
     84   server.on('connection', (socket) => {
     85     sockets.push(socket);
     86     socket.on('message', (bytes) => {
     87       const buffer = Array.isArray(bytes)
     88         ? Buffer.concat(bytes)
     89         : Buffer.isBuffer(bytes)
     90           ? bytes
     91           : Buffer.from(bytes);
     92       const frame = JSON.parse(buffer.toString('utf8')) as unknown[];
     93       if (frame[0] !== 'REQ') return;
     94       const id = String(frame[1]),
     95         query = frame[2] as Record<string, unknown>;
     96       filters.push(query);
     97       const values =
     98         (query.kinds as number[])[0] === 30402
     99           ? [previous, current]
    100           : [deletion];
    101       for (const value of values)
    102         socket.send(JSON.stringify(['EVENT', id, value]));
    103       socket.send(JSON.stringify(['EOSE', id]));
    104       if (filters.length === 2) sent();
    105     });
    106   });
    107   await once(server, 'listening');
    108   const address = server.address();
    109   assert.ok(address && typeof address !== 'string');
    110   const port = address.port;
    111   const oldWindow = Object.getOwnPropertyDescriptor(globalThis, 'window'),
    112     oldSocket = globalThis.WebSocket;
    113   class FixtureSocket extends WebSocket {
    114     constructor(url: string | URL) {
    115       assert.equal(String(url).replace(/\/$/, ''), origin);
    116       super(`ws://127.0.0.1:${port}`);
    117     }
    118   }
    119   Object.defineProperty(globalThis, 'window', {
    120     configurable: true,
    121     value: {}
    122   });
    123   globalThis.WebSocket =
    124     FixtureSocket as unknown as typeof globalThis.WebSocket;
    125   const context = createPublicRuntimeContext();
    126   try {
    127     const policy = validateRelayPolicy(
    128       JSON.stringify({
    129         schemaVersion: 1,
    130         public: [{ origin, read: true, write: false, nip50: false }],
    131         inbox: [],
    132         postingEnabled: false,
    133         messagingEnabled: false,
    134         operatorDenylist: []
    135       })
    136     )!;
    137     const runtime = mountPublicRuntime(context, policy)!;
    138     const view = createPublicView(runtime),
    139       run = beginPublicViewRun(view);
    140     const proof = verifyEnvelope(JSON.stringify(previous));
    141     assert.ok(proof.ok);
    142     const initial = createPublicHeadCandidate(proof.value);
    143     assert.ok(initial);
    144     const resolver = createPublicViewHeadResolver(view, run, {
    145       nowSeconds: () => base.created_at + 10
    146     });
    147     resolveHeads(resolver, [initial, initial]);
    148     resolveHeads(resolver, [initial]);
    149     await sentBoth;
    150     for (
    151       let n = 0;
    152       n < 100 &&
    153       headResolutionSnapshot(resolver)[0].coverage !== 'bounded-eose';
    154       n++
    155     )
    156       await new Promise((resolve) => setTimeout(resolve, 5));
    157     assert.equal(filters.length, 2);
    158     const head = filters.find((q) => (q.kinds as number[])[0] === 30402)!;
    159     const requests = filters.find((q) => (q.kinds as number[])[0] === 5)!;
    160     assert.deepEqual(head.authors, [previous.pubkey]);
    161     assert.deepEqual(head['#d'], [base.tags.find((t) => t[0] === 'd')![1]]);
    162     assert.deepEqual(requests.authors, [previous.pubkey]);
    163     for (const q of filters) {
    164       assert.equal(q.limit, 200);
    165       assert.equal('q' in q, false);
    166       assert.equal('search' in q, false);
    167       assert.equal('since' in q, false);
    168       assert.equal('#k' in q, false);
    169     }
    170     const row = headResolutionSnapshot(resolver)[0];
    171     assert.equal(row.coverage, 'bounded-eose');
    172     assert.equal(row.lastKnown, false);
    173     assert.equal(row.state.head.id, current.id);
    174     assert.equal(row.state.food, undefined);
    175     assert.equal(row.deletion.outcome, 'suppressed');
    176     assert.equal(row.deletionProofs.length, 1);
    177     assert.equal(row.definitiveAbsence, false);
    178     assert.equal(publicRunSnapshot(run).ingress.deliveries, 3);
    179     assert.equal(publicRunSnapshot(run).activeRequests, 0);
    180     closePublicRuntime(context);
    181     assert.equal(headResolutionSnapshot(resolver)[0].lastKnown, true);
    182   } finally {
    183     closePublicRuntime(context);
    184     key.fill(0);
    185     globalThis.WebSocket = oldSocket;
    186     if (oldWindow) Object.defineProperty(globalThis, 'window', oldWindow);
    187     else delete (globalThis as { window?: unknown }).window;
    188     for (const socket of sockets) socket.terminate();
    189     await new Promise<void>((resolve, reject) =>
    190       server.close((error) => (error ? reject(error) : resolve()))
    191     );
    192   }
    193 });