@mikeargento/bitgraph 1.9.1 → 1.10.0

package/src/__tests__/audit-witness.test.ts

@@ -1,345 +0,0 @@
-// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
-
-/**
- * Anchor witness verification tests (bundle spec section 10.3).
- *
- * The synthetic header is a 20-item RLP list with the block number at
- * index 8 and the timestamp at index 11; its Keccak-256 hash is the
- * "block hash", the anchor's signed attribution.message is that hash,
- * and the anchor's artifact digest is SHA-256 over the hash STRING,
- * exactly like bitcoin-anchor.ts. Full verification yields the header
- * timestamp; every single-point corruption fails with its own stable
- * reason and confers nothing.
- */
-
-import { describe, it } from "node:test";
-import * as assert from "node:assert/strict";
-import { keccak_256 } from "@noble/hashes/sha3";
-import { sha256 } from "@noble/hashes/sha256";
-import {
-  identifyAnchors,
-  ingestBundle,
-  verifyAnchorWitness,
-  verifyAnchorWitnesses,
-  verifyObservedProofs,
-} from "@mikeargento/bitgraph-audit";
-import type { AnchorIdentification, IngestResult } from "@mikeargento/bitgraph-audit";
-import {
-  b64,
-  makeAnchorProof,
-  makeEthereumHeader,
-  makeTempDir,
-  proofJson,
-  utf8,
-  witnessJson,
-  writeBundleDir,
-} from "./audit-fixtures.js";
-
-const BLOCK_NUMBER = 24800448;
-const TIMESTAMP = 1750000000;
-
-const HEADER = makeEthereumHeader({ blockNumber: BLOCK_NUMBER, timestamp: TIMESTAMP });
-const BLOCK_HASH = `0x${Buffer.from(keccak_256(HEADER.headerBytes)).toString("hex")}`;
-
-async function pipeline(
-  files: Record<string, string | Uint8Array>
-): Promise<{ ingest: IngestResult; anchors: AnchorIdentification }> {
-  const dir = await makeTempDir("bg-audit-witness-");
-  await writeBundleDir(dir, files);
-  const ingest = await ingestBundle(dir);
-  await verifyObservedProofs(ingest);
-  return { ingest, anchors: identifyAnchors(ingest) };
-}
-
-function goodWitness(): string {
-  return witnessJson({
-    headerRlpHex: HEADER.headerRlpHex,
-    blockNumber: BLOCK_NUMBER,
-    blockHash: BLOCK_HASH,
-    network: "ethereum-mainnet",
-  });
-}
-
-describe("audit witness: full verification", () => {
-  it("passes every step and yields the header timestamp as the only wall-clock evidence", async () => {
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W1",
-      counter: "4",
-      slotCounter: "3",
-    });
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/w.json": goodWitness(),
-    });
-
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    assert.equal(analysis.outcomes.length, 1);
-    const outcome = analysis.outcomes[0]!;
-    assert.equal(outcome.verified, true);
-    assert.equal(outcome.anchorProofHash, anchor.proofHash);
-    assert.equal(outcome.computedBlockHash, BLOCK_HASH);
-    assert.equal(outcome.blockNumber, String(BLOCK_NUMBER));
-    assert.equal(outcome.timestamp, TIMESTAMP);
-    assert.equal(outcome.reason, undefined);
-    assert.equal(analysis.findings.length, 0);
-  });
-
-  it("compares the hash case-insensitively but binds the digest to the exact signed string", async () => {
-    // The anchor signed an UPPERCASE hash string; the digest covers that
-    // exact string. Step 3 lowercases for comparison, step 4 does not.
-    const upper = `0x${BLOCK_HASH.slice(2).toUpperCase()}`;
-    const anchor = await makeAnchorProof({
-      blockHash: upper,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W2",
-      counter: "2",
-    });
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/w.json": goodWitness(),
-    });
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    assert.equal(analysis.outcomes.length, 1);
-    assert.equal(analysis.outcomes[0]!.verified, true);
-    assert.equal(analysis.outcomes[0]!.timestamp, TIMESTAMP);
-  });
-});
-
-describe("audit witness: single-point corruptions fail with distinct stable reasons", () => {
-  it("wrong claimed blockHash: witness-claimed-hash-mismatch", async () => {
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W3",
-      counter: "2",
-    });
-    const wrongClaim = `0x${"ab".repeat(32)}`;
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/w.json": witnessJson({
-        headerRlpHex: HEADER.headerRlpHex,
-        blockNumber: BLOCK_NUMBER,
-        blockHash: wrongClaim,
-      }),
-    });
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    const outcome = analysis.outcomes[0]!;
-    assert.equal(outcome.verified, false);
-    assert.equal(outcome.reason, "witness-claimed-hash-mismatch");
-    assert.equal(outcome.timestamp, undefined, "a rejected witness confers nothing");
-    assert.ok(analysis.findings.some((f) => f.code === "witness-claimed-hash-mismatch"));
-  });
-
-  it("wrong artifact digest: witness-digest-mismatch", async () => {
-    // Validly signed anchor whose digest covers a different string, so the
-    // proof itself verifies but the message-to-digest binding fails.
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W4",
-      counter: "2",
-      digestB64: b64(sha256(utf8("some other committed artifact"))),
-    });
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/w.json": goodWitness(),
-    });
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    const outcome = analysis.outcomes[0]!;
-    assert.equal(outcome.verified, false);
-    assert.equal(outcome.reason, "witness-digest-mismatch");
-    assert.equal(outcome.timestamp, undefined);
-  });
-
-  it("wrong claimed blockNumber: witness-block-number-mismatch", async () => {
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W5",
-      counter: "2",
-    });
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/w.json": witnessJson({
-        headerRlpHex: HEADER.headerRlpHex,
-        blockNumber: BLOCK_NUMBER + 1,
-        blockHash: BLOCK_HASH,
-      }),
-    });
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    const outcome = analysis.outcomes[0]!;
-    assert.equal(outcome.verified, false);
-    assert.equal(outcome.reason, "witness-block-number-mismatch");
-    assert.match(outcome.detail as string, /witness claims blockNumber/);
-  });
-
-  it("signed Etherscan URL disagreeing with the header: witness-block-number-mismatch", async () => {
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER + 7),
-      epochId: "E-W6",
-      counter: "2",
-    });
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/w.json": goodWitness(),
-    });
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    const outcome = analysis.outcomes[0]!;
-    assert.equal(outcome.verified, false);
-    assert.equal(outcome.reason, "witness-block-number-mismatch");
-    assert.match(outcome.detail as string, /Etherscan URL/);
-  });
-
-  it("tampered RLP header bytes: witness-hash-mismatch", async () => {
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W7",
-      counter: "2",
-    });
-    // Flip content bytes in the middle: still well-formed RLP, different
-    // Keccak hash. The witness still reaches its intended anchor through
-    // the claimed hash and fails loudly at step 3.
-    const tampered =
-      HEADER.headerRlpHex.slice(0, 40) +
-      (HEADER.headerRlpHex[40] === "f" ? "e" : "f") +
-      HEADER.headerRlpHex.slice(41);
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/w.json": witnessJson({
-        headerRlpHex: tampered,
-        blockNumber: BLOCK_NUMBER,
-        blockHash: BLOCK_HASH,
-      }),
-    });
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    const outcome = analysis.outcomes[0]!;
-    assert.equal(outcome.verified, false);
-    assert.equal(outcome.reason, "witness-hash-mismatch");
-    assert.equal(outcome.timestamp, undefined);
-  });
-});
-
-describe("audit witness: malformed and unusable witnesses", () => {
-  it("field violations fail with witness-malformed", async () => {
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W8",
-      counter: "2",
-    });
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/no-header.json": witnessJson({
-        blockNumber: BLOCK_NUMBER,
-        blockHash: BLOCK_HASH,
-        omit: ["headerRlpHex"],
-      }),
-      "witnesses/string-number.json": witnessJson({
-        headerRlpHex: HEADER.headerRlpHex,
-        blockNumber: String(BLOCK_NUMBER),
-        blockHash: BLOCK_HASH,
-      }),
-      "witnesses/bad-hash-shape.json": witnessJson({
-        headerRlpHex: HEADER.headerRlpHex,
-        blockNumber: BLOCK_NUMBER,
-        blockHash: "28ed3639",
-      }),
-    });
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    assert.equal(analysis.outcomes.length, 3);
-    for (const outcome of analysis.outcomes) {
-      assert.equal(outcome.verified, false);
-      assert.equal(outcome.reason, "witness-malformed");
-      assert.equal(outcome.timestamp, undefined);
-    }
-  });
-
-  it("structurally invalid RLP fails with witness-rlp-invalid", async () => {
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W9",
-      counter: "2",
-    });
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      // 0xf9 declares a long list with a 2-byte length that never arrives.
-      "witnesses/w.json": witnessJson({
-        headerRlpHex: "0xf901",
-        blockNumber: BLOCK_NUMBER,
-        blockHash: BLOCK_HASH,
-      }),
-    });
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    assert.equal(analysis.outcomes[0]!.reason, "witness-rlp-invalid");
-  });
-
-  it("a witness matching no anchor is reported witness-unmatched", async () => {
-    const otherHeader = makeEthereumHeader({ blockNumber: 5, timestamp: 6 });
-    const otherHash = `0x${Buffer.from(keccak_256(otherHeader.headerBytes)).toString("hex")}`;
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W10",
-      counter: "2",
-    });
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/w.json": witnessJson({
-        headerRlpHex: otherHeader.headerRlpHex,
-        blockNumber: 5,
-        blockHash: otherHash,
-      }),
-    });
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    const outcome = analysis.outcomes[0]!;
-    assert.equal(outcome.verified, false);
-    assert.equal(outcome.reason, "witness-unmatched");
-    assert.equal(outcome.anchorProofHash, undefined);
-  });
-
-  it("a witness cannot rescue an invalid anchor: witness-anchor-invalid", async () => {
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W11",
-      counter: "2",
-    });
-    // Tamper the Ed25519 signature: the canonical identity is unchanged
-    // (the signature is outside the signed body) but the proof is invalid.
-    anchor.proof.signer.signatureB64 = `AA${anchor.proof.signer.signatureB64.slice(2)}`;
-    const { ingest, anchors } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/w.json": goodWitness(),
-    });
-    const analysis = await verifyAnchorWitnesses(ingest, anchors);
-    const outcome = analysis.outcomes[0]!;
-    assert.equal(outcome.verified, false);
-    assert.equal(outcome.reason, "witness-anchor-invalid");
-    assert.equal(outcome.timestamp, undefined);
-  });
-});
-
-describe("audit witness: direct single-pair API", () => {
-  it("verifyAnchorWitness runs the full procedure against one anchor", async () => {
-    const anchor = await makeAnchorProof({
-      blockHash: BLOCK_HASH,
-      blockNumber: String(BLOCK_NUMBER),
-      epochId: "E-W12",
-      counter: "2",
-    });
-    const { ingest } = await pipeline({
-      "proofs/anchor.json": proofJson(anchor.proof),
-      "witnesses/w.json": goodWitness(),
-    });
-    const observed = ingest.proofs.find((p) => p.proofHash === anchor.proofHash)!;
-    const witnessFile = ingest.witnesses[0]!;
-    const outcome = await verifyAnchorWitness(witnessFile, observed);
-    assert.equal(outcome.verified, true);
-    assert.equal(outcome.timestamp, TIMESTAMP);
-  });
-});

