@freedomofpress/cometbft 0.1.0

package/src/tests/commit.test.ts

@@ -0,0 +1,278 @@
+import { describe, expect, it } from "vitest";
+
+import { importCommit } from "../commit";
+import { base64ToUint8Array, Uint8ArrayToBase64 } from "../encoding";
+import type { CommitJson } from "../types";
+import commitFixture from "./fixtures/commit-12.json";
+
+// Deep-clone plain JSON-like objects
+function clone<T>(x: T): T {
+  return JSON.parse(JSON.stringify(x));
+}
+
+describe("importCommit: happy path (fixture)", () => {
+  it("parses a valid signed_header into SignedHeader (ts-proto, useDate=false)", () => {
+    const resp = commitFixture as unknown as CommitJson;
+
+    const sh = importCommit(resp);
+
+    // header basics
+    expect(sh.header!.chainId).toBe("chain-ORcSeX");
+    expect(sh.header!.height).toBe(12n);
+    expect(sh.header!.version?.block).toBe(11n);
+    expect(sh.header!.version?.app).toBe(1n);
+    expect(sh.header!.time).toEqual({
+      seconds: expect.any(BigInt),
+      nanos: expect.any(Number),
+    });
+
+    // 32-byte hashes (app hash can be any length; in the fixture it's 8 bytes)
+    expect(sh.header!.lastCommitHash.length).toBe(32);
+    expect(sh.header!.dataHash.length).toBe(32);
+    expect(sh.header!.validatorsHash.length).toBe(32);
+    expect(sh.header!.nextValidatorsHash.length).toBe(32);
+    expect(sh.header!.consensusHash.length).toBe(32);
+    expect(sh.header!.appHash.length).toBe(8);
+    expect(sh.header!.lastResultsHash.length).toBe(32);
+    expect(sh.header!.evidenceHash.length).toBe(32);
+
+    // proposer 20 bytes
+    expect(sh.header!.proposerAddress.length).toBe(20);
+
+    // last_block_id + commit.block_id parts
+    expect(sh.header!.lastBlockId!.hash.length).toBe(32);
+    expect(sh.header!.lastBlockId!.partSetHeader!.hash.length).toBe(32);
+    expect(typeof sh.header!.lastBlockId!.partSetHeader!.total).toBe("number");
+
+    expect(sh.commit!.height).toBe(12n);
+    expect(sh.commit!.round).toBe(0);
+    expect(sh.commit!.blockId!.hash.length).toBe(32);
+    expect(sh.commit!.blockId!.partSetHeader!.hash.length).toBe(32);
+    expect(sh.commit!.signatures.length).toBeGreaterThan(0);
+
+    for (const s of sh.commit!.signatures) {
+      expect(typeof s.blockIdFlag).toBe("number");
+      expect(s.validatorAddress.length).toBe(20);
+      expect(s.signature.length).toBe(64); // fixture has present signatures
+      expect(s.timestamp).toEqual({
+        seconds: expect.any(BigInt),
+        nanos: expect.any(Number),
+      });
+    }
+  });
+});
+
+describe("importCommit: validation errors", () => {
+  it("fails on missing signed_header", () => {
+    const bad = {} as unknown as CommitJson;
+    expect(() => importCommit(bad)).toThrow(/Missing signed_header/);
+  });
+
+  it("fails on missing header", () => {
+    const bad = clone(commitFixture) as any;
+    delete bad.signed_header.header;
+    expect(() => importCommit(bad)).toThrow(/Missing header/);
+  });
+
+  it("fails on missing commit", () => {
+    const bad = clone(commitFixture) as any;
+    delete bad.signed_header.commit;
+    expect(() => importCommit(bad)).toThrow(/Missing commit/);
+  });
+
+  it("fails on missing header.height", () => {
+    const bad = clone(commitFixture) as any;
+    delete bad.signed_header.header.height;
+    expect(() => importCommit(bad)).toThrow(/Missing header\.height/);
+  });
+
+  it("fails on missing commit.height", () => {
+    const bad = clone(commitFixture) as any;
+    bad.signed_header.commit.height = "";
+    expect(() => importCommit(bad)).toThrow(/Missing commit\.height/);
+  });
+
+  it("fails on mismatched header/commit heights", () => {
+    const bad = clone(commitFixture) as any;
+    bad.signed_header.header.height = "13";
+    expect(() => importCommit(bad)).toThrow(/height mismatch/);
+  });
+
+  it("fails on invalid commit.round (negative / non-integer)", () => {
+    const bad1 = clone(commitFixture) as any;
+    bad1.signed_header.commit.round = -1;
+    expect(() => importCommit(bad1)).toThrow(/Invalid commit\.round/);
+
+    const bad2 = clone(commitFixture) as any;
+    bad2.signed_header.commit.round = 0.5;
+    expect(() => importCommit(bad2)).toThrow(/Invalid commit\.round/);
+  });
+
+  it("fails on invalid last_block_id (missing fields)", () => {
+    const bad = clone(commitFixture) as any;
+    delete bad.signed_header.header.last_block_id.parts;
+    expect(() => importCommit(bad)).toThrow(/Invalid last_block_id/);
+  });
+
+  it("fails on bad last_block_id.parts.total (negative / non-integer)", () => {
+    const bad1 = clone(commitFixture) as any;
+    bad1.signed_header.header.last_block_id.parts.total = -1;
+    expect(() => importCommit(bad1)).toThrow(
+      /Invalid last_block_id\.parts\.total/,
+    );
+
+    const bad2 = clone(commitFixture) as any;
+    bad2.signed_header.header.last_block_id.parts.total = 1.2;
+    expect(() => importCommit(bad2)).toThrow(
+      /Invalid last_block_id\.parts\.total/,
+    );
+  });
+
+  it("fails on malformed header hash lengths (32 bytes expected)", () => {
+    const fields = [
+      "last_commit_hash",
+      "data_hash",
+      "validators_hash",
+      "next_validators_hash",
+      "consensus_hash",
+      "last_results_hash",
+      "evidence_hash",
+    ] as const;
+
+    for (const f of fields) {
+      const bad = clone(commitFixture) as any;
+      // Make hex too short (trim 2 chars -> 31 bytes)
+      bad.signed_header.header[f] = bad.signed_header.header[f].slice(0, -2);
+      expect(() => importCommit(bad)).toThrow(
+        new RegExp(`${f.replace(/_/g, "\\_")}`),
+      );
+    }
+  });
+
+  it("fails on missing header.time", () => {
+    const bad = clone(commitFixture) as any;
+    delete bad.signed_header.header.time;
+    expect(() => importCommit(bad)).toThrow(/Missing header\.time/);
+  });
+
+  it("fails on invalid header.time (not RFC3339)", () => {
+    const bad = clone(commitFixture) as any;
+    bad.signed_header.header.time = "not-a-time";
+    expect(() => importCommit(bad)).toThrow(/Invalid RFC3339 time/);
+  });
+
+  it("fails on missing proposer_address", () => {
+    const bad = clone(commitFixture) as any;
+    delete bad.signed_header.header.proposer_address;
+    expect(() => importCommit(bad)).toThrow(/Missing proposer_address/);
+  });
+
+  it("fails on proposer_address wrong length", () => {
+    const bad = clone(commitFixture) as any;
+    bad.signed_header.header.proposer_address =
+      bad.signed_header.header.proposer_address.slice(0, 38); // 19 bytes
+    expect(() => importCommit(bad)).toThrow(
+      /proposer_address must be 20 bytes/,
+    );
+  });
+
+  it("fails on invalid commit.block_id (missing parts)", () => {
+    const bad = clone(commitFixture) as any;
+    delete bad.signed_header.commit.block_id.parts;
+    expect(() => importCommit(bad)).toThrow(/Invalid commit\.block_id/);
+  });
+
+  it("fails on bad commit.block_id.parts.total", () => {
+    const bad = clone(commitFixture) as any;
+    bad.signed_header.commit.block_id.parts.total = -1;
+    expect(() => importCommit(bad)).toThrow(
+      /Invalid commit\.block_id\.parts\.total/,
+    );
+  });
+
+  it("fails when commit has no signatures", () => {
+    const bad = clone(commitFixture) as any;
+    bad.signed_header.commit.signatures = [];
+    expect(() => importCommit(bad)).toThrow(/Commit has no signatures/);
+  });
+
+  it("fails on invalid signatures[*].block_id_flag type", () => {
+    const bad = clone(commitFixture) as any;
+    bad.signed_header.commit.signatures[0].block_id_flag = "2";
+    expect(() => importCommit(bad)).toThrow(/block_id_flag must be a number/);
+  });
+
+  it("fails on missing validator_address", () => {
+    const bad = clone(commitFixture) as any;
+    delete bad.signed_header.commit.signatures[0].validator_address;
+    expect(() => importCommit(bad)).toThrow(/validator_address missing/);
+  });
+
+  it("fails on short validator_address (hex < 40 chars)", () => {
+    const bad = clone(commitFixture) as any;
+    bad.signed_header.commit.signatures[0].validator_address =
+      bad.signed_header.commit.signatures[0].validator_address.slice(0, 38);
+    expect(() => importCommit(bad)).toThrow(/validator_address.*20 bytes/);
+  });
+
+  it("defaults header.version.{block,app} to 0n when version is missing", () => {
+    const resp = clone(commitFixture) as any;
+    delete resp.signed_header.header.version;
+
+    const sh = importCommit(resp as CommitJson);
+
+    expect(sh.header!.version?.block).toBe(0n);
+    expect(sh.header!.version?.app).toBe(0n);
+  });
+
+  it("parses header.time without fractional seconds (nanos=0)", () => {
+    const resp = clone(commitFixture) as any;
+    resp.signed_header.header.time = "2025-08-18T13:39:10Z"; // no .fraction
+
+    const sh = importCommit(resp as CommitJson);
+
+    expect(sh.header!.time?.nanos).toBe(0);
+    expect(typeof sh.header!.time?.seconds).toBe("bigint");
+  });
+
+  it("allows a signature with no timestamp (kept undefined)", () => {
+    const resp = clone(commitFixture) as any;
+    delete resp.signed_header.commit.signatures[0].timestamp;
+
+    const sh = importCommit(resp as CommitJson);
+
+    expect(sh.commit!.signatures[0].timestamp).toBeUndefined();
+  });
+
+  it("allows missing signature (proto3 bytes -> empty) and sets length to 0", () => {
+    const good = clone(commitFixture) as any;
+    delete good.signed_header.commit.signatures[0].signature;
+
+    const sh = importCommit(good as CommitJson);
+    expect(sh.commit!.signatures[0].signature).toBeInstanceOf(Uint8Array);
+    expect(sh.commit!.signatures[0].signature.length).toBe(0);
+  });
+
+  it("fails on wrong signature length (not 64 bytes) without Buffer", () => {
+    const bad = clone(commitFixture) as any;
+    const sigB64: string = bad.signed_header.commit.signatures[0].signature;
+
+    const sigBytes = base64ToUint8Array(sigB64);
+    const shorter = sigBytes.slice(0, 63);
+    bad.signed_header.commit.signatures[0].signature =
+      Uint8ArrayToBase64(shorter);
+
+    expect(() => importCommit(bad)).toThrow(/signature.*64 bytes/);
+  });
+
+  it("parses timestamps with fractional seconds (nano padding/truncation)", () => {
+    const withFrac = clone(commitFixture) as any;
+    withFrac.signed_header.header.time = "2025-08-18T13:39:10.618857123Z";
+    withFrac.signed_header.commit.signatures[0].timestamp =
+      "2025-08-18T13:39:11.9Z";
+
+    const sh = importCommit(withFrac as CommitJson);
+    expect(sh.header!.time?.nanos).toBe(618857123);
+    expect(sh.commit!.signatures[0].timestamp?.nanos).toBe(900000000);
+  });
+});

