@mikeargento/bitgraph-player 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikeargento/bitgraph-player",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Deterministic evaluation of causal rules over BitGraph proof bundles: a pure function from (rule, verified evidence) to a reproducible verdict.",
   "license": "MIT",
   "type": "module",
@@ -17,6 +17,7 @@
   },
   "files": [
     "dist",
+    "dist-web",
     "src",
     "SPEC.md",
     "README.md",
@@ -26,17 +27,22 @@
     "build": "tsc",
     "prepack": "tsc",
     "typecheck": "tsc --noEmit",
-    "test": "tsc && node --test \"dist/__tests__/*.test.js\""
+    "test": "tsc && node --test \"dist/__tests__/*.test.js\"",
+    "build:web": "node scripts/build-verify-html.mjs --out ../folder/src/verify.html",
+    "typecheck:web": "tsc -p web/tsconfig.json"
   },
   "engines": {
     "node": ">=20"
   },
   "dependencies": {
-    "@mikeargento/bitgraph-audit": "^0.1.3",
-    "@mikeargento/bitgraph-verify": "^1.1.2"
+    "@mikeargento/bitgraph-audit": "^0.2.1",
+    "@mikeargento/bitgraph-verify": "^1.2.0"
   },
   "devDependencies": {
+    "@noble/curves": "^2.3.0",
     "@types/node": "^20.0.0",
+    "buffer": "^6.0.3",
+    "esbuild": "^0.27.0",
     "typescript": "^5.4.0"
   }
 }

package/src/__tests__/check.test.ts

