Add vitest tests and CI improvements for Node SDKs

Introduces vitest-based test suites for proofkit and verifier Node packages, including tests for canonical note building, JCS encoding, publishing, and verification logic. Updates package.json scripts to include 'test' for both packages. Simplifies CI workflow to always run tests if present. Minor Python test imports updated for type checking.

Author: AnVenDev

.github/workflows/ci-sdks.yml

@@ -41,34 +41,25 @@ jobs:
     strategy:
       matrix:
         node-version: ["18", "20"]
-
+  
     steps:
-      - name: Checkout code
+      - name: Checkout repo
         uses: actions/checkout@v4
-
+  
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
-
+  
       - name: Test @axiomatic_oracle/proofkit
         run: |
           cd packages_node/proofkit
           npm install
-          echo "Checking for test script in @axiomatic_oracle/proofkit..."
-          if npm run | grep -q " test"; then
-            npm test
-          else
-            echo "No 'test' script found for @axiomatic_oracle/proofkit, skipping tests for now."
-          fi
-
+          npm test
+  
       - name: Test @axiomatic_oracle/verifier
         run: |
           cd packages_node/verifier
           npm install
-          echo "Checking for test script in @axiomatic_oracle/verifier..."
-          if npm run | grep -q " test"; then
-            npm test
-          else
-            echo "No 'test' script found for @axiomatic_oracle/verifier, skipping tests for now."
-          fi
+          npm test
+

packages_node/proofkit/package.json

@@ -14,7 +14,8 @@
   "files": ["dist"],
   "sideEffects": false,
   "scripts": {
-    "build": "tsc -p tsconfig.json"
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
   },
   "engines": {
   "node": ">=18"

packages_node/proofkit/tests/proofkit.build_p1_and_hash.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect } from "vitest";
+import { Buffer } from "node:buffer";
+import {
+  NOTE_MAX_BYTES,
+  buildP1,
+  canonicalNoteBytesP1,
+  assertNoteSizeOK,
+  buildCanonicalInput,
+  computeInputHash,
+} from "../src/index.js";
+import { jcsSha256 } from "../src/jcs.js"
+
+describe("buildP1 / canonical note / input hashing (proofkit)", () => {
+  it("builds a valid p1 object with expected fields", () => {
+    const p1 = buildP1({
+      assetTag: "re:EUR",
+      modelVersion: "model-v1",
+      modelHashHex: "0".repeat(64),
+      inputHashHex: "1".repeat(64),
+      valueEUR: 123_456.78,
+      uncertaintyLowEUR: 120_000,
+      uncertaintyHighEUR: 130_000,
+      timestampEpochSec: 1_700_000_000,
+    });
+
+    expect(p1.s).toBe("p1");
+    expect(p1.a).toBe("re:EUR");
+    expect(p1.mv).toBe("model-v1");
+    expect(p1.mh).toBe("0".repeat(64));
+    expect(p1.ih).toBe("1".repeat(64));
+    expect(typeof p1.v).toBe("number");
+    expect(p1.u).toEqual([120_000, 130_000]);
+    expect(p1.ts).toBe(1_700_000_000);
+  });
+
+  it("rejects invalid hex hashes and intervals", () => {
+    // bad model hash
+    expect(() =>
+      buildP1({
+        assetTag: "re:EUR",
+        modelVersion: "model-v1",
+        modelHashHex: "xyz",
+        inputHashHex: "1".repeat(64),
+        valueEUR: 1,
+        uncertaintyLowEUR: 0,
+        uncertaintyHighEUR: 2,
+        timestampEpochSec: 1_700_000_000,
+      }),
+    ).toThrow(/modelHashHex/i);
+
+    // bad input hash
+    expect(() =>
+      buildP1({
+        assetTag: "re:EUR",
+        modelVersion: "model-v1",
+        modelHashHex: "0".repeat(64),
+        inputHashHex: "!",
+        valueEUR: 1,
+        uncertaintyLowEUR: 0,
+        uncertaintyHighEUR: 2,
+        timestampEpochSec: 1_700_000_000,
+      }),
+    ).toThrow(/inputHashHex/i);
+
+    // invalid interval
+    expect(() =>
+      buildP1({
+        assetTag: "re:EUR",
+        modelVersion: "model-v1",
+        modelHashHex: "0".repeat(64),
+        inputHashHex: "1".repeat(64),
+        valueEUR: 1,
+        uncertaintyLowEUR: 200,
+        uncertaintyHighEUR: 100,
+        timestampEpochSec: 1_700_000_000,
+      }),
+    ).toThrow(/uncertainty/i);
+  });
+
+  it("produces stable canonical note bytes and hash", async () => {
+    const base = {
+      assetTag: "re:EUR",
+      modelVersion: "model-v1",
+      modelHashHex: "0".repeat(64),
+      inputHashHex: "1".repeat(64),
+      valueEUR: 123_456.78,
+      uncertaintyLowEUR: 120_000,
+      uncertaintyHighEUR: 130_000,
+      timestampEpochSec: 1_700_000_000,
+    };
+
+    const p1a = buildP1(base);
+    const p1b = buildP1({ ...base });
+
+    const noteA = await canonicalNoteBytesP1(p1a);
+    const noteB = await canonicalNoteBytesP1(p1b);
+
+    expect(noteA.size).toBe(noteA.bytes.length);
+    expect(noteB.size).toBe(noteB.bytes.length);
+
+    expect(Buffer.from(noteA.bytes).toString("utf8")).toBe(
+      Buffer.from(noteB.bytes).toString("utf8"),
+    );
+    expect(noteA.sha256).toBe(noteB.sha256);
+  });
+
+  it("enforces NOTE_MAX_BYTES via assertNoteSizeOK", async () => {
+    const p1 = buildP1({
+      assetTag: "re:EUR",
+      modelVersion: "model-v1",
+      modelHashHex: "0".repeat(64),
+      inputHashHex: "1".repeat(64),
+      valueEUR: 1,
+      uncertaintyLowEUR: 0,
+      uncertaintyHighEUR: 2,
+      timestampEpochSec: 1_700_000_000,
+    });
+
+    // Should not throw with default NOTE_MAX_BYTES
+    await expect(assertNoteSizeOK(p1)).resolves.toBeUndefined();
+    expect(NOTE_MAX_BYTES).toBeGreaterThan(0);
+
+    // Force a failure with an artificially tiny limit
+    await expect(assertNoteSizeOK(p1, 1)).rejects.toThrow(/too large/i);
+  });
+
+  it("buildCanonicalInput filters and strips fields as expected", async () => {
+    const rec = {
+      keep: 1,
+      drop: 2,
+      skipNull: null,
+      skipUndef: undefined as unknown,
+    };
+
+    const allowed = ["keep", "skipNull", "skipUndef"];
+    const cin = buildCanonicalInput(rec, allowed);
+
+    expect(cin).toEqual({ keep: 1 });
+
+    const hash1 = await computeInputHash(rec, allowed);
+    const hash2 = await jcsSha256(cin);
+
+    expect(hash1).toBe(hash2);
+  });
+});