package/src/tests/encoding.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  hexToUint8Array,
+  Uint8ArrayToBase64,
+  Uint8ArrayToHex,
+} from "../encoding";
+
+describe("encoding", () => {
+  it("converts Uint8Array to Base64", () => {
+    const input = new Uint8Array([72, 101, 108, 108, 111]);
+    const result = Uint8ArrayToBase64(input);
+    expect(result).toBe("SGVsbG8=");
+  });
+
+  it("converts ArrayBuffer to Base64", () => {
+    const buffer = new TextEncoder().encode("Hi").buffer;
+    const result = Uint8ArrayToBase64(buffer);
+    expect(result).toBe("SGk=");
+  });
+
+  it("parses valid hex string", () => {
+    const hex = "48656c6c6f";
+    const uint8 = hexToUint8Array(hex);
+    expect([...uint8]).toEqual([72, 101, 108, 108, 111]);
+  });
+
+  it("throws on invalid characters", () => {
+    expect(() => hexToUint8Array("zz12")).toThrow(
+      "Hex string contains invalid characters",
+    );
+  });
+
+  it("throws on odd-length hex string", () => {
+    expect(() => hexToUint8Array("abc")).toThrow(
+      "Hex string must have an even length",
+    );
+  });
+
+  it("encodes Uint8Array to hex string", () => {
+    const input = new Uint8Array([72, 101, 108, 108, 111]);
+    const hex = Uint8ArrayToHex(input);
+    expect(hex).toBe("48656c6c6f");
+  });
+});