@@ -0,0 +1,451 @@
+// Copyright (c) 2024-2026 Mike Argento. Licensed under the MIT License. See LICENSE.
+
+/**
+ * `check` tests.
+ *
+ * The real fixture is a genuine export from the production ledger: a
+ * 685-byte random text file, its proof (real Ed25519 signature, real AWS
+ * Nitro attestation, enclave v5 measurement), both bounding anchors, and
+ * both block-header witnesses. Copied verbatim from a BitGraph Folder
+ * export; read-only here, no ledger writes, no network.
+ *
+ * The parity test is the one that matters most: the same bundle ingested
+ * from disk (the CLI's path) and from memory (the browser page's path)
+ * must produce byte-identical reports, or the two fronts have drifted.
+ */
+
+import { describe, it, before, after } from "node:test";
+import * as assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { cp, mkdtemp, readFile, rm, writeFile, readdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ingestBundle, ingestEntries } from "@mikeargento/bitgraph-audit";
+import type { AuditResult, BundleEntrySource } from "@mikeargento/bitgraph-audit";
+import { buildCheckReport, checkIngest, renderCheckText, serializeCheckReport, KNOWN_ENCLAVE_MEASUREMENTS } from "../check.js";
+import type { CheckReport } from "../check.js";
+import { PLAYER_VERSION } from "../verdict.js";
+import { digestFor, makeAudit } from "./fixtures.js";
+
+const FIXTURE = fileURLToPath(new URL("../../src/__tests__/fixtures/export-random-043", import.meta.url));
+const CLI_PATH = fileURLToPath(new URL("../cli.js", import.meta.url));
+
+async function walk(root: string, rel = ""): Promise<string[]> {
+  const out: string[] = [];
+  const dir = rel === "" ? root : join(root, rel);
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const r = rel === "" ? entry.name : `${rel}/${entry.name}`;
+    if (entry.isDirectory()) out.push(...(await walk(root, r)));
+    else if (entry.isFile()) out.push(r);
+  }
+  return out;
+}
+
+async function memoryEntriesOf(root: string): Promise<BundleEntrySource[]> {
+  const paths = await walk(root);
+  return paths.map((p) => ({
+    path: p,
+    open: () => readFile(join(root, ...p.split("/"))).then((b) => new Uint8Array(b)),
+  }));
+}
+
+/** Fill the audit sections makeAudit leaves empty so buildCheckReport can run over synthetic input. */
+function complete(audit: AuditResult, overrides: Partial<AuditResult> = {}): AuditResult {
+  const a = audit as unknown as Record<string, unknown>;
+  return {
+    ...audit,
+    anomalies: { anomalies: [], divergences: [], boundaryEntryPoints: [] },
+    authorities: { groups: [], anomalies: [], sharedSignersAcrossEpochs: [] },
+    anchors: { anchors: [], metadataOnlyProofHashes: [], findings: [] },
+    witnesses: { outcomes: [], findings: [] },
+    attestations: {
+      records: [],
+      findings: [],
+      counts: {
+        proofsWithDeclaredMeasurement: 0,
+        proofsWithDocument: 0,
+        documentsValidated: 0,
+        documentsFailed: 0,
+        pcr0Matches: 0,
+        pcr0Mismatches: 0,
+        userDataBound: 0,
+        userDataUnbound: 0,
+      },
+    },
+    ...(a["temporal"] !== undefined ? {} : {}),
+    ...overrides,
+  } as AuditResult;
+}
+
+describe("check: real export fixture (disk)", () => {
+  let report: CheckReport;
+  before(async () => {
+    report = await checkIngest(await ingestBundle(FIXTURE));
+  });
+
+  it("is TRUE end to end: file, signature, attestation, enclave, both anchors, both witnesses", () => {
+    assert.equal(report.check, "bitgraph-check/1");
+    assert.equal(report.result, "TRUE");
+    assert.equal(report.recordings.length, 1);
+    assert.equal(report.anchors.length, 2);
+    const rec = report.recordings[0]!;
+    assert.equal(rec.result, "TRUE");
+    assert.equal(rec.filePath, "random-043.txt");
+    assert.deepEqual(
+      rec.lines.map((l) => [l.name, l.result]),
+      [
+        ["file", "TRUE"],
+        ["signature", "TRUE"],
+        ["attestation", "TRUE"],
+        ["enclave", "TRUE"],
+      ]
+    );
+    for (const anchor of report.anchors) {
+      assert.equal(anchor.result, "TRUE");
+      assert.deepEqual(
+        anchor.lines.map((l) => [l.name, l.result]),
+        [
+          ["signature", "TRUE"],
+          ["witness", "TRUE"],
+        ]
+      );
+    }
+    assert.equal(report.contradictions.length, 0);
+  });
+
+  it("brackets the recording between the two verified block headers", () => {
+    const b = report.recordings[0]!.bounds;
+    assert.equal(b.status, "bracketed");
+    assert.equal(b.notBefore?.blockNumber, "25735831");
+    assert.equal(b.notAfter?.blockNumber, "25735832");
+    assert.match(b.detail, /after Ethereum block 25735831 and before block 25735832/);
+  });
+
+  it("orders anchors by causal position, not file name", () => {
+    assert.deepEqual(
+      report.anchors.map((a) => a.blockNumber),
+      ["25735831", "25735832"]
+    );
+    assert.equal(report.anchors[0]!.witnessPath, "ethereum-anchors/anchor-before-witness.json");
+  });
+
+  it("names the excerpt gaps as notes, never as verdicts", () => {
+    assert.ok(report.notes.some((n) => /causal positions? between the earliest and latest recording/.test(n)));
+    assert.ok(report.notes.some((n) => /link(s)? to a predecessor that is not in this bundle/.test(n)));
+    assert.equal(report.contradictions.length, 0);
+  });
+
+  it("states what it cannot check", () => {
+    assert.ok(report.notChecked.some((n) => /canonical/.test(n)));
+    assert.ok(report.notChecked.some((n) => /ledger/.test(n)));
+    assert.equal(report.network, "none");
+    assert.equal(report.evaluator.version, PLAYER_VERSION);
+  });
+
+  it("recognizes the enclave v5 measurement from PINS.md", () => {
+    const enclave = report.recordings[0]!.lines.find((l) => l.name === "enclave")!;
+    assert.match(enclave.detail, /enclave v5/);
+    assert.equal(KNOWN_ENCLAVE_MEASUREMENTS.length, 4);
+  });
+
+  it("serializes deterministically: no timestamps, no machine paths", async () => {
+    const again = await checkIngest(await ingestBundle(FIXTURE));
+    assert.equal(serializeCheckReport(again), serializeCheckReport(report));
+    const bytes = serializeCheckReport(report);
+    assert.ok(!bytes.includes(FIXTURE), "report must not contain the machine path");
+    assert.ok(!bytes.includes("startedAt"));
+    assert.ok(renderCheckText(report).startsWith("TRUE: this file was recorded at position 1576"));
+  });
+});
+
+describe("check: a DECLARED recording (agency proof)", () => {
+  /* Ledger position #12,010, the first declaration ever made on the public
+     chain (2026-08-18). It is here because these packages had no real agency
+     proof to test against, and two bugs lived in that gap at once:
+
+       1. the attestation stage compared user_data against computeProofHash,
+          the FROZEN SUBSET that excludes `actor`, instead of the hash of the
+          full signed body the enclave actually attested. Identical for every
+          proof without `actor`/`policy`, so every existing fixture passed;
+       2. the browser verifier's createVerify shim THREW on P-256 rather than
+          checking it, so verify.html reported a valid declared proof as
+          contradicting itself.
+
+     Both turned a good proof FALSE — the failure mode the three-valued rule
+     exists to prevent. Keep this fixture. */
+  const DECLARED = fileURLToPath(new URL("../../src/__tests__/fixtures/declared-12010", import.meta.url));
+
+  it("verifies: signature, attestation binding, and enclave identity all TRUE", async () => {
+    const report = await checkIngest(await ingestBundle(DECLARED));
+    const rec = report.recordings[0]!;
+    assert.equal(rec.lines.find((l) => l.name === "signature")!.result, "TRUE");
+    assert.equal(rec.lines.find((l) => l.name === "attestation")!.result, "TRUE");
+    assert.equal(rec.lines.find((l) => l.name === "enclave")!.result, "TRUE");
+  });
+
+  it("is UNDETERMINED for want of the file, never FALSE", async () => {
+    const report = await checkIngest(await ingestBundle(DECLARED));
+    // The bundle holds no artifact, so the file line cannot decide. That is
+    // the only thing left open, and nothing here contradicts anything.
+    assert.equal(report.result, "UNDETERMINED");
+    assert.deepEqual(report.contradictions, []);
+  });
+});
+
+describe("check: disk and memory ingest produce byte-identical reports (the no-drift guarantee)", () => {
+  it("ingestEntries over the same files equals ingestBundle over the directory", async () => {
+    const fromDisk = await checkIngest(await ingestBundle(FIXTURE));
+    const fromMemory = await checkIngest(await ingestEntries(await memoryEntriesOf(FIXTURE)));
+    assert.equal(serializeCheckReport(fromMemory), serializeCheckReport(fromDisk));
+    assert.equal(fromMemory.result, "TRUE");
+  });
+
+  it("memory ingest tolerates any supply order (entries are sorted by path)", async () => {
+    const entries = await memoryEntriesOf(FIXTURE);
+    const reversed = [...entries].reverse();
+    const a = await checkIngest(await ingestEntries(entries));
+    const b = await checkIngest(await ingestEntries(reversed));
+    assert.equal(serializeCheckReport(a), serializeCheckReport(b));
+  });
+
+  it("memory ingest accepts whole bytes, promises, and chunk streams alike", async () => {
+    const paths = await walk(FIXTURE);
+    const entries: BundleEntrySource[] = [];
+    for (const [i, p] of paths.entries()) {
+      const bytes = new Uint8Array(await readFile(join(FIXTURE, ...p.split("/"))));
+      const open =
+        i % 3 === 0
+          ? () => bytes
+          : i % 3 === 1
+            ? () => Promise.resolve(bytes)
+            : () =>
+                (async function* () {
+                  const half = Math.floor(bytes.length / 2);
+                  yield bytes.subarray(0, half);
+                  yield bytes.subarray(half);
+                })();
+      entries.push({ path: p, open });
+    }
+    const report = await checkIngest(await ingestEntries(entries));
+    assert.equal(report.result, "TRUE");
+  });
+});
+
+describe("check: what evidence in hand contradicts, and what it merely leaves open", () => {
+  let dir: string;
+  before(async () => {
+    dir = await mkdtemp(join(tmpdir(), "bitgraph-check-"));
+  });
+  after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  async function copyFixture(name: string): Promise<string> {
+    const dest = join(dir, name);
+    await cp(FIXTURE, dest, { recursive: true });
+    return dest;
+  }
+
+  it("an edited file is UNDETERMINED (not FALSE) with a note naming it: absence is not a verdict", async () => {
+    const d = await copyFixture("edited");
+    const p = join(d, "random-043.txt");
+    await writeFile(p, Buffer.concat([await readFile(p), Buffer.from("x")]));
+    const report = await checkIngest(await ingestBundle(d));
+    assert.equal(report.result, "UNDETERMINED");
+    const file = report.recordings[0]!.lines.find((l) => l.name === "file")!;
+    assert.equal(file.result, "UNDETERMINED");
+    assert.ok(report.notes.some((n) => /random-043\.txt/.test(n) && /bytes differ/.test(n)));
+    // Everything else about the recording still holds.
+    assert.equal(report.recordings[0]!.lines.find((l) => l.name === "signature")!.result, "TRUE");
+    assert.equal(report.recordings[0]!.lines.find((l) => l.name === "attestation")!.result, "TRUE");
+  });
+
+  it("a tampered signature is FALSE", async () => {
+    const d = await copyFixture("badsig");
+    const p = join(d, "proof.json");
+    const proof = JSON.parse(await readFile(p, "utf8")) as { signer: { signatureB64: string } };
+    const sig = Buffer.from(proof.signer.signatureB64, "base64");
+    sig[0] = sig[0]! ^ 1;
+    proof.signer.signatureB64 = sig.toString("base64");
+    await writeFile(p, JSON.stringify(proof));
+    const report = await checkIngest(await ingestBundle(d));
+    assert.equal(report.result, "FALSE");
+    assert.equal(report.recordings[0]!.lines.find((l) => l.name === "signature")!.result, "FALSE");
+    assert.match(report.summary, /^FALSE/);
+  });
+
+  it("a tampered block header is FALSE on that anchor, and the bound it gave is withdrawn", async () => {
+    const d = await copyFixture("badwitness");
+    const p = join(d, "ethereum-anchors", "anchor-after-witness.json");
+    const w = JSON.parse(await readFile(p, "utf8")) as { headerRlpHex: string };
+    const h = w.headerRlpHex;
+    w.headerRlpHex = h.slice(0, -2) + (h.slice(-2) === "00" ? "11" : "00");
+    await writeFile(p, JSON.stringify(w));
+    const report = await checkIngest(await ingestBundle(d));
+    assert.equal(report.result, "FALSE");
+    const after = report.anchors.find((a) => a.blockNumber === "25735832")!;
+    assert.equal(after.lines.find((l) => l.name === "witness")!.result, "FALSE");
+    assert.equal(report.recordings[0]!.result, "TRUE", "the recording itself is still sound");
+    assert.equal(report.recordings[0]!.bounds.status, "lower-bounded");
+  });
+
+  it("proof plus file with no anchors is TRUE and unanchored", async () => {
+    const entries: BundleEntrySource[] = ["proof.json", "random-043.txt"].map((name) => ({
+      path: name,
+      open: () => readFile(join(FIXTURE, name)).then((b) => new Uint8Array(b)),
+    }));
+    const report = await checkIngest(await ingestEntries(entries));
+    assert.equal(report.result, "TRUE");
+    assert.equal(report.recordings[0]!.bounds.status, "unanchored");
+    assert.equal(report.anchors.length, 0);
+    assert.match(report.summary, /with no Ethereum bound in this bundle/);
+  });
+
+  it("proof alone (no file) is UNDETERMINED: signature and attestation hold, binding to bytes does not", async () => {
+    const entries: BundleEntrySource[] = [
+      { path: "proof.json", open: () => readFile(join(FIXTURE, "proof.json")).then((b) => new Uint8Array(b)) },
+    ];
+    const report = await checkIngest(await ingestEntries(entries));
+    assert.equal(report.result, "UNDETERMINED");
+    const rec = report.recordings[0]!;
+    assert.equal(rec.lines.find((l) => l.name === "file")!.result, "UNDETERMINED");
+    assert.equal(rec.lines.find((l) => l.name === "signature")!.result, "TRUE");
+    assert.equal(rec.filePath, undefined);
+  });
+
+  it("without WebCrypto the attestation is UNDETERMINED with the reason, never FALSE", async () => {
+    const report = await checkIngest(await ingestBundle(FIXTURE), { webCryptoAvailable: false });
+    const rec = report.recordings[0]!;
+    assert.equal(rec.lines.find((l) => l.name === "attestation")!.result, "UNDETERMINED");
+    assert.match(rec.lines.find((l) => l.name === "attestation")!.detail, /WebCrypto/);
+    assert.equal(rec.lines.find((l) => l.name === "enclave")!.result, "UNDETERMINED");
+    assert.equal(report.result, "UNDETERMINED");
+  });
+
+  it("an empty bundle is UNDETERMINED and says so", async () => {
+    const report = await checkIngest(await ingestEntries([]));
+    assert.equal(report.result, "UNDETERMINED");
+    assert.match(report.summary, /no BitGraph proofs were found/);
+  });
+});
+
+describe("check: synthetic audit shapes", () => {
+  it("an unknown PCR0 is UNDETERMINED (outside this verifier's knowledge), never FALSE", () => {
+    const audit = complete(
+      makeAudit({
+        proofs: [{ name: "a", digestB64: digestFor("a"), epochId: "E", counter: "5", slotCounter: "4" }],
+        partitions: [{ epochId: "E", members: ["a"] }],
+      })
+    );
+    audit.attestations.records.push({
+      proofHash: "proofhash-a",
+      declaredMeasurementPresent: true,
+      declaredMeasurement: "ff".repeat(48),
+      documentPresent: true,
+      attestationFormat: "aws-nitro",
+      documentValidated: true,
+      checks: [],
+      attestedPcr0: "ff".repeat(48),
+      pcr0MatchesDeclared: true,
+      userDataBoundToProof: true,
+    });
+    const report = buildCheckReport(audit);
+    const rec = report.recordings[0]!;
+    assert.equal(rec.lines.find((l) => l.name === "attestation")!.result, "TRUE");
+    const enclave = rec.lines.find((l) => l.name === "enclave")!;
+    assert.equal(enclave.result, "UNDETERMINED");
+    assert.match(enclave.detail, /not among the BitGraph enclave measurements this verifier knows/);
+    assert.equal(report.result, "UNDETERMINED");
+  });
+
+  it("an attestation bound to some other proof is FALSE", () => {
+    const audit = complete(
+      makeAudit({
+        proofs: [{ name: "a", digestB64: digestFor("a"), epochId: "E", counter: "5" }],
+        partitions: [{ epochId: "E", members: ["a"] }],
+      })
+    );
+    audit.attestations.records.push({
+      proofHash: "proofhash-a",
+      declaredMeasurementPresent: true,
+      documentPresent: true,
+      documentValidated: true,
+      checks: [],
+      attestedPcr0: KNOWN_ENCLAVE_MEASUREMENTS[3]!.pcr0,
+      pcr0MatchesDeclared: true,
+      userDataBoundToProof: false,
+    });
+    const report = buildCheckReport(audit);
+    assert.equal(report.recordings[0]!.lines.find((l) => l.name === "attestation")!.result, "FALSE");
+    assert.equal(report.result, "FALSE");
+  });
+
+  it("structural contradictions surface as FALSE while excerpt gaps stay notes", () => {
+    const audit = complete(
+      makeAudit({
+        proofs: [
+          { name: "a", digestB64: digestFor("a"), epochId: "E", counter: "5" },
+          { name: "b", digestB64: digestFor("b"), epochId: "E", counter: "5" },
+        ],
+        partitions: [{ epochId: "E", members: ["a", "b"] }],
+      })
+    );
+    audit.anomalies.anomalies.push(
+      { code: "unexplained-counter-positions", proofHashes: [], message: "gap", details: { count: "3", ranges: [], positions: [], truncated: false } },
+      { code: "chain-break-missing", proofHashes: ["proofhash-a"], message: "missing pred", details: {} },
+      { code: "counter-collision", proofHashes: ["proofhash-a", "proofhash-b"], message: "two commits at position 5" }
+    );
+    const report = buildCheckReport(audit);
+    assert.equal(report.contradictions.length, 1);
+    assert.match(report.contradictions[0]!.detail, /^counter-collision/);
+    assert.ok(report.notes.some((n) => /3 causal positions/.test(n)));
+    assert.equal(report.result, "FALSE");
+  });
+});
+
+describe("check: CLI", () => {
+  it("prints the human report and exits 0 on the real fixture", () => {
+    const r = spawnSync(process.execPath, [CLI_PATH, "check", FIXTURE], { encoding: "utf8" });
+    assert.equal(r.status, 0, r.stderr);
+    assert.match(r.stdout, /^TRUE: this file was recorded at position 1576/);
+    assert.match(r.stdout, /Result: TRUE/);
+  });
+
+  it("--json prints the bitgraph-check/1 report", () => {
+    const r = spawnSync(process.execPath, [CLI_PATH, "check", FIXTURE, "--json"], { encoding: "utf8" });
+    assert.equal(r.status, 0, r.stderr);
+    const parsed = JSON.parse(r.stdout) as CheckReport;
+    assert.equal(parsed.check, "bitgraph-check/1");
+    assert.equal(parsed.result, "TRUE");
+  });
+
+  it("accepts a list of files and ingests them in memory", () => {
+    const r = spawnSync(
+      process.execPath,
+      [CLI_PATH, "check", join(FIXTURE, "proof.json"), join(FIXTURE, "random-043.txt")],
+      { encoding: "utf8" }
+    );
+    assert.equal(r.status, 0, r.stderr);
+    assert.match(r.stdout, /no Ethereum bound in this bundle/);
+  });
+
+  it("exits 2 for UNDETERMINED (proof alone) and 3 for a missing path", () => {
+    const u = spawnSync(process.execPath, [CLI_PATH, "check", join(FIXTURE, "proof.json")], { encoding: "utf8" });
+    assert.equal(u.status, 2, u.stderr);
+    const e = spawnSync(process.execPath, [CLI_PATH, "check", join(FIXTURE, "does-not-exist")], { encoding: "utf8" });
+    assert.equal(e.status, 3);
+    assert.match(e.stderr, /cannot read bundle/);
+  });
+
+  it("evaluate and init reject --json (it belongs to check only)", () => {
+    const r = spawnSync(process.execPath, [CLI_PATH, "init", join(FIXTURE, "random-043.txt"), "--json"], { encoding: "utf8" });
+    assert.equal(r.status, 3);
+    assert.match(r.stderr, /usage:/);
+  });
+
+  it("the relative path helper is unused by the report (paths are bundle-relative only)", () => {
+    // Guard against a future report field leaking absolute paths.
+    assert.equal(relative(FIXTURE, join(FIXTURE, "proof.json")), "proof.json");
+  });
+});