package/src/__tests__/canonical.test.ts

@@ -1,253 +0,0 @@
-// Copyright (c) Argento Computing Inc. All rights reserved. See LICENSE.
-
-import { describe, test } from "node:test";
-import * as assert from "node:assert/strict";
-import {
-  canonicalize,
-  canonicalizeToString,
-  constantTimeEqual,
-} from "../index.js";
-
-// ---------------------------------------------------------------------------
-// canonicalizeToString
-// ---------------------------------------------------------------------------
-
-describe("canonicalizeToString", () => {
-  // Primitives
-  test("null", () => assert.equal(canonicalizeToString(null), "null"));
-  test("true", () => assert.equal(canonicalizeToString(true), "true"));
-  test("false", () => assert.equal(canonicalizeToString(false), "false"));
-  test("integer", () => assert.equal(canonicalizeToString(42), "42"));
-  test("float", () => assert.equal(canonicalizeToString(3.14), "3.14"));
-  test("negative", () => assert.equal(canonicalizeToString(-1), "-1"));
-  test("zero", () => assert.equal(canonicalizeToString(0), "0"));
-  test("string", () => assert.equal(canonicalizeToString("hello"), '"hello"'));
-  test("empty string", () => assert.equal(canonicalizeToString(""), '""'));
-
-  // Object key ordering
-  test("sorts keys lexicographically", () => {
-    assert.equal(
-      canonicalizeToString({ z: 1, a: 2, m: 3 }),
-      '{"a":2,"m":3,"z":1}',
-    );
-  });
-
-  test("uppercase sorts before lowercase (Unicode code-point order)", () => {
-    assert.equal(canonicalizeToString({ b: 2, A: 1 }), '{"A":1,"b":2}');
-  });
-
-  test("sorts nested object keys recursively", () => {
-    assert.equal(
-      canonicalizeToString({ outer: { z: 1, a: 2 }, b: 3 }),
-      '{"b":3,"outer":{"a":2,"z":1}}',
-    );
-  });
-
-  test("empty object", () => assert.equal(canonicalizeToString({}), "{}"));
-
-  test("same output regardless of insertion order", () => {
-    const a = { z: 1, a: 2 };
-    const b = { a: 2, z: 1 };
-    assert.equal(canonicalizeToString(a), canonicalizeToString(b));
-  });
-
-  // Arrays
-  test("preserves array element order", () => {
-    assert.equal(canonicalizeToString([3, 1, 2]), "[3,1,2]");
-  });
-
-  test("sorts keys inside array elements", () => {
-    assert.equal(canonicalizeToString([{ b: 2, a: 1 }]), '[{"a":1,"b":2}]');
-  });
-
-  test("empty array", () => assert.equal(canonicalizeToString([]), "[]"));
-
-  test("nested arrays preserve order", () => {
-    assert.equal(
-      canonicalizeToString([[1, 2], [3, 4]]),
-      "[[1,2],[3,4]]",
-    );
-  });
-
-  // Undefined handling
-  test("skips undefined values in objects", () => {
-    const obj: Record<string, unknown> = { a: 1, c: 3 };
-    obj["b"] = undefined;
-    assert.equal(canonicalizeToString(obj), '{"a":1,"c":3}');
-  });
-
-  // Rejection of non-serializable types
-  test("throws TypeError for undefined", () => {
-    assert.throws(
-      () => canonicalizeToString(undefined as unknown),
-      TypeError,
-    );
-  });
-
-  test("throws TypeError for function", () => {
-    assert.throws(
-      () => canonicalizeToString((() => {}) as unknown),
-      TypeError,
-    );
-  });
-
-  test("throws TypeError for symbol", () => {
-    assert.throws(
-      () => canonicalizeToString(Symbol("x") as unknown),
-      TypeError,
-    );
-  });
-
-  test("throws TypeError for BigInt", () => {
-    assert.throws(
-      () => canonicalizeToString(BigInt(42) as unknown),
-      TypeError,
-    );
-  });
-
-  test("throws TypeError for BigInt inside object", () => {
-    assert.throws(
-      () => canonicalizeToString({ n: BigInt(1) } as unknown),
-      TypeError,
-    );
-  });
-
-  // NaN / Infinity → null (standard JSON.stringify behavior)
-  test("NaN serializes as null", () => {
-    assert.equal(canonicalizeToString(NaN), "null");
-  });
-
-  test("Infinity serializes as null", () => {
-    assert.equal(canonicalizeToString(Infinity), "null");
-  });
-
-  test("-Infinity serializes as null", () => {
-    assert.equal(canonicalizeToString(-Infinity), "null");
-  });
-
-  // Determinism
-  test("is deterministic across repeated calls", () => {
-    const obj = { c: 3, b: 2, a: 1 };
-    assert.equal(canonicalizeToString(obj), canonicalizeToString(obj));
-  });
-});
-
-// ---------------------------------------------------------------------------
-// canonicalize
-// ---------------------------------------------------------------------------
-
-describe("canonicalize", () => {
-  test("returns a Uint8Array", () => {
-    assert.ok(canonicalize({}) instanceof Uint8Array);
-  });
-
-  test("UTF-8 encodes the canonical JSON string", () => {
-    const bytes = canonicalize({ hello: "world" });
-    assert.equal(new TextDecoder().decode(bytes), '{"hello":"world"}');
-  });
-
-  test("matches TextEncoder(canonicalizeToString(obj))", () => {
-    const obj = { z: 1, a: 2 };
-    const bytes = canonicalize(obj);
-    const str = canonicalizeToString(obj);
-    assert.deepEqual(bytes, new TextEncoder().encode(str));
-  });
-
-  test("empty object → two bytes ('{' and '}')", () => {
-    assert.deepEqual(canonicalize({}), new TextEncoder().encode("{}"));
-  });
-
-  test("large payload round-trips through canonicalizeToString", () => {
-    const large: Record<string, number> = {};
-    for (let i = 0; i < 1000; i++) large[`key_${i}`] = i;
-    const bytes = canonicalize(large);
-    const str = canonicalizeToString(large);
-    assert.deepEqual(bytes, new TextEncoder().encode(str));
-  });
-
-  test("throws TypeError for BigInt nested inside object", () => {
-    assert.throws(() => canonicalize({ n: BigInt(1) } as unknown), TypeError);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// constantTimeEqual
-// ---------------------------------------------------------------------------
-
-describe("constantTimeEqual", () => {
-  test("equal non-empty arrays", () => {
-    assert.equal(
-      constantTimeEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3])),
-      true,
-    );
-  });
-
-  test("different content same length", () => {
-    assert.equal(
-      constantTimeEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 4])),
-      false,
-    );
-  });
-
-  test("different lengths", () => {
-    assert.equal(
-      constantTimeEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2])),
-      false,
-    );
-  });
-
-  test("empty arrays are equal", () => {
-    assert.equal(
-      constantTimeEqual(new Uint8Array([]), new Uint8Array([])),
-      true,
-    );
-  });
-
-  test("empty vs non-empty", () => {
-    assert.equal(
-      constantTimeEqual(new Uint8Array([]), new Uint8Array([0])),
-      false,
-    );
-  });
-
-  test("single byte equal", () => {
-    assert.equal(
-      constantTimeEqual(new Uint8Array([0xff]), new Uint8Array([0xff])),
-      true,
-    );
-  });
-
-  test("single byte different", () => {
-    assert.equal(
-      constantTimeEqual(new Uint8Array([0xff]), new Uint8Array([0xfe])),
-      false,
-    );
-  });
-
-  test("large equal arrays", () => {
-    const a = new Uint8Array(1024).fill(0xab);
-    const b = new Uint8Array(1024).fill(0xab);
-    assert.equal(constantTimeEqual(a, b), true);
-  });
-
-  test("large arrays differing in last byte", () => {
-    const a = new Uint8Array(1024).fill(0xab);
-    const b = new Uint8Array(1024).fill(0xab);
-    b[1023] = 0xac;
-    assert.equal(constantTimeEqual(a, b), false);
-  });
-
-  test("large arrays differing in first byte", () => {
-    const a = new Uint8Array(1024).fill(0xab);
-    const b = new Uint8Array(1024).fill(0xab);
-    b[0] = 0xac;
-    assert.equal(constantTimeEqual(a, b), false);
-  });
-
-  test("all-zeros equal", () => {
-    assert.equal(
-      constantTimeEqual(new Uint8Array(32), new Uint8Array(32)),
-      true,
-    );
-  });
-});