package/src/tests/fixtures/commit-12.json

@@ -0,0 +1,64 @@
+{
+  "signed_header": {
+    "header": {
+      "version": { "block": "11", "app": "1" },
+      "chain_id": "chain-ORcSeX",
+      "height": "12",
+      "time": "2025-08-18T13:39:10.618857Z",
+      "last_block_id": {
+        "hash": "980DF9A358F01668EB6F289D223065C8A496A56411C11842FF89677AE427C3DF",
+        "parts": {
+          "total": 1,
+          "hash": "4CEBEE9DBC12129AED6B8D834FC7C5CED8F519C10EF6DE7A46376631A91E3FA6"
+        }
+      },
+      "last_commit_hash": "B3FAAB00E85339EED6ADE15BDCB136C3994F536ADF3BB6C45FAB3CD9F8E40B2A",
+      "data_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
+      "validators_hash": "3340D40CE35BC4A025795BBE753A1A1E0026D0904326DD20438ED0BE7A73EE94",
+      "next_validators_hash": "3340D40CE35BC4A025795BBE753A1A1E0026D0904326DD20438ED0BE7A73EE94",
+      "consensus_hash": "68ECD6F333119CE43751ECE583B981F23508AEAF4221FF582B1BB33BE42BCEFA",
+      "app_hash": "0600000000000000",
+      "last_results_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
+      "evidence_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
+      "proposer_address": "CCF25785244316D4A5EAFC187E0EAA36C5665599"
+    },
+    "commit": {
+      "height": "12",
+      "round": 0,
+      "block_id": {
+        "hash": "93232036CF95FF1890654092D560742F9305DD85F4FD80B3DFA71A1FF3A9B6D6",
+        "parts": {
+          "total": 1,
+          "hash": "08DAFA6B9653A474F6D9C18302B904C15BF1D72FD4B1B72B6390D55AC0CCB3E8"
+        }
+      },
+      "signatures": [
+        {
+          "block_id_flag": 2,
+          "validator_address": "4DBA7206E6BF35AFAEE7AEF523D450A4B10DC955",
+          "timestamp": "2025-08-18T13:39:11.924425Z",
+          "signature": "mLNmsIOnQgD/dIg5To83ig94MhgrUqGVWzFvmPWKv5A9kFDzhp7dAvn1FGSeS9yjA12WFc7oV9dNZk9+IxeNDg=="
+        },
+        {
+          "block_id_flag": 2,
+          "validator_address": "9A9BC61D31EF1673F6975AA7ACE356E7B6BE2412",
+          "timestamp": "2025-08-18T13:39:11.920418Z",
+          "signature": "/zzgiepmyjyASMZMsKmp1xdSmOnin0mW3g6irkU7DJX52oFuI9d3WNDX4VUzOccKrLS/vwLLiELOQBdcnAAVAg=="
+        },
+        {
+          "block_id_flag": 2,
+          "validator_address": "CAD8E57D78ABDFF7DF23C81C330335430EE97808",
+          "timestamp": "2025-08-18T13:39:11.916389Z",
+          "signature": "p1sbdl3iEH5RG/HhroyGqx3+p4VV42aNpcsEme31dq0rlLd4F8RHnmcsIbtqLCIs2L8MzlVEebuCVJheVJeqCg=="
+        },
+        {
+          "block_id_flag": 2,
+          "validator_address": "CCF25785244316D4A5EAFC187E0EAA36C5665599",
+          "timestamp": "2025-08-18T13:39:11.92732Z",
+          "signature": "aW7m0l/5yX2B9DeJ5qcuWdGoOp7Crj6Nwj6WbQA24B4NRgaY1PmBzDNr4SDSGOJUu4HnnVtm0zp6qNNm8JaNAA=="
+        }
+      ]
+    }
+  },
+  "canonical": true
+}