package/src/__tests__/fixtures/declared-12010/proof.json

@@ -0,0 +1 @@
+{"version": "bitgraph/1", "artifact": {"hashAlg": "sha256", "digestB64": "szEkIOHMuIaOXlqVG9uqKvaKtmnYmklfzOjEldzFP2E="}, "commit": {"nonceB64": "05pT2TUMA2mJ0iBsQPkOaKFIUa0i4Ta6wdNkqS3jef4=", "counter": "12010", "slotCounter": "12009", "slotHashB64": "VbOoREc4tcmNwFFYmtfenUZ04LNkjP02wQN2okIi81Y=", "epochId": "plJ+9/nhhVEvDE4X4rCjJI+zys0fIov3XT114+mQIpk=", "prevB64": "3TzjHBZWqTMte6FE0BZ0SM7hrcRhFv29Sl4NMf/ZvBs=", "chainId": "bitgraph:main"}, "signer": {"publicKeyB64": "tmp21VjPay+EhaMwmrFLfdjZo2KIjjT7VDqjmm27wHI=", "signatureB64": "96dTfH4EYq1pRvS7zAhVZuiCLsfrlur0QkA4dfkRQZtbkQ8dgebEQn85TOdvvPtk2YYh9pP0k46HWrZuOOYlBg=="}, "environment": {"enforcement": "measured-tee", "measurement": "6483cedffed74680ffb287507744a398b288c3fb943eb3f2e4fe889f8b60b3d575ad8942350360b69a1bd7bf713df27f", "attestation": {"format": "aws-nitro", "reportB64": "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"}}, "slotAllocation": {"version": "bitgraph/slot/1", "nonceB64": "05pT2TUMA2mJ0iBsQPkOaKFIUa0i4Ta6wdNkqS3jef4=", "counter": "12009", "epochId": "plJ+9/nhhVEvDE4X4rCjJI+zys0fIov3XT114+mQIpk=", "publicKeyB64": "tmp21VjPay+EhaMwmrFLfdjZo2KIjjT7VDqjmm27wHI=", "chainId": "bitgraph:main", "signatureB64": "LlqN1udFVXP9IFxsjwdF6//NMJZbm/IvBmlzDWJ7sfDAqCHD9fSH24w5AM4thFtf0YxMT/n5FedunYYwUQRgCA=="}, "agency": {"actor": {"keyId": "ee0c65174625e065c18e732a226b649a138625ba49c3d7dde026957082035cde", "publicKeyB64": "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEVXEkwZppHxU13Ew9Ap+BQnxQcNXuMvH6KPepQe3t8t1Jh2/aEguB0Ttrzxw9WGxmB8a3AdVVv+ybchgrL8XIRg==", "algorithm": "ES256", "provider": "passkey"}, "authorization": {"purpose": "bitgraph/commit-authorize/v1", "format": "webauthn", "actorKeyId": "ee0c65174625e065c18e732a226b649a138625ba49c3d7dde026957082035cde", "artifactHash": "szEkIOHMuIaOXlqVG9uqKvaKtmnYmklfzOjEldzFP2E=", "challenge": "WzE2FoHLFBQhiwQCpdR8xXA0g1FfOcRCcTEG+1iOJa4=", "timestamp": 1787086799013, "authenticatorDataB64": "Gv0914qYXymsoynDxplniUKsvF16m3HSkeyxwvtTjnsdAAAAAA==", "clientDataJSON": "{\"type\":\"webauthn.get\",\"challenge\":\"WzE2FoHLFBQhiwQCpdR8xXA0g1FfOcRCcTEG-1iOJa4\",\"origin\":\"https://bitgraph.ing\",\"crossOrigin\":false}", "signatureB64": "MEUCIQDBAxBn+pAZcq9YTCVnGcoV6TX+dC1sR1R/0ufz5GSf8gIgMrlaLEPP8f4uFLfTXHT0EA+m85x1LcQNDYqf3557Ktk="}}, "proofHash": "gpbq9mzjkjy9xz7wZAsV+eLk1kwTeOtHogysF5rYS2w="}