package/src/__tests__/chain-hash-anchor.test.ts

@@ -1,67 +0,0 @@
-/**
- * Regression: computeChainHash must exclude the anchor service's `ethereum`
- * field so that an Ethereum anchor can be resolved as a chain predecessor.
- *
- * Real-data fixture. `anchor-with-ethereum-112758.json` is a live Ethereum
- * anchor (commit 112758) exactly as it ships in an export bundle: it carries a
- * top-level `ethereum` { blockNumber, blockHash } field that the anchor service
- * appended AFTER the enclave signed it. `successor-112760.json` is the next
- * proof on the chain (the BitGraph whitepaper, commit 112760); its
- * `commit.prevB64` was computed by the enclave over the anchor as the enclave
- * saw it — before the `ethereum` field existed.
- *
- * The bug (latent since the anchor service began stamping `ethereum` on
- * 2026-04-01, exposed once the audit tool resolved prevB64 via computeChainHash
- * on 2026-07-10): computeChainHash hashed the whole proof minus only
- * `proofHash`, so the appended `ethereum` field poisoned the hash and no
- * successor's prevB64 could ever match. The anchor "vanished" from the chain
- * even though it was present in the bundle. The fix excludes `ethereum` (and
- * any ledger/service-added field) from the chain hash.
- */
-
-import { describe, it } from "node:test";
-import * as assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { computeChainHash, type BitGraphProof } from "@mikeargento/bitgraph-verify";
-
-function loadFixture(name: string): Record<string, unknown> {
-  const url = new URL(`../../src/__tests__/real-fixtures/${name}`, import.meta.url);
-  return JSON.parse(readFileSync(fileURLToPath(url), "utf8"));
-}
-
-describe("computeChainHash: Ethereum anchor chain link (ethereum-field regression)", () => {
-  const anchor = loadFixture("anchor-with-ethereum-112758.json");
-  const successor = loadFixture("successor-112760.json");
-  const expectedPrev = (successor.commit as { prevB64: string }).prevB64;
-
-  it("the fixture is the real shape: anchor carries a top-level ethereum field", () => {
-    assert.ok(Object.prototype.hasOwnProperty.call(anchor, "ethereum"));
-    assert.equal((anchor.commit as { counter: string }).counter, "112758");
-    assert.equal((successor.commit as { counter: string }).counter, "112760");
-  });
-
-  it("resolves the successor's prevB64 to the anchor, as exported (with ethereum)", () => {
-    // The whole point: the anchor is exported WITH the ethereum field, and its
-    // chain hash must still equal the successor's prevB64.
-    assert.equal(computeChainHash(anchor as unknown as BitGraphProof), expectedPrev);
-  });
-
-  it("ignores the ethereum field entirely (with === without)", () => {
-    const withoutEth: Record<string, unknown> = { ...anchor };
-    delete withoutEth.ethereum;
-    assert.equal(
-      computeChainHash(anchor as unknown as BitGraphProof),
-      computeChainHash(withoutEth as unknown as BitGraphProof)
-    );
-  });
-
-  it("also ignores the ledger-added proofHash field (with === without)", () => {
-    const withoutHash: Record<string, unknown> = { ...anchor };
-    delete withoutHash.proofHash;
-    assert.equal(
-      computeChainHash(anchor as unknown as BitGraphProof),
-      computeChainHash(withoutHash as unknown as BitGraphProof)
-    );
-  });
-});