package/src/tests/fixtures/validators-12.json

@@ -0,0 +1,41 @@
+{
+  "block_height": "12",
+  "validators": [
+    {
+      "address": "4DBA7206E6BF35AFAEE7AEF523D450A4B10DC955",
+      "pub_key": {
+        "type": "tendermint/PubKeyEd25519",
+        "value": "BBqAcUZ6IPWzOZyUOHVK95ihP7s0McuRaYjbn6CqWfk="
+      },
+      "voting_power": "1",
+      "proposer_priority": "0"
+    },
+    {
+      "address": "9A9BC61D31EF1673F6975AA7ACE356E7B6BE2412",
+      "pub_key": {
+        "type": "tendermint/PubKeyEd25519",
+        "value": "/nX4LxZwh87dNEYD9t2cw8+HHwbwuBmq34Q7z7tvqEc="
+      },
+      "voting_power": "1",
+      "proposer_priority": "0"
+    },
+    {
+      "address": "CAD8E57D78ABDFF7DF23C81C330335430EE97808",
+      "pub_key": {
+        "type": "tendermint/PubKeyEd25519",
+        "value": "w3pPpAwVxmK0oTHeAmQFk8JviQAJUn7CGo7vAHtMqfg="
+      },
+      "voting_power": "1",
+      "proposer_priority": "0"
+    },
+    {
+      "address": "CCF25785244316D4A5EAFC187E0EAA36C5665599",
+      "pub_key": {
+        "type": "tendermint/PubKeyEd25519",
+        "value": "DZY3DLVKC8ZML3I/kuqMUaoXyAj+UGXskuWlDMAcnC0="
+      },
+      "voting_power": "1",
+      "proposer_priority": "0"
+    }
+  ]
+}