package/src/__tests__/fixtures/export-random-043/ethereum-anchors/anchor-after-witness.json

@@ -0,0 +1,6 @@
+{
+  "version": "bitgraph-anchor-witness/1",
+  "headerRlpHex": "0xf90278a0b40e3a88ae7d5c107dd48503c73036a9ec382cf807c8ade7902389c161e93e77a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794dadb0d80178819f2319190d340ce9a924f783711a0421e753106383049bcf5c9fd339b3e40737ebfca4a41117bc26162bc2b542f7da0222fa1b22c0331e3c36cd9b7d11d5dd38e72106617f8eefcb7e1e34c58e87b64a0e1b785033a8cbc93c926e779d4a20e76b959cb4a507426258aec8223b32739d8b901007df77d335fcfbfbfffefefffbffbff7efb5bffefcdfb7ffbfff7bfffeebfefff9fffbefae4dfc3757dfffbff892fbfffffab77f7feefb9fffdfadffd16ff6febffffd2c75ffefffb5bff7f1b7dedffffc077f6fffb75dffaf1c7d2e5fff63f755f3ed120ffeefeffddfdefefbfbbfdffbe575efffdf7e5d33fff7fff2ffbf6ef83ff6bbbf7bf77fefbefe9faf737f7bfc7f5c5b7fdefffffed7bff5775f7ffeedf7777feefbf7f1e7f7fb5cfdc6bfddbff7edefefdddfd4ddfffff3bbfefe7ff7fedfd3fdfefeffffffffff9597ffe759ffff3dffffff7feddf7f7fa756f7cdacbffff77df7fdfaf2fff73f6d9df7deee5ff97b1fdfffdfefbdbfb7df79fffbf80840188b298840393870084020e1228846a7bd55b8a4275696c6465724e6574a003e75244081f38a3700ddbd87fd5c9ca45d2424c478ef199371134924a9462e588000000000000000084049120a8a0cc35135a513f4b5594eedd2ad8ee10e49ec602f209585b3c96776fb71ec9b0e7831e0000840aafde36a0cb0fbc3b6f4ec529821e2c0b3122ba994bf018f24b0286717010024229e1cc09a0e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "blockNumber": 25735832,
+  "blockHash": "0xd20342041898e98ecaa7a07ce4d962561288755e23984e0114d154a5e75bd1a1"
+}

