c-kzg-4844/bindings/node.js/test/kzg.test.ts

480 lines
16 KiB
TypeScript
Raw Normal View History

2022-11-03 22:13:49 +00:00
import { randomBytes } from "crypto";
import { readFileSync } from "fs";
import { resolve } from "path";
import { globSync } from "glob";
const yaml = require("js-yaml");
interface TestMeta<
I extends Record<string, any>,
O extends boolean | string | string[] | Record<string, any>,
> {
input: I;
output: O;
}
import {
loadTrustedSetup,
2022-11-03 00:17:17 +00:00
blobToKzgCommitment,
computeKzgProof,
2023-02-18 21:49:52 +00:00
computeBlobKzgProof,
verifyKzgProof,
verifyBlobKzgProof,
verifyBlobKzgProofBatch,
2023-02-14 21:11:10 +00:00
BYTES_PER_BLOB,
BYTES_PER_COMMITMENT,
BYTES_PER_PROOF,
2022-11-04 18:44:57 +00:00
BYTES_PER_FIELD_ELEMENT,
ProofResult,
} from "../lib/kzg";
2022-11-02 20:45:29 +00:00
const SETUP_FILE_PATH = resolve(
__dirname,
"__fixtures__",
"testing_trusted_setups.json",
);
2022-12-12 22:48:05 +00:00
const MAX_TOP_BYTE = 114;
2023-03-28 16:01:07 +00:00
const BLOB_TO_KZG_COMMITMENT_TESTS =
"../../tests/blob_to_kzg_commitment/*/*/data.yaml";
const COMPUTE_KZG_PROOF_TESTS = "../../tests/compute_kzg_proof/*/*/data.yaml";
const COMPUTE_BLOB_KZG_PROOF_TESTS =
"../../tests/compute_blob_kzg_proof/*/*/data.yaml";
const VERIFY_KZG_PROOF_TESTS = "../../tests/verify_kzg_proof/*/*/data.yaml";
const VERIFY_BLOB_KZG_PROOF_TESTS =
"../../tests/verify_blob_kzg_proof/*/*/data.yaml";
const VERIFY_BLOB_KZG_PROOF_BATCH_TESTS =
"../../tests/verify_blob_kzg_proof_batch/*/*/data.yaml";
type BlobToKzgCommitmentTest = TestMeta<{ blob: string }, string>;
type ComputeKzgProofTest = TestMeta<{ blob: string; z: string }, string[]>;
type ComputeBlobKzgProofTest = TestMeta<
{ blob: string; commitment: string },
string
>;
type VerifyKzgProofTest = TestMeta<
{ commitment: string; y: string; z: string; proof: string },
boolean
>;
type VerifyBlobKzgProofTest = TestMeta<
{ blob: string; commitment: string; proof: string },
boolean
>;
type VerifyBatchKzgProofTest = TestMeta<
{ blobs: string[]; commitments: string[]; proofs: string[] },
boolean
>;
2023-02-18 21:49:52 +00:00
2022-12-12 22:48:05 +00:00
const generateRandomBlob = () => {
return new Uint8Array(
2023-02-14 21:11:10 +00:00
randomBytes(BYTES_PER_BLOB).map((x, i) => {
2022-12-12 22:48:05 +00:00
// Set the top byte to be low enough that the field element doesn't overflow the BLS modulus
if (x > MAX_TOP_BYTE && i % BYTES_PER_FIELD_ELEMENT == 31) {
return Math.floor(Math.random() * MAX_TOP_BYTE);
}
return x;
}),
);
};
2022-11-03 00:17:17 +00:00
const blobValidLength = randomBytes(BYTES_PER_BLOB);
const blobBadLength = randomBytes(BYTES_PER_BLOB - 1);
const commitmentValidLength = randomBytes(BYTES_PER_COMMITMENT);
const commitmentBadLength = randomBytes(BYTES_PER_COMMITMENT - 1);
const proofValidLength = randomBytes(BYTES_PER_PROOF);
const proofBadLength = randomBytes(BYTES_PER_PROOF - 1);
const fieldElementValidLength = randomBytes(BYTES_PER_FIELD_ELEMENT);
const fieldElementBadLength = randomBytes(BYTES_PER_FIELD_ELEMENT - 1);
function bytesFromHex(hexString: string): Buffer {
return Buffer.from(hexString.slice(2), "hex");
}
2022-11-03 22:13:49 +00:00
describe("C-KZG", () => {
beforeAll(async () => {
loadTrustedSetup(SETUP_FILE_PATH);
});
2023-02-21 20:22:44 +00:00
describe("reference tests should pass", () => {
it("reference tests for blobToKzgCommitment should pass", () => {
let tests = globSync(BLOB_TO_KZG_COMMITMENT_TESTS);
expect(tests.length).toBeGreaterThan(0);
tests.forEach((testFile: string) => {
const test: BlobToKzgCommitmentTest = yaml.load(
readFileSync(testFile, "ascii"),
);
let commitment: Buffer;
let blob = bytesFromHex(test.input.blob);
2023-02-18 21:49:52 +00:00
try {
commitment = blobToKzgCommitment(blob);
2023-02-18 21:49:52 +00:00
} catch (err) {
expect(test.output).toBeNull();
return;
2023-02-18 21:49:52 +00:00
}
expect(test.output).not.toBeNull();
let expectedCommitment = bytesFromHex(test.output);
expect(commitment).toEqual(expectedCommitment);
2023-02-18 21:49:52 +00:00
});
});
2023-02-21 20:22:44 +00:00
it("reference tests for computeKzgProof should pass", () => {
let tests = globSync(COMPUTE_KZG_PROOF_TESTS);
expect(tests.length).toBeGreaterThan(0);
tests.forEach((testFile: string) => {
const test: ComputeKzgProofTest = yaml.load(
readFileSync(testFile, "ascii"),
);
let proof: ProofResult;
let blob = bytesFromHex(test.input.blob);
let z = bytesFromHex(test.input.z);
2023-02-18 21:49:52 +00:00
try {
proof = computeKzgProof(blob, z);
2023-02-18 21:49:52 +00:00
} catch (err) {
expect(test.output).toBeNull();
return;
2023-02-18 21:49:52 +00:00
}
expect(test.output).not.toBeNull();
expect(proof).toEqual(test.output.map((hex) => bytesFromHex(hex)));
2023-02-18 21:49:52 +00:00
});
});
2023-02-21 20:22:44 +00:00
it("reference tests for computeBlobKzgProof should pass", () => {
let tests = globSync(COMPUTE_BLOB_KZG_PROOF_TESTS);
expect(tests.length).toBeGreaterThan(0);
tests.forEach((testFile: string) => {
const test: ComputeBlobKzgProofTest = yaml.load(
readFileSync(testFile, "ascii"),
);
let proof: Buffer;
let blob = bytesFromHex(test.input.blob);
let commitment = bytesFromHex(test.input.commitment);
2023-02-18 21:49:52 +00:00
try {
proof = computeBlobKzgProof(blob, commitment);
2023-02-18 21:49:52 +00:00
} catch (err) {
expect(test.output).toBeNull();
return;
2023-02-18 21:49:52 +00:00
}
expect(test.output).not.toBeNull();
let expectedProof = bytesFromHex(test.output);
expect(proof).toEqual(expectedProof);
2023-02-18 21:49:52 +00:00
});
});
2023-02-21 20:22:44 +00:00
it("reference tests for verifyKzgProof should pass", () => {
let tests = globSync(VERIFY_KZG_PROOF_TESTS);
expect(tests.length).toBeGreaterThan(0);
tests.forEach((testFile: string) => {
const test: VerifyKzgProofTest = yaml.load(
readFileSync(testFile, "ascii"),
);
let valid;
let commitment = bytesFromHex(test.input.commitment);
let z = bytesFromHex(test.input.z);
let y = bytesFromHex(test.input.y);
let proof = bytesFromHex(test.input.proof);
2023-02-18 21:49:52 +00:00
try {
valid = verifyKzgProof(commitment, z, y, proof);
2023-02-18 21:49:52 +00:00
} catch (err) {
expect(test.output).toBeNull();
return;
2023-02-18 21:49:52 +00:00
}
expect(valid).toEqual(test.output);
2023-02-18 21:49:52 +00:00
});
});
2023-02-21 20:22:44 +00:00
it("reference tests for verifyBlobKzgProof should pass", () => {
let tests = globSync(VERIFY_BLOB_KZG_PROOF_TESTS);
expect(tests.length).toBeGreaterThan(0);
tests.forEach((testFile: string) => {
const test: VerifyBlobKzgProofTest = yaml.load(
readFileSync(testFile, "ascii"),
);
let valid;
let blob = bytesFromHex(test.input.blob);
let commitment = bytesFromHex(test.input.commitment);
let proof = bytesFromHex(test.input.proof);
2023-02-18 21:49:52 +00:00
try {
valid = verifyBlobKzgProof(blob, commitment, proof);
2023-02-18 21:49:52 +00:00
} catch (err) {
expect(test.output).toBeNull();
return;
2023-02-18 21:49:52 +00:00
}
expect(valid).toEqual(test.output);
2023-02-18 21:49:52 +00:00
});
});
2023-02-21 20:22:44 +00:00
it("reference tests for verifyBlobKzgProofBatch should pass", () => {
let tests = globSync(VERIFY_BLOB_KZG_PROOF_BATCH_TESTS);
expect(tests.length).toBeGreaterThan(0);
tests.forEach((testFile: string) => {
const test: VerifyBatchKzgProofTest = yaml.load(
readFileSync(testFile, "ascii"),
);
let valid;
let blobs = test.input.blobs.map(bytesFromHex);
let commitments = test.input.commitments.map(bytesFromHex);
let proofs = test.input.proofs.map(bytesFromHex);
2023-02-18 21:49:52 +00:00
try {
valid = verifyBlobKzgProofBatch(blobs, commitments, proofs);
2023-02-18 21:49:52 +00:00
} catch (err) {
expect(test.output).toBeNull();
return;
2023-02-18 21:49:52 +00:00
}
expect(valid).toEqual(test.output);
2023-02-18 21:49:52 +00:00
});
});
});
2023-02-21 20:22:44 +00:00
describe("edge cases for blobToKzgCommitment", () => {
2023-02-18 21:49:52 +00:00
it("throws as expected when given an argument of invalid type", () => {
// @ts-expect-error
expect(() => blobToKzgCommitment("wrong type")).toThrowError(
"Expected blob to be a Uint8Array",
2023-02-18 21:49:52 +00:00
);
});
it("throws as expected when given an argument of invalid length", () => {
expect(() => blobToKzgCommitment(blobBadLength)).toThrowError(
"Expected blob to be 131072 bytes",
);
2023-02-18 21:49:52 +00:00
});
2022-11-02 20:45:29 +00:00
});
2022-11-04 00:08:36 +00:00
2023-02-21 20:22:44 +00:00
// TODO: add more tests for this function.
describe("edge cases for computeKzgProof", () => {
2023-02-18 21:49:52 +00:00
it("computes a proof from blob/field element", () => {
let blob = generateRandomBlob();
const zBytes = new Uint8Array(BYTES_PER_FIELD_ELEMENT).fill(0);
computeKzgProof(blob, zBytes);
});
it("throws as expected when given an argument of invalid length", () => {
expect(() =>
computeKzgProof(blobBadLength, fieldElementValidLength),
).toThrowError("Expected blob to be 131072 bytes");
expect(() =>
computeKzgProof(blobValidLength, fieldElementBadLength),
).toThrowError("Expected zBytes to be 32 bytes");
});
});
2023-02-21 20:22:44 +00:00
// TODO: add more tests for this function.
describe("edge cases for computeBlobKzgProof", () => {
2023-02-18 21:49:52 +00:00
it("computes a proof from blob", () => {
let blob = generateRandomBlob();
let commitment = blobToKzgCommitment(blob);
computeBlobKzgProof(blob, commitment);
2023-02-18 21:49:52 +00:00
});
it("throws as expected when given an argument of invalid length", () => {
expect(() =>
computeBlobKzgProof(
blobBadLength,
blobToKzgCommitment(generateRandomBlob()),
),
).toThrowError("Expected blob to be 131072 bytes");
});
});
2023-02-21 20:22:44 +00:00
describe("edge cases for verifyKzgProof", () => {
it("valid proof should result in true", () => {
2023-02-18 21:49:52 +00:00
const commitment = new Uint8Array(BYTES_PER_COMMITMENT).fill(0);
commitment[0] = 0xc0;
const z = new Uint8Array(BYTES_PER_FIELD_ELEMENT).fill(0);
const y = new Uint8Array(BYTES_PER_FIELD_ELEMENT).fill(0);
const proof = new Uint8Array(BYTES_PER_PROOF).fill(0);
proof[0] = 0xc0;
2022-12-13 19:21:43 +00:00
2023-02-18 21:49:52 +00:00
expect(verifyKzgProof(commitment, z, y, proof)).toBe(true);
});
2022-12-13 19:24:55 +00:00
2023-02-21 20:22:44 +00:00
it("invalid proof should result in false", () => {
2023-02-18 21:49:52 +00:00
const commitment = new Uint8Array(BYTES_PER_COMMITMENT).fill(0);
commitment[0] = 0xc0;
const z = new Uint8Array(BYTES_PER_FIELD_ELEMENT).fill(1);
const y = new Uint8Array(BYTES_PER_FIELD_ELEMENT).fill(1);
const proof = new Uint8Array(BYTES_PER_PROOF).fill(0);
proof[0] = 0xc0;
2022-12-13 19:24:55 +00:00
2023-02-18 21:49:52 +00:00
expect(verifyKzgProof(commitment, z, y, proof)).toBe(false);
});
it("throws as expected when given an argument of invalid length", () => {
expect(() =>
verifyKzgProof(
commitmentBadLength,
fieldElementValidLength,
fieldElementValidLength,
proofValidLength,
),
).toThrowError("Expected commitmentBytes to be 48 bytes");
expect(() =>
verifyKzgProof(
commitmentValidLength,
fieldElementBadLength,
fieldElementValidLength,
proofValidLength,
),
).toThrowError("Expected zBytes to be 32 bytes");
expect(() =>
verifyKzgProof(
commitmentValidLength,
fieldElementValidLength,
fieldElementBadLength,
proofValidLength,
),
).toThrowError("Expected yBytes to be 32 bytes");
expect(() =>
verifyKzgProof(
commitmentValidLength,
fieldElementValidLength,
fieldElementValidLength,
proofBadLength,
),
).toThrowError("Expected proofBytes to be 48 bytes");
});
2022-12-13 19:21:43 +00:00
});
2023-02-21 20:22:44 +00:00
describe("edge cases for verifyBlobKzgProof", () => {
it("correct blob/commitment/proof should verify as true", () => {
2023-02-18 21:49:52 +00:00
let blob = generateRandomBlob();
let commitment = blobToKzgCommitment(blob);
let proof = computeBlobKzgProof(blob, commitment);
2023-02-18 21:49:52 +00:00
expect(verifyBlobKzgProof(blob, commitment, proof)).toBe(true);
});
2023-02-21 20:22:44 +00:00
it("incorrect commitment should verify as false", () => {
2023-02-18 21:49:52 +00:00
let blob = generateRandomBlob();
let commitment = blobToKzgCommitment(generateRandomBlob());
let proof = computeBlobKzgProof(blob, commitment);
2023-02-18 21:49:52 +00:00
expect(verifyBlobKzgProof(blob, commitment, proof)).toBe(false);
});
2023-02-21 20:22:44 +00:00
it("incorrect proof should verify as false", () => {
2023-02-18 21:49:52 +00:00
let blob = generateRandomBlob();
let commitment = blobToKzgCommitment(blob);
let randomBlob = generateRandomBlob();
let randomCommitment = blobToKzgCommitment(randomBlob);
let proof = computeBlobKzgProof(randomBlob, randomCommitment);
2023-02-18 21:49:52 +00:00
expect(verifyBlobKzgProof(blob, commitment, proof)).toBe(false);
});
it("throws as expected when given an argument of invalid length", () => {
expect(() =>
verifyBlobKzgProof(
blobBadLength,
commitmentValidLength,
proofValidLength,
),
).toThrowError("Expected blob to be 131072 bytes");
expect(() =>
verifyBlobKzgProof(
blobValidLength,
commitmentBadLength,
proofValidLength,
),
).toThrowError("Expected commitmentBytes to be 48 bytes");
expect(() =>
verifyBlobKzgProof(
blobValidLength,
commitmentValidLength,
proofBadLength,
),
).toThrowError("Expected proofBytes to be 48 bytes");
});
});
2023-02-21 20:22:44 +00:00
describe("edge cases for verifyBlobKzgProofBatch", () => {
it("should reject non-array args", () => {
expect(() =>
verifyBlobKzgProofBatch(
2 as unknown as Uint8Array[],
[commitmentValidLength, commitmentValidLength],
[proofValidLength, proofValidLength],
),
2023-03-30 14:17:57 +00:00
).toThrowError("Blobs, commitments, and proofs must all be arrays");
});
2023-02-22 15:10:09 +00:00
it("should reject non-bytearray blob", () => {
expect(() =>
verifyBlobKzgProofBatch(
["foo", "bar"] as unknown as Uint8Array[],
[commitmentValidLength, commitmentValidLength],
[proofValidLength, proofValidLength],
),
).toThrowError("Expected blob to be a Uint8Array");
});
it("throws as expected when given an argument of invalid length", () => {
expect(() =>
verifyBlobKzgProofBatch(
[blobBadLength, blobValidLength],
[commitmentValidLength, commitmentValidLength],
[proofValidLength, proofValidLength],
),
).toThrowError("Expected blob to be 131072 bytes");
expect(() =>
verifyBlobKzgProofBatch(
[blobValidLength, blobValidLength],
[commitmentBadLength, commitmentValidLength],
[proofValidLength, proofValidLength],
),
).toThrowError("Expected commitmentBytes to be 48 bytes");
expect(() =>
verifyBlobKzgProofBatch(
[blobValidLength, blobValidLength],
[commitmentValidLength, commitmentValidLength],
[proofValidLength, proofBadLength],
),
).toThrowError("Expected proofBytes to be 48 bytes");
2023-02-22 15:10:09 +00:00
});
2023-02-21 20:22:44 +00:00
it("zero blobs/commitments/proofs should verify as true", () => {
2023-02-18 21:49:52 +00:00
expect(verifyBlobKzgProofBatch([], [], [])).toBe(true);
});
2023-02-14 21:11:10 +00:00
2023-02-21 20:22:44 +00:00
it("mismatching blobs/commitments/proofs should throw error", () => {
2023-02-18 21:49:52 +00:00
let count = 3;
let blobs = new Array(count);
let commitments = new Array(count);
let proofs = new Array(count);
for (let [i] of blobs.entries()) {
2023-02-18 21:49:52 +00:00
blobs[i] = generateRandomBlob();
commitments[i] = blobToKzgCommitment(blobs[i]);
proofs[i] = computeBlobKzgProof(blobs[i], commitments[i]);
2023-02-18 21:49:52 +00:00
}
expect(verifyBlobKzgProofBatch(blobs, commitments, proofs)).toBe(true);
2023-02-14 21:11:10 +00:00
expect(() =>
2023-02-18 21:49:52 +00:00
verifyBlobKzgProofBatch(blobs.slice(0, 1), commitments, proofs),
2023-03-30 14:17:57 +00:00
).toThrowError("Requires equal number of blobs/commitments/proofs");
2023-02-18 21:49:52 +00:00
expect(() =>
verifyBlobKzgProofBatch(blobs, commitments.slice(0, 1), proofs),
2023-03-30 14:17:57 +00:00
).toThrowError("Requires equal number of blobs/commitments/proofs");
2023-02-18 21:49:52 +00:00
expect(() =>
verifyBlobKzgProofBatch(blobs, commitments, proofs.slice(0, 1)),
2023-03-30 14:17:57 +00:00
).toThrowError("Requires equal number of blobs/commitments/proofs");
2023-02-14 21:11:10 +00:00
});
});
2022-11-02 20:45:29 +00:00
});