@freedomofpress/cometbft 0.1.0

package/src/types.ts

@@ -0,0 +1,63 @@
+export interface ValidatorJson {
+  block_height?: string;
+  validators: {
+    address: string;
+    pub_key: {
+      type: string;
+      value: string;
+    };
+    voting_power?: string;
+    power?: string;
+    proposer_priority?: string;
+  }[];
+  count: string;
+  total: string;
+}
+
+export interface CommitJson {
+  signed_header: {
+    header: {
+      version: {
+        block: string;
+        app: string;
+      };
+      chain_id: string;
+      height: string;
+      time: string; // RFC3339 timestamp
+      last_block_id: {
+        hash: string;
+        parts: {
+          total: number;
+          hash: string;
+        };
+      };
+      last_commit_hash: string;
+      data_hash: string;
+      validators_hash: string;
+      next_validators_hash: string;
+      consensus_hash: string;
+      app_hash: string;
+      last_results_hash: string;
+      evidence_hash: string;
+      proposer_address: string;
+    };
+    commit: {
+      height: string;
+      round: number;
+      block_id: {
+        hash: string;
+        parts: {
+          total: number;
+          hash: string;
+        };
+      };
+      signatures: {
+        block_id_flag: number;
+        validator_address: string;
+        timestamp: string;
+        signature: string; // base64
+      }[];
+    };
+  };
+  canonical?: boolean;
+}

package/src/validators.ts

@@ -0,0 +1,84 @@
+import { base64ToUint8Array, Uint8ArrayToHex } from "./encoding";
+import { Validator, ValidatorSet } from "./proto/cometbft/types/v1/validator";
+import type { ValidatorJson } from "./types";
+
+export async function importValidators(resp: ValidatorJson): Promise<{
+  proto: ValidatorSet;
+  cryptoIndex: Map<string, CryptoKey>;
+}> {
+  const seen: Set<string> = new Set();
+  const cryptoIndex = new Map<string, CryptoKey>();
+  const protoValidators: Validator[] = [];
+
+  if (!resp.validators || resp.validators.length < 1) {
+    throw new Error("Missing validators");
+  }
+  let countedPower = 0n;
+
+  for (const v of resp.validators) {
+    if (!v.address || v.address.length !== 40) {
+      throw new Error(
+        `Validator address must be 40 HEX digits, provided: ${v.address}`,
+      );
+    }
+    if (!v.pub_key?.type || !v.pub_key?.value) {
+      throw new Error("Validator key object is invalid");
+    }
+    if (v.pub_key.type !== "tendermint/PubKeyEd25519") {
+      throw new Error(
+        `Key of type ${v.pub_key.type} is currently unsupported.`,
+      );
+    }
+
+    const rawKey = base64ToUint8Array(v.pub_key.value);
+    const key = await crypto.subtle.importKey(
+      "raw",
+      new Uint8Array(rawKey),
+      { name: "Ed25519" },
+      false,
+      ["verify"],
+    );
+
+    const sha = new Uint8Array(
+      await crypto.subtle.digest("SHA-256", new Uint8Array(rawKey)),
+    );
+    const addrHex = Uint8ArrayToHex(sha.slice(0, 20)).toUpperCase();
+
+    if (addrHex !== v.address.toUpperCase()) {
+      throw new Error(`Address ${v.address} does not match its public key`);
+    }
+    if (seen.has(addrHex)) {
+      throw new Error("Duplicate entry in validators set");
+    }
+    seen.add(addrHex);
+    cryptoIndex.set(addrHex, key);
+
+    const powerNum = Number(v.voting_power) || Number(v.power);
+    if (
+      !Number.isFinite(powerNum) ||
+      !Number.isInteger(powerNum) ||
+      powerNum < 1
+    ) {
+      throw new Error(`Invalid voting power for ${addrHex}`);
+    }
+    countedPower += BigInt(powerNum);
+
+    const protoV: Validator = {
+      address: new Uint8Array(sha.slice(0, 20)),
+      pubKeyBytes: rawKey,
+      pubKeyType: "ed25519",
+      votingPower: BigInt(powerNum),
+      proposerPriority: 0n, // JSON gives string "0"; use 0n by default
+    };
+
+    protoValidators.push(protoV);
+  }
+
+  const protoSet: ValidatorSet = {
+    validators: protoValidators,
+    proposer: undefined,
+    totalVotingPower: countedPower,
+  };
+
+  return { proto: protoSet, cryptoIndex };
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["DOM", "ES2022"],
+    "module": "ESNext",
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "outDir": "./dist"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "html", "json"],
+      include: ["src/**/*.ts"],
+      exclude: ["node_modules/**", "dist/**", "src/proto/**"],
+    },
+  },
+});