package/src/__tests__/fixtures/export-random-043/ethereum-anchors/anchor-after.json

@@ -0,0 +1,43 @@
+{
+  "version": "bitgraph/1",
+  "artifact": {
+    "hashAlg": "sha256",
+    "digestB64": "ya3LF/xYXUsyLLaRa5atPA0w36iNe2sOEZtMFJzoCx8="
+  },
+  "commit": {
+    "nonceB64": "Z9NHxN5Vx7f3N8SRlk8Uah9RjD64Kbt9xedB83Mv3Ag=",
+    "counter": "1670",
+    "slotCounter": "1669",
+    "slotHashB64": "BcWtB3Ml8S3x9BujCeLH1b+c/VSdwyFViqeX0xDNOqg=",
+    "epochId": "kAx9jUikwWxf+alVyitZcqWPpYeRaDanlZFBVsm2q9s=",
+    "prevB64": "Khd8P6SVzr481lW63viAVAwwkXMrl5jX3uBeMjfFQZ8=",
+    "chainId": "bitgraph:main"
+  },
+  "signer": {
+    "publicKeyB64": "+EyavXXDJAvztDWhIh8Fu03WwMfUzYVgCXnp1lU18Ds=",
+    "signatureB64": "zVXdodzwzhm7fIsm7nz7CGuwHmeHAjA1gzCEN1G/QicFBZ6sprdedV2OVjHtedKZDxbQOSvVU60hSD2Dj6iaAQ=="
+  },
+  "environment": {
+    "enforcement": "measured-tee",
+    "measurement": "6483cedffed74680ffb287507744a398b288c3fb943eb3f2e4fe889f8b60b3d575ad8942350360b69a1bd7bf713df27f",
+    "attestation": {
+      "format": "aws-nitro",
+      "reportB64": "hEShATgioFkRI79pbW9kdWxlX2lkeCdpLTA2NTAyNzM0MjNmZjY3NTY3LWVuYzAxOWZmMzQzZWJhYzcyMzhmZGlnZXN0ZlNIQTM4NGl0aW1lc3RhbXAbAAABn/O5mEJkcGNyc7AAWDBkg87f/tdGgP+yh1B3RKOYsojD+5Q+s/Lk/oifi2Cz1XWtiUI1A2C2mhvXv3E98n8BWDBLTVs2YbPvwSkgkAyA4Sbkzng8Ui3mwCoqW/evOiuTJ7hndvGI5L4cHEBKEp29pJMCWDAynb/jQM5eHKp3DXM2OyH3mevEVlkkmD6tdagU/IUeRoPgtSmfqkazriLTDreBBBkDWDD+UwK5y1gm9uJGWywTP7nx46KUMZGUv4pHEWPSDdx91LwKDPm88/yRbkF8pnByVT4EWDB/NnLXYAC6yWpaRfuiml8mtOMJ0c28NmxuHHZxb2qRGqxwMMGDPYSq4Peo5aubZAIFWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPWDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABrY2VydGlmaWNhdGVZAoAwggJ8MIICAaADAgECAhABn/ND66xyOAAAAABqe7dMMAoGCCqGSM49BAMDMIGOMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEPMA0GA1UECgwGQW1hem9uMQwwCgYDVQQLDANBV1MxOTA3BgNVBAMMMGktMDY1MDI3MzQyM2ZmNjc1NjcudXMtZWFzdC0yLmF3cy5uaXRyby1lbmNsYXZlczAeFw0yNjA4MTEyMzU5MDVaFw0yNjA4MTIwMjU5MDhaMIGTMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEPMA0GA1UECgwGQW1hem9uMQwwCgYDVQQLDANBV1MxPjA8BgNVBAMMNWktMDY1MDI3MzQyM2ZmNjc1NjctZW5jMDE5ZmYzNDNlYmFjNzIzOC51cy1lYXN0LTIuYXdzMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEIYc7tN9lYLpucD5kyNj0MSoNiQztZYgR22OORzvutH9nzGC6dP54EfQFy/CaVewdCACdXnGE/5bKlbf3QHUDFORVlrpzHanVHeXFX5KGWon110UgBqLXS6XoDV3gtUgdox0wGzAMBgNVHRMBAf8EAjAAMAsGA1UdDwQEAwIGwDAKBggqhkjOPQQDAwNpADBmAjEAhl8xJCNOol7s1BZjJug6BUXkvrTcujHTrEjDOLpHY6icPpel0XFXnPi01grkbFwvAjEAs5DymwW8Q/s97U5AdV02gVVkPbEz7ydHId9zqb9llvMT1D8WqxnCIwcB4mk1bxHaaGNhYnVuZGxlhFkCFTCCAhEwggGWoAMCAQICEQD5MXVoG5Cv4R1GzLTk5/hWMAoGCCqGSM49BAMDMEkxCzAJBgNVBAYTAlVTMQ8wDQYDVQQKDAZBbWF6b24xDDAKBgNVBAsMA0FXUzEbMBkGA1UEAwwSYXdzLm5pdHJvLWVuY2xhdmVzMB4XDTE5MTAyODEzMjgwNVoXDTQ5MTAyODE0MjgwNVowSTELMAkGA1UEBhMCVVMxDzANBgNVBAoMBkFtYXpvbjEMMAoGA1UECwwDQVdTMRswGQYDVQQDDBJhd3Mubml0cm8tZW5jbGF2ZXMwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAT8AlTrpgjB82hw4prakL5GODKSc26JS//2ctmJREtQUeU0pLH22+PAvFgaMrexdgcO3hLWmj/qIRtm51LPfdHdCV9vE3D0FwhD2dwQASHkz2MBKAlmRIfJeWKEME3FP/SjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFJAltQ3ZBUfnlsOW+nKdz5mp30uWMA4GA1UdDwEB/wQEAwIBhjAKBggqhkjOPQQDAwNpADBmAjEAo38vkaHJvV7nuGJ8FpjSVQOOHwND+VtjqWKMPTmAlUWhHry/LjtV2K7ucbTD1q3zAjEAovObFgWycCil3UugabUBbmW0+96P4AYdalMZf5za9dlDvGH8K+sDy2/ujSMC89/2WQLCMIICvjCCAkWgAwIBAgIRAJfoNNpEC3gE5OD0gRuLL1AwCgYIKoZIzj0EAwMwSTELMAkGA1UEBhMCVVMxDzANBgNVBAoMBkFtYXpvbjEMMAoGA1UECwwDQVdTMRswGQYDVQQDDBJhd3Mubml0cm8tZW5jbGF2ZXMwHhcNMjYwODA3MDI0ODA3WhcNMjYwODI3MDM0ODA3WjBkMQswCQYDVQQGEwJVUzEPMA0GA1UECgwGQW1hem9uMQwwCgYDVQQLDANBV1MxNjA0BgNVBAMMLTQ1ZjU3YjJmNTI4ZmQ0Y2IudXMtZWFzdC0yLmF3cy5uaXRyby1lbmNsYXZlczB2MBAGByqGSM49AgEGBSuBBAAiA2IABLLMSvTOIr/7QWTibLSRtyva2ZCw9okkb0Ybl3hHFD/SwMNNKeS343bzpKCSS80MI5uO3n6oM0yTpKujJOHjicKMmYiPNFtLFGuKSSvKLe1kPlKfT/QdfiN3oYynBgau9KOB1TCB0jASBgNVHRMBAf8ECDAGAQH/AgECMB8GA1UdIwQYMBaAFJAltQ3ZBUfnlsOW+nKdz5mp30uWMB0GA1UdDgQWBBRZlmFoP2IvBwC31RxGlWS4TuHEdzAOBgNVHQ8BAf8EBAMCAYYwbAYDVR0fBGUwYzBhoF+gXYZbaHR0cDovL2F3cy1uaXRyby1lbmNsYXZlcy1jcmwuczMuYW1hem9uYXdzLmNvbS9jcmwvYWI0OTYwY2MtN2Q2My00MmJkLTllOWYtNTkzMzhjYjY3Zjg0LmNybDAKBggqhkjOPQQDAwNnADBkAjApHRJ8S8/LPUpjy/+7yuXiWAwdtxnGzw6vssMtsGxs6c0xcSRUsnF22WGTJ8L6IXYCMAzMhwnpVT3L7BwEi3gZDB6NkORGXMCCMgf2HtQiYHgoriPHI2HNgXwdnuQf1PjcWFkDGTCCAxUwggKaoAMCAQICEBRuHGICJn7N5PyKtslCd6IwCgYIKoZIzj0EAwMwZDELMAkGA1UEBhMCVVMxDzANBgNVBAoMBkFtYXpvbjEMMAoGA1UECwwDQVdTMTYwNAYDVQQDDC00NWY1N2IyZjUyOGZkNGNiLnVzLWVhc3QtMi5hd3Mubml0cm8tZW5jbGF2ZXMwHhcNMjYwODExMTEwNjA5WhcNMjYwODE3MDAwNjA5WjCBiTE8MDoGA1UEAwwzZWJjOTEwYTM3Mzc4ODdlNS56b25hbC51cy1lYXN0LTIuYXdzLm5pdHJvLWVuY2xhdmVzMQwwCgYDVQQLDANBV1MxDzANBgNVBAoMBkFtYXpvbjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAldBMRAwDgYDVQQHDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEiMM1x/0HEhamp3T1kgfG4irHIiwkjSpM1OhYNmc7hqLeAF6AUUjRSuG3k5LfL6zBORUMPdyo0nImdfeif/T+an3/66sscbLdVoBpvbIffLCt5BCvDRiJXFAAAWFJARJVo4HqMIHnMBIGA1UdEwEB/wQIMAYBAf8CAQEwHwYDVR0jBBgwFoAUWZZhaD9iLwcAt9UcRpVkuE7hxHcwHQYDVR0OBBYEFLsYdmX5qDQB2Nej/y15dzLt4loIMA4GA1UdDwEB/wQEAwIBhjCBgAYDVR0fBHkwdzB1oHOgcYZvaHR0cDovL2NybC11cy1lYXN0LTItYXdzLW5pdHJvLWVuY2xhdmVzLnMzLnVzLWVhc3QtMi5hbWF6b25hd3MuY29tL2NybC80NGZkOGIwMi00ODYwLTQ4NmItOWY4Ni0xYzk1ZjVhMmJhNjguY3JsMAoGCCqGSM49BAMDA2kAMGYCMQCjieA/CTwRsh7ci68p3uzDyy8tRmyo/jleo07SPfuVxyuxwEHomoF/XoUCzqhaYeACMQDez4f94H9j42nYD5T/fH2bM/ieYlYEnS7WYacevT70iT6iInsoT54NtatlIkhygpdZAsMwggK/MIICRaADAgECAhUAui0vaxByYVl/f5zb1xP/iqtBylEwCgYIKoZIzj0EAwMwgYkxPDA6BgNVBAMMM2ViYzkxMGEzNzM3ODg3ZTUuem9uYWwudXMtZWFzdC0yLmF3cy5uaXRyby1lbmNsYXZlczEMMAoGA1UECwwDQVdTMQ8wDQYDVQQKDAZBbWF6b24xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJXQTEQMA4GA1UEBwwHU2VhdHRsZTAeFw0yNjA4MTExNTA4MzdaFw0yNjA4MTIxNTA4MzdaMIGOMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEPMA0GA1UECgwGQW1hem9uMQwwCgYDVQQLDANBV1MxOTA3BgNVBAMMMGktMDY1MDI3MzQyM2ZmNjc1NjcudXMtZWFzdC0yLmF3cy5uaXRyby1lbmNsYXZlczB2MBAGByqGSM49AgEGBSuBBAAiA2IABDhoMFUcb8bP5C1T3N/oAjW5AkdYF14mzccQF90SDUWeC6d2tXRoMm9VXQhH0pWw8Hf3dl4HIpoujKP3dHNDBccJ8B4dKffbwUyn29CWZNg4bVXAkui5aVa27N3/6GSznKNmMGQwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNVHQ8BAf8EBAMCAgQwHQYDVR0OBBYEFI3Ez5VD2q8WGxgPpifG0Lc/M02zMB8GA1UdIwQYMBaAFLsYdmX5qDQB2Nej/y15dzLt4loIMAoGCCqGSM49BAMDA2gAMGUCMQDdHPeiFt+r7qa8mcDiSGiAeytnfNgQGJmqfJyx/sfsIb3cp4xt4KeUUNdNT6zboDwCMF0/hywl/8pBUzLamPMrSz8vEBKu66YQzdQbx+szhWczIhWAwgwoOwQP25I438SxbGpwdWJsaWNfa2V59ml1c2VyX2RhdGFYIHVsluzLkyAG0ABzaEcqIXNewPRoRg9QqH/SarQBVKxeZW5vbmNl9v9YYGJ4UwvvIrxZRztcTDXk+e2iADIk9zOADhYUd7gQgSV+Pl1i3xF9pn3XUQdsdFoHDoeCRGTLZV+ExWSOhGhD/3AlfiqTZTD8J0yNXDaFhtIFZiN/DrKgH/+0ovlYgraiqw=="
+    }
+  },
+  "slotAllocation": {
+    "version": "bitgraph/slot/1",
+    "nonceB64": "Z9NHxN5Vx7f3N8SRlk8Uah9RjD64Kbt9xedB83Mv3Ag=",
+    "counter": "1669",
+    "epochId": "kAx9jUikwWxf+alVyitZcqWPpYeRaDanlZFBVsm2q9s=",
+    "publicKeyB64": "+EyavXXDJAvztDWhIh8Fu03WwMfUzYVgCXnp1lU18Ds=",
+    "chainId": "bitgraph:main",
+    "signatureB64": "sEx4coi4XxoaFCuUnOPDnvLa5uJfEuafAt44kmVpAQMbhJjwIXz5Hq2xeynIWgWdd91zYuHW+R/goDARTSLNAA=="
+  },
+  "attribution": {
+    "name": "Ethereum Anchor",
+    "title": "https://etherscan.io/block/25735832",
+    "message": "0xd20342041898e98ecaa7a07ce4d962561288755e23984e0114d154a5e75bd1a1"
+  },
+  "proofHash": "dWyW7MuTIAbQAHNoRyohc17A9GhGD1Cof9JqtAFUrF4="
+}