packages_node/proofkit/tests/proofkit.jcs.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect } from "vitest";
+import { toJcsBytes, jcsSha256 } from "../src/jcs.js";
+
+const td = new TextDecoder();
+
+/**
+ * Helper to decode JCS bytes into a UTF-8 string.
+ */
+function jcsString(obj: unknown): string {
+  return td.decode(toJcsBytes(obj));
+}
+
+describe("JCS / canonical JSON (proofkit)", () => {
+  it("produces identical canonical JSON for equivalent objects", async () => {
+    const obj1 = {
+      s: "p1",
+      a: "re:EUR",
+      mv: "model-v1",
+      mh: "0".repeat(64),
+      ih: "1".repeat(64),
+      v: 100.0,
+      u: [90.0, 110.0],
+      ts: 1_700_000_000,
+      nested: {
+        z: 3,
+        a: 1,
+      },
+    };
+
+    // Same logical content, different key ordering
+    const obj2 = {
+      nested: {
+        a: 1,
+        z: 3,
+      },
+      u: [90.0, 110.0],
+      v: 100.0,
+      ih: "1".repeat(64),
+      mh: "0".repeat(64),
+      mv: "model-v1",
+      a: "re:EUR",
+      s: "p1",
+      ts: 1_700_000_000,
+    };
+
+    const s1 = jcsString(obj1);
+    const s2 = jcsString(obj2);
+
+    expect(s1).toBe(s2);
+
+    const h1 = await jcsSha256(obj1);
+    const h2 = await jcsSha256(obj2);
+
+    expect(h1).toBe(h2);
+  });
+
+  it("normalizes undefined to null in canonical JSON", () => {
+    const obj = { a: undefined as unknown, b: 1 };
+    const s = jcsString(obj);
+
+    // JCS-style: undefined → null
+    expect(s).toBe('{"a":null,"b":1}');
+  });
+
+  it("rejects non-finite numbers", () => {
+    const badValues = [NaN, Infinity, -Infinity];
+
+    for (const x of badValues) {
+      const obj = { v: x };
+      expect(() => toJcsBytes(obj)).toThrow(/Non-finite float/);
+    }
+  });
+
+  it("encodes bigint values as decimal strings", () => {
+    const obj = { big: 42n };
+    const s = jcsString(obj);
+
+    // Key ordering is deterministic: {"big":"42"}
+    expect(s).toBe('{"big":"42"}');
+  });
+});