@mikeargento/bitgraph 1.1.0

package/src/__tests__/proof-hash-regression.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Regression test: all code paths must produce identical proofHash.
+ *
+ * Simulates the hash computation as done by:
+ *   1. computeProofHash() from bitgraph (canonical)
+ *   2. Inline signed-body + canonicalize + sha256 (how ledger s3.ts USED to do it)
+ *   3. Any other path
+ *
+ * If these ever diverge, this test fails.
+ */
+import { describe, it } from "node:test";
+import * as assert from "node:assert/strict";
+import { sha256 } from "@noble/hashes/sha256";
+import { computeProofHash, canonicalize } from "../index.js";
+
+// Realistic proof — mirrors what the TEE actually produces
+const REALISTIC_PROOF = {
+  version: "bitgraph/1" as const,
+  artifact: {
+    hashAlg: "sha256" as const,
+    digestB64: "NkYJQ1Gi0hE0SIhv6c46MlqJdurmKHtbScOprDfoL6A=",
+  },
+  commit: {
+    nonceB64: "z1272XEvkMtibuBP0qG3oY37cewo6cJ/o1AuigOSVOk=",
+    counter: "1370",
+    slotCounter: "1369",
+    slotHashB64: "8IyrBOGB64ppP/RETEZTYyYesF5bfcwJ5dI9+u7r2yY=",
+    epochId: "7jU4N9703cm6A2t8YNoGsyOvbdePDpoaD8AKCFs7wko=",
+    prevB64: "KsJfA3MinpSwF+t4GuxU9vLmmaqAK8FhzhaepEnJBDc=",
+    chainId: "bitgraph:main",
+  },
+  signer: {
+    publicKeyB64: "9XjqKDS+e8NhhNoBqbisCKHpaR/HK6hH0x5AKdwc56w=",
+    signatureB64: "wbhAtN1dcF2nESBDB0sCQ4ebuZCav8ziLivYgofh7cXeupw5H97VyovHN4I/R9uS0vNaoPIP8js8uTkZnn/IBA==",
+  },
+  environment: {
+    enforcement: "measured-tee",
+    measurement: "638d655ad6091bed5c358628b7780de0cdbe138a37fe09d52bf8021a720680a2b3c730fee9f6bef79c1dbe68ef3cdd94",
+    attestation: {
+      format: "aws-nitro",
+      reportB64: "hEShATgioFkR...(truncated for test)",
+    },
+  },
+  slotAllocation: {
+    version: "bitgraph/slot/1" as const,
+    nonceB64: "z1272XEvkMtibuBP0qG3oY37cewo6cJ/o1AuigOSVOk=",
+    counter: "1369",
+    epochId: "7jU4N9703cm6A2t8YNoGsyOvbdePDpoaD8AKCFs7wko=",
+    publicKeyB64: "9XjqKDS+e8NhhNoBqbisCKHpaR/HK6hH0x5AKdwc56w=",
+    chainId: "bitgraph:main",
+    signatureB64: "yO34pHfmkjGY6HgDxcPIaFd/lnt/UFZuHQa10LmUvTHgsQP3S3bIEJX/xcXPRENKZ9duVe7c+81rAWdmhiRMBg==",
+  },
+  attribution: {
+    name: "Ethereum Anchor",
+    title: "https://etherscan.io/block/24800448",
+    message: "0x28ed3639cd705fb8cb2b915c1991e9f808b40e775bc8eb540702942729fec2c0",
+  },
+};
+
+/**
+ * Inline signed-body hash — the OLD way ledger s3.ts computed it.
+ * This must produce the same result as computeProofHash().
+ */
+function inlineSignedBodyHash(proof: Record<string, unknown>): string {
+  const signer = proof.signer as { publicKeyB64: string };
+  const env = proof.environment as { enforcement: string; measurement: string; attestation?: { format: string } };
+
+  const signedBody: Record<string, unknown> = {
+    version: proof.version,
+    artifact: proof.artifact,
+    commit: proof.commit,
+    publicKeyB64: signer.publicKeyB64,
+    enforcement: env.enforcement,
+    measurement: env.measurement,
+  };
+  if (proof.attribution) signedBody.attribution = proof.attribution;
+  if (env.attestation) signedBody.attestationFormat = env.attestation.format;
+
+  return Buffer.from(sha256(canonicalize(signedBody))).toString("base64");
+}
+
+describe("proof hash regression — all paths must agree", () => {
+  it("computeProofHash matches inline signed-body hash (with attribution)", () => {
+    const canonical = computeProofHash(REALISTIC_PROOF);
+    const inline = inlineSignedBodyHash(REALISTIC_PROOF);
+    assert.equal(canonical, inline, "hash drift detected: computeProofHash vs inline");
+  });
+
+  it("computeProofHash matches inline signed-body hash (without attribution)", () => {
+    const noAttr = { ...REALISTIC_PROOF } as Record<string, unknown>;
+    delete noAttr.attribution;
+    const canonical = computeProofHash(noAttr);
+    const inline = inlineSignedBodyHash(noAttr);
+    assert.equal(canonical, inline, "hash drift detected without attribution");
+  });
+
+  it("computeProofHash matches inline signed-body hash (without attestation)", () => {
+    const noAttest = {
+      ...REALISTIC_PROOF,
+      environment: {
+        enforcement: REALISTIC_PROOF.environment.enforcement,
+        measurement: REALISTIC_PROOF.environment.measurement,
+      },
+    };
+    const canonical = computeProofHash(noAttest);
+    const inline = inlineSignedBodyHash(noAttest);
+    assert.equal(canonical, inline, "hash drift detected without attestation");
+  });
+
+  it("anchor proof and user proof use the same hash function", () => {
+    // User proof (no attribution)
+    const userProof = { ...REALISTIC_PROOF } as Record<string, unknown>;
+    delete userProof.attribution;
+
+    // Anchor proof (has attribution)
+    const anchorProof = REALISTIC_PROOF;
+
+    // Both should work with the same function
+    const userHash = computeProofHash(userProof);
+    const anchorHash = computeProofHash(anchorProof);
+
+    // They should be different (different inputs) but both valid
+    assert.notEqual(userHash, anchorHash, "user and anchor proofs with different data should differ");
+    assert.equal(Buffer.from(userHash, "base64").length, 32, "user hash should be SHA-256");
+    assert.equal(Buffer.from(anchorHash, "base64").length, 32, "anchor hash should be SHA-256");
+  });
+
+  it("adding slotAllocation or metadata does not change hash", () => {
+    const bare = { ...REALISTIC_PROOF } as Record<string, unknown>;
+    delete bare.slotAllocation;
+
+    const withSlot = { ...REALISTIC_PROOF };
+
+    const withMetadata = {
+      ...REALISTIC_PROOF,
+      metadata: { type: "ethereum-anchor", extra: true },
+      timestamps: { artifact: { time: 1234567890 } },
+    };
+
+    const bareHash = computeProofHash(bare);
+    const withSlotHash = computeProofHash(withSlot);
+    const withMetaHash = computeProofHash(withMetadata);
+
+    assert.equal(bareHash, withSlotHash, "slotAllocation should not affect hash");
+    assert.equal(bareHash, withMetaHash, "metadata/timestamps should not affect hash");
+  });
+});