package/src/__tests__/fixtures/export-random-043/ethereum-anchors/anchor-before-witness.json

@@ -0,0 +1,6 @@
+{
+  "version": "bitgraph-anchor-witness/1",
+  "headerRlpHex": "0xf90286a02503d8262a3a5bd39a93f835f338a720434de7db353666a432d3af470ffc32e0a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347944838b106fce9647bdf1e7877bf73ce8b0bad5f97a0cf917d0242c222689c6ffec1e370ede05b474b64bf872cff3f1e77b207e84df0a0860c3a345b84903a1b2c6222e217424fd9ecc7df833db93ddd5534c82c35cb5ca0fbcccc621bc16881ca28d5be42348d32da5ec5614576be29f61f4413a6eea770b90100b9f73afff7fbdd71edef3fabfaf67dbf67f60f4bdfcf3aefeffd45fdfff8ed3f7dfe5f39b96f87b7cff6dbbf7cfe7395bf7ffefbfff3fffff7fbc7f7bbfe67c5fef6ffff4ffefbbd6e7f59bff3779eb9c7ff5f3fb2ff6c77befbff97ddefff86fcbcff55bffbfcd794f48fb3fcbeafc5faab4faf69ce77fe2bf0fbbf53ffde3b9d7776fff9feeb5bbbeff67eff17e7fff37bdab3ff8dc65fd5e76de5bbfcd53d7fef95777fd1af6fdd757bfebaf7fdce557ffff5e9be7e4b4fecbfbeb6f7ef73efafff8f67ebdf7712dbdff8057cffb53fcfffe37e69f1fa777bfbbaeb11fda6e676bd65b760bf9c5ff6d7fffefbdffdffedddff9ffb3d69b35ffa7c7ece7db780840188b29784039387008402077531846a7bd54398546974616e2028746974616e6275696c6465722e78797a29a0ec6cba377edad8dba8ff3c107a4a3df470239a0ae9d0fcdd11efddc52fb8358188000000000000000084047dc210a09f522911c579bcb780c77c3f3684c5478b64265ae99f6b11017b22d425343b3883060000840aadde36a0c3ab61e8d9a8e9935d60604b636336867145eebed5408f477aa1f239fa6a125ba0e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "blockNumber": 25735831,
+  "blockHash": "0xb40e3a88ae7d5c107dd48503c73036a9ec382cf807c8ade7902389c161e93e77"
+}

