app

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

food-corpus.test.ts (6546B)


      1 import assert from 'node:assert/strict';
      2 import { createHash } from 'node:crypto';
      3 import { lstat, readFile } from 'node:fs/promises';
      4 import test from 'node:test';
      5 import { getEventHash, verifyEvent } from 'applesauce-core/helpers';
      6 import type { NostrEvent } from 'applesauce-core/helpers';
      7 
      8 const root = new URL(
      9   '../../../contracts/interop/food_availability/',
     10   import.meta.url
     11 );
     12 const revision = '189c49b74b4bafc142b00b76b296477931139e72';
     13 const sourceHash =
     14   'dede1eb1f682ecd548e8cd3ccb251d298762e504e2588a73528e5f7a5b9eff21';
     15 const digest = (bytes: Uint8Array) =>
     16   createHash('sha256').update(bytes).digest('hex');
     17 
     18 interface Vector {
     19   id: string;
     20   kind: string;
     21   input: Record<string, unknown>;
     22   expected: Record<string, unknown>;
     23   signed_wires: Record<string, string>;
     24   unsigned_wire_parts: {
     25     kind: number;
     26     content: string;
     27     tags: string[][];
     28   } | null;
     29 }
     30 interface Corpus {
     31   revision: string;
     32   source_sha256: string;
     33   vectors: Vector[];
     34 }
     35 interface Descriptor {
     36   path: string;
     37   sha256: string;
     38   bytes: number;
     39 }
     40 interface Provenance {
     41   schema_version: number;
     42   public_source: { revision: string; repository: string; sha256: string };
     43   source_copy: Descriptor;
     44   corpus: Descriptor;
     45   producer: { files: Descriptor[]; rust_toolchain: string };
     46   protocol_references: {
     47     nip: string;
     48     revision: string;
     49     url: string;
     50     sha256: string;
     51   }[];
     52 }
     53 
     54 async function input(name: string) {
     55   const file = new URL(name, root);
     56   const info = await lstat(file);
     57   assert.ok(info.isFile() && !info.isSymbolicLink());
     58   assert.ok(info.size > 0 && info.size <= 1024 * 1024);
     59   const bytes = await readFile(file);
     60   assert.equal(bytes.length, info.size);
     61   return bytes;
     62 }
     63 
     64 const sourceBytes = await input('source_profile.v1.json');
     65 const corpusBytes = await input('corpus.v1.json');
     66 const source = JSON.parse(sourceBytes.toString()) as Corpus;
     67 const corpus = JSON.parse(corpusBytes.toString()) as Corpus;
     68 const provenance = JSON.parse(
     69   (await input('provenance.v1.json')).toString()
     70 ) as Provenance;
     71 
     72 void test('public Food corpus and isolated producer retain exact pinned byte provenance', async () => {
     73   assert.equal(provenance.schema_version, 1);
     74   assert.equal(
     75     provenance.public_source.repository,
     76     'https://github.com/radrootslabs/lib'
     77   );
     78   assert.equal(provenance.public_source.revision, revision);
     79   assert.equal(provenance.public_source.sha256, sourceHash);
     80   assert.equal(digest(sourceBytes), sourceHash);
     81   assert.equal(corpus.revision, revision);
     82   assert.equal(corpus.source_sha256, sourceHash);
     83   assert.equal(provenance.source_copy.path, 'source_profile.v1.json');
     84   assert.equal(provenance.source_copy.sha256, digest(sourceBytes));
     85   assert.equal(provenance.source_copy.bytes, sourceBytes.length);
     86   assert.equal(provenance.corpus.path, 'corpus.v1.json');
     87   assert.equal(provenance.corpus.sha256, digest(corpusBytes));
     88   assert.equal(provenance.corpus.bytes, corpusBytes.length);
     89   assert.equal(provenance.producer.rust_toolchain, '1.99.0');
     90   assert.deepEqual(provenance.producer.files.map((row) => row.path).sort(), [
     91     'oracle/Cargo.lock',
     92     'oracle/Cargo.toml',
     93     'oracle/rust-toolchain.toml',
     94     'oracle/src/main.rs'
     95   ]);
     96   for (const row of provenance.producer.files) {
     97     const bytes = await input(row.path);
     98     assert.equal(digest(bytes), row.sha256, row.path);
     99     assert.equal(bytes.length, row.bytes, row.path);
    100   }
    101   assert.deepEqual(
    102     provenance.protocol_references.map((row) => row.nip),
    103     ['01', '07', '09', '17', '19', '42', '44', '50', '59', '99']
    104   );
    105   for (const row of provenance.protocol_references) {
    106     assert.equal(row.revision, '0046368a747c5c25ae2bec28bae0e537744c8f10');
    107     assert.equal(
    108       row.url,
    109       `https://raw.githubusercontent.com/nostr-protocol/nips/${row.revision}/${row.nip}.md`
    110     );
    111     assert.match(row.sha256, /^[0-9a-f]{64}$/u);
    112   }
    113 });
    114 
    115 void test('all forty public cases retain original input and Rust outcome coverage', () => {
    116   assert.equal(source.vectors.length, 40);
    117   assert.equal(corpus.vectors.length, 40);
    118   assert.equal(new Set(corpus.vectors.map((row) => row.id)).size, 40);
    119   for (const [index, row] of corpus.vectors.entries()) {
    120     const original = source.vectors[index];
    121     assert.equal(row.id, original.id);
    122     assert.equal(row.kind, original.kind);
    123     assert.deepEqual(row.input, original.input, row.id);
    124     assert.deepEqual(row.expected, original.expected, row.id);
    125   }
    126   for (const id of [
    127     'food_admission_normalizes_decimal_currency_014',
    128     'food_admission_excludes_operational_before_validation_016',
    129     'food_admission_excludes_generic_nip99_017',
    130     'food_admission_rejects_ambiguous_markers_018',
    131     'food_admission_rejects_invalid_signature_031',
    132     'food_revision_equal_time_a_current_039',
    133     'food_revision_equal_time_b_current_040'
    134   ])
    135     assert.ok(
    136       corpus.vectors.some((row) => row.id === id),
    137       id
    138     );
    139 });
    140 
    141 void test('actual Applesauce verifies the Rust-read signed wire bytes and rejects the signature control', () => {
    142   let wires = 0;
    143   let rejected = 0;
    144   for (const row of corpus.vectors) {
    145     for (const [field, raw] of Object.entries(row.signed_wires)) {
    146       const event = JSON.parse(raw) as NostrEvent;
    147       assert.deepEqual(event, row.input[field], row.id);
    148       assert.ok(
    149         Number.isSafeInteger(event.created_at) && event.created_at >= 0
    150       );
    151       assert.ok(
    152         Number.isSafeInteger(event.kind) &&
    153           event.kind >= 0 &&
    154           event.kind <= 65535
    155       );
    156       assert.equal(getEventHash(event), event.id, row.id);
    157       const invalid = row.id === 'food_admission_rejects_invalid_signature_031';
    158       assert.equal(verifyEvent(event), !invalid, row.id);
    159       if (invalid) rejected++;
    160       wires++;
    161     }
    162   }
    163   assert.equal(wires, 36);
    164   assert.equal(rejected, 1);
    165 });
    166 
    167 void test('eleven actual Rust unsigned outputs preserve complete content and tags', () => {
    168   let outputs = 0;
    169   for (const row of corpus.vectors) {
    170     const wire = row.unsigned_wire_parts;
    171     if (wire === null) continue;
    172     assert.equal(row.kind, 'food_availability.build_authored_draft.valid');
    173     assert.equal(wire.kind, 30402);
    174     const expected = row.expected.wire_parts as Record<string, unknown>;
    175     assert.deepEqual(wire.tags, expected.tags);
    176     if ('content_length' in expected) {
    177       assert.equal(
    178         new TextEncoder().encode(wire.content).length,
    179         expected.content_length
    180       );
    181     } else {
    182       assert.equal(wire.content, expected.content);
    183     }
    184     outputs++;
    185   }
    186   assert.equal(outputs, 11);
    187 });