package/src/__tests__/proof-hash.test.ts

@@ -0,0 +1,148 @@
+import { describe, it } from "node:test";
+import * as assert from "node:assert/strict";
+import { sha256 } from "@noble/hashes/sha256";
+import { computeProofHash, canonicalize } from "../index.js";
+import type { BitGraphProof } from "../index.js";
+
+const MOCK_PROOF: BitGraphProof = {
+  version: "bitgraph/1",
+  artifact: { hashAlg: "sha256", digestB64: "abc123==" },
+  commit: {
+    nonceB64: "nonce==",
+    counter: "42",
+    slotCounter: "41",
+    epochId: "epoch==",
+    prevB64: "prev==",
+  },
+  signer: {
+    publicKeyB64: "pubkey==",
+    signatureB64: "sig==",
+  },
+  environment: {
+    enforcement: "measured-tee",
+    measurement: "pcr0hash",
+    attestation: { format: "aws-nitro", reportB64: "report==" },
+  },
+  attribution: { name: "test", message: "hello" },
+};
+
+describe("computeProofHash", () => {
+  it("produces base64-encoded SHA-256", () => {
+    const hash = computeProofHash(MOCK_PROOF);
+    // Base64 of SHA-256 is always 44 chars (with padding)
+    assert.ok(hash.length > 0 && hash.length <= 44, `unexpected hash length: ${hash.length}`);
+    // Valid base64
+    const decoded = Buffer.from(hash, "base64");
+    assert.equal(decoded.length, 32, "SHA-256 output should be 32 bytes");
+  });
+
+  it("matches manual signed-body computation", () => {
+    const signedBody: Record<string, unknown> = {
+      version: MOCK_PROOF.version,
+      artifact: MOCK_PROOF.artifact,
+      commit: MOCK_PROOF.commit,
+      publicKeyB64: MOCK_PROOF.signer.publicKeyB64,
+      enforcement: MOCK_PROOF.environment.enforcement,
+      measurement: MOCK_PROOF.environment.measurement,
+      attribution: MOCK_PROOF.attribution,
+      attestationFormat: MOCK_PROOF.environment.attestation!.format,
+    };
+    const expected = Buffer.from(sha256(canonicalize(signedBody))).toString("base64");
+    const actual = computeProofHash(MOCK_PROOF);
+    assert.equal(actual, expected, "computeProofHash must match manual signed-body hash");
+  });
+
+  it("is deterministic — same input always produces same output", () => {
+    const a = computeProofHash(MOCK_PROOF);
+    const b = computeProofHash(MOCK_PROOF);
+    assert.equal(a, b);
+  });
+
+  it("is not affected by key ordering in input", () => {
+    // Construct same proof with keys in different order
+    const reordered = {
+      environment: MOCK_PROOF.environment,
+      version: MOCK_PROOF.version,
+      signer: MOCK_PROOF.signer,
+      artifact: MOCK_PROOF.artifact,
+      commit: MOCK_PROOF.commit,
+      attribution: MOCK_PROOF.attribution,
+    } as unknown as BitGraphProof;
+    assert.equal(computeProofHash(reordered), computeProofHash(MOCK_PROOF));
+  });
+
+  it("is not affected by metadata (outside signed body)", () => {
+    const withMetadata = {
+      ...MOCK_PROOF,
+      metadata: { extra: "stuff", nested: { deep: true } },
+      timestamps: { artifact: { time: 12345 } },
+    } as unknown as BitGraphProof;
+    assert.equal(computeProofHash(withMetadata), computeProofHash(MOCK_PROOF));
+  });
+
+  it("is not affected by signatureB64 (not in signed body)", () => {
+    const differentSig = {
+      ...MOCK_PROOF,
+      signer: { ...MOCK_PROOF.signer, signatureB64: "completely-different-sig==" },
+    } as BitGraphProof;
+    assert.equal(computeProofHash(differentSig), computeProofHash(MOCK_PROOF));
+  });
+
+  it("is not affected by attestation reportB64 (not in signed body)", () => {
+    const differentReport = {
+      ...MOCK_PROOF,
+      environment: {
+        ...MOCK_PROOF.environment,
+        attestation: { format: "aws-nitro", reportB64: "totally-different==" },
+      },
+    } as BitGraphProof;
+    assert.equal(computeProofHash(differentReport), computeProofHash(MOCK_PROOF));
+  });
+
+  it("changes when artifact changes", () => {
+    const different = {
+      ...MOCK_PROOF,
+      artifact: { hashAlg: "sha256" as const, digestB64: "different==" },
+    };
+    assert.notEqual(computeProofHash(different), computeProofHash(MOCK_PROOF));
+  });
+
+  it("changes when counter changes", () => {
+    const different = {
+      ...MOCK_PROOF,
+      commit: { ...MOCK_PROOF.commit, counter: "99" },
+    };
+    assert.notEqual(computeProofHash(different), computeProofHash(MOCK_PROOF));
+  });
+
+  it("changes when publicKeyB64 changes", () => {
+    const different = {
+      ...MOCK_PROOF,
+      signer: { ...MOCK_PROOF.signer, publicKeyB64: "different-key==" },
+    } as BitGraphProof;
+    assert.notEqual(computeProofHash(different), computeProofHash(MOCK_PROOF));
+  });
+
+  it("includes attribution when present", () => {
+    const without = { ...MOCK_PROOF } as Record<string, unknown>;
+    delete without.attribution;
+    assert.notEqual(computeProofHash(without), computeProofHash(MOCK_PROOF));
+  });
+
+  it("includes attestationFormat when present", () => {
+    const withoutAttestation = {
+      ...MOCK_PROOF,
+      environment: {
+        enforcement: MOCK_PROOF.environment.enforcement,
+        measurement: MOCK_PROOF.environment.measurement,
+      },
+    } as BitGraphProof;
+    assert.notEqual(computeProofHash(withoutAttestation), computeProofHash(MOCK_PROOF));
+  });
+
+  it("works with Record<string, unknown> input (not just BitGraphProof)", () => {
+    const record: Record<string, unknown> = { ...MOCK_PROOF };
+    const hash = computeProofHash(record);
+    assert.equal(hash, computeProofHash(MOCK_PROOF));
+  });
+});