package/src/__tests__/fixtures/export-random-043/ethereum-anchors/anchor-before.json

@@ -0,0 +1,47 @@
+{
+  "version": "bitgraph/1",
+  "artifact": {
+    "hashAlg": "sha256",
+    "digestB64": "ki5C7mF2smUeovIXfsjaQWDpJlNeuh/RqojLVO9x1po="
+  },
+  "commit": {
+    "nonceB64": "Yy8vOkAYWfg49uKe6ageYcGqTZ1XQoqIlnn3i2cU6iI=",
+    "counter": "1428",
+    "slotCounter": "1427",
+    "slotHashB64": "CDiOgdW2+WfYRYFgC3Nq7nFGORlAna5rhumMPw0jIRI=",
+    "epochId": "kAx9jUikwWxf+alVyitZcqWPpYeRaDanlZFBVsm2q9s=",
+    "prevB64": "7l8DjZkNO//ouuiDP9SqlZ4zjX0coCOgnYfOOOAnsf4=",
+    "chainId": "bitgraph:main"
+  },
+  "signer": {
+    "publicKeyB64": "+EyavXXDJAvztDWhIh8Fu03WwMfUzYVgCXnp1lU18Ds=",
+    "signatureB64": "Qkx5qkbs9ftKA5RSYFjBZiSSpwoOaIzrTL7hHfvoo8DLMfnVoh+gSlJLKQzpqI5eTZ/nF62uXel3wlzyUY/iDA=="
+  },
+  "environment": {
+    "enforcement": "measured-tee",
+    "measurement": "6483cedffed74680ffb287507744a398b288c3fb943eb3f2e4fe889f8b60b3d575ad8942350360b69a1bd7bf713df27f",
+    "attestation": {
+      "format": "aws-nitro",
+      "reportB64": "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"
+    }
+  },
+  "slotAllocation": {
+    "version": "bitgraph/slot/1",
+    "nonceB64": "Yy8vOkAYWfg49uKe6ageYcGqTZ1XQoqIlnn3i2cU6iI=",
+    "counter": "1427",
+    "epochId": "kAx9jUikwWxf+alVyitZcqWPpYeRaDanlZFBVsm2q9s=",
+    "publicKeyB64": "+EyavXXDJAvztDWhIh8Fu03WwMfUzYVgCXnp1lU18Ds=",
+    "chainId": "bitgraph:main",
+    "signatureB64": "3O+/iIgdF4/9YImCVjT7keEmaJ/bu63x61l7GJvBFPVrqto5S2RDQKluhEvX8HjREvnZhXrTG2FU1aL2P4msDg=="
+  },
+  "attribution": {
+    "name": "Ethereum Anchor",
+    "title": "https://etherscan.io/block/25735831",
+    "message": "0xb40e3a88ae7d5c107dd48503c73036a9ec382cf807c8ade7902389c161e93e77"
+  },
+  "proofHash": "dkZTDDfmmrAxL1FWJwqJXBUH8AxCWUr6cLT7eA79Fhw=",
+  "ethereum": {
+    "blockNumber": 25735831,
+    "blockHash": "0xb40e3a88ae7d5c107dd48503c73036a9ec382cf807c8ade7902389c161e93e77"
+  }
+}