package/src/tests/fixtures/webcat.json

@@ -0,0 +1,71 @@
+{
+  "signed_header": {
+    "header": {
+      "version": {
+        "block": "11",
+        "app": "0"
+      },
+      "chain_id": "test-chain-hGjZNv",
+      "height": "493",
+      "time": "2025-11-26T21:34:06.159025Z",
+      "last_block_id": {
+        "hash": "6ABE9483553796549941230EFFC982A4B389FE475D37C43815E6B735E5AEDE7B",
+        "parts": {
+          "total": 1,
+          "hash": "FA7002E34B341CC2625B2A2EB546ED9A1D2B77D1146A5650D9D2E3682940EE29"
+        }
+      },
+      "last_commit_hash": "C7B78BBAF834E298EB6570836DAA9116A56BED2F652D8BAF6C28B1F33ABC8AE8",
+      "data_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
+      "validators_hash": "04C72627103FD466C7B4C30C0E654D2B58EA140493C009B8BAB66749FFEBE60C",
+      "next_validators_hash": "04C72627103FD466C7B4C30C0E654D2B58EA140493C009B8BAB66749FFEBE60C",
+      "consensus_hash": "048091BC7DDC283F77BFBF91D73C44DA58C3DF8A9CBC867405D8B7F3DAADA22F",
+      "app_hash": "180B4624DAB5D631EAD41DC7BEC0F63D2A25DF826B068604B7D858206ED92DD6",
+      "last_results_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
+      "evidence_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855",
+      "proposer_address": "F588CF8C0CA8D88CDD2F909C8262018B361CF5D5"
+    },
+    "commit": {
+      "height": "493",
+      "round": 0,
+      "block_id": {
+        "hash": "2A1D00CC2A092465E85EA2C24986BEE0105285039DC1873BB6B0CA7F610EC89D",
+        "parts": {
+          "total": 1,
+          "hash": "379E62CC2B2741AD07E1F325307BBDECDAA10F2405A22C9B9350615A5DAF2725"
+        }
+      },
+      "signatures": [
+        {
+          "block_id_flag": 2,
+          "validator_address": "F588CF8C0CA8D88CDD2F909C8262018B361CF5D5",
+          "timestamp": "2025-11-26T21:34:07.1855Z",
+          "signature": "ttukjhivwXmf9YKEFSceZe0b6D98esb+9nMCeEz6e1z5MDfxMKun7O0nPis0PoDWcqBifWJy2NdbfO0zySILDQ=="
+        }
+      ]
+    }
+  },
+  "validator_set": {
+    "validators": [
+      {
+        "address": "F588CF8C0CA8D88CDD2F909C8262018B361CF5D5",
+        "pub_key": {
+          "type": "tendermint/PubKeyEd25519",
+          "value": "Pn7hPwDPYkoBBTKxdxL0QZLdPCupGXyds/qSyOIBSZg="
+        },
+        "power": "10",
+        "name": null
+      }
+    ],
+    "proposer": {
+      "address": "F588CF8C0CA8D88CDD2F909C8262018B361CF5D5",
+      "pub_key": {
+        "type": "tendermint/PubKeyEd25519",
+        "value": "Pn7hPwDPYkoBBTKxdxL0QZLdPCupGXyds/qSyOIBSZg="
+      },
+      "power": "10",
+      "name": null
+    },
+    "total_voting_power": "10"
+  }
+}