From 54ecfacaeaeb02c7f9d2e1ebe6d73dcdbd4529db Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Thu, 28 Mar 2024 11:42:05 -0600 Subject: [PATCH 01/27] Create boiler plate for kzg runner --- rustc-ice-2024-03-29T15_01_52-72620.txt | 59 +++++++++++++++++++++++++ spec-tests/runners/kzg.rs | 5 +++ spec-tests/runners/mod.rs | 1 + spec-tests/test_case.rs | 6 +-- spec-tests/test_meta.rs | 2 +- 5 files changed, 69 insertions(+), 4 deletions(-) create mode 100644 rustc-ice-2024-03-29T15_01_52-72620.txt create mode 100644 spec-tests/runners/kzg.rs diff --git a/rustc-ice-2024-03-29T15_01_52-72620.txt b/rustc-ice-2024-03-29T15_01_52-72620.txt new file mode 100644 index 000000000..5f1d4846e --- /dev/null +++ b/rustc-ice-2024-03-29T15_01_52-72620.txt @@ -0,0 +1,59 @@ +thread 'rustc' panicked at compiler/rustc_middle/src/util/bug.rs:35:44: +Box +stack backtrace: + 0: 0x7fbdc9658a7f - std::backtrace_rs::backtrace::libunwind::trace::hafd7b517e60b27ef + at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/../../backtrace/src/backtrace/libunwind.rs:104:5 + 1: 0x7fbdc9658a7f - std::backtrace_rs::backtrace::trace_unsynchronized::h3dcf1c8471111015 + at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/../../backtrace/src/backtrace/mod.rs:66:5 + 2: 0x7fbdc9658a7f - std::backtrace::Backtrace::create::h089f041334eb3d98 + at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/backtrace.rs:331:13 + 3: 0x7fbdc96589c0 - std::backtrace::Backtrace::force_capture::hb73638146ba678c1 + at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/backtrace.rs:312:9 + 4: 0x7fbdc6286686 - std[7f1acebbb10ad2f1]::panicking::update_hook::>::{closure#0} + 5: 0x7fbdc9673812 - as core::ops::function::Fn>::call::h4bcc70abf9c70518 + at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/alloc/src/boxed.rs:2030:9 + 6: 0x7fbdc9673812 - std::panicking::rust_panic_with_hook::h4d6de4d4c8a288c8 + at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/panicking.rs:783:13 + 7: 0x7fbdc62b2434 - std[7f1acebbb10ad2f1]::panicking::begin_panic::::{closure#0} + 8: 0x7fbdc62af086 - std[7f1acebbb10ad2f1]::sys_common::backtrace::__rust_end_short_backtrace::::{closure#0}, !> + 9: 0x7fbdc62aa706 - std[7f1acebbb10ad2f1]::panicking::begin_panic:: + 10: 0x7fbdc62bbb61 - ::emit_producing_guarantee + 11: 0x7fbdc673b921 - rustc_middle[f473203dd8788d4]::util::bug::opt_span_bug_fmt::::{closure#0} + 12: 0x7fbdc671f38a - rustc_middle[f473203dd8788d4]::ty::context::tls::with_opt::::{closure#0}, !>::{closure#0} + 13: 0x7fbdc671f228 - rustc_middle[f473203dd8788d4]::ty::context::tls::with_context_opt::::{closure#0}, !>::{closure#0}, !> + 14: 0x7fbdc4c57760 - rustc_middle[f473203dd8788d4]::util::bug::bug_fmt + 15: 0x7fbdc673a06b - rustc_middle[f473203dd8788d4]::ty::typeck_results::invalid_hir_id_for_typeck_results + 16: 0x7fbdc78675c7 - ::pat_ty + 17: 0x7fbdc7876cdf - rustc_hir_typeck[11925a8be78966b0]::typeck + 18: 0x7fbdc78720e9 - rustc_query_impl[e5835872ae7aea92]::plumbing::__rust_begin_short_backtrace::> + 19: 0x7fbdc7a91df3 - rustc_query_system[6be8a39ca75c4004]::query::plumbing::try_execute_query::>, false, false, false>, rustc_query_impl[e5835872ae7aea92]::plumbing::QueryCtxt, true> + 20: 0x7fbdc7eb6309 - rustc_query_impl[e5835872ae7aea92]::query_impl::typeck::get_query_incr::__rust_end_short_backtrace + 21: 0x7fbdc7eb5692 - ::par_body_owners::::{closure#0} + 22: 0x7fbdc7eb3f5d - rustc_hir_analysis[9ecbd17abd23d13]::check_crate + 23: 0x7fbdc82bfeef - rustc_interface[117b78f67e30e948]::passes::analysis + 24: 0x7fbdc82bfb59 - rustc_query_impl[e5835872ae7aea92]::plumbing::__rust_begin_short_backtrace::> + 25: 0x7fbdc8373b22 - rustc_query_system[6be8a39ca75c4004]::query::plumbing::try_execute_query::>, false, false, false>, rustc_query_impl[e5835872ae7aea92]::plumbing::QueryCtxt, true> + 26: 0x7fbdc837372e - rustc_query_impl[e5835872ae7aea92]::query_impl::analysis::get_query_incr::__rust_end_short_backtrace + 27: 0x7fbdc82af20f - rustc_interface[117b78f67e30e948]::interface::run_compiler::, rustc_driver_impl[2b260be814c7fc23]::run_compiler::{closure#0}>::{closure#0} + 28: 0x7fbdc85f0997 - std[7f1acebbb10ad2f1]::sys_common::backtrace::__rust_begin_short_backtrace::, rustc_driver_impl[2b260be814c7fc23]::run_compiler::{closure#0}>::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>>::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>> + 29: 0x7fbdc85f07c4 - <::spawn_unchecked_, rustc_driver_impl[2b260be814c7fc23]::run_compiler::{closure#0}>::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>>::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>>::{closure#1} as core[8e23e68bd98ccc77]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} + 30: 0x7fbdc967cf75 - as core::ops::function::FnOnce>::call_once::hd60fe919ef7a3acd + at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/alloc/src/boxed.rs:2016:9 + 31: 0x7fbdc967cf75 - as core::ops::function::FnOnce>::call_once::h735e8292ab8c5296 + at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/alloc/src/boxed.rs:2016:9 + 32: 0x7fbdc967cf75 - std::sys::pal::unix::thread::Thread::new::thread_start::hd8e133aac405ea58 + at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/sys/pal/unix/thread.rs:108:17 + 33: 0x7fbdc3097b5a - start_thread + at ./nptl/pthread_create.c:444:8 + 34: 0x7fbdc31285fc - __GI___clone3 + at ./misc/../sysdeps/unix/sysv/linux/x86_64/clone3.S:78 + 35: 0x0 - + + +rustc version: 1.78.0-nightly (7d3702e47 2024-03-06) +platform: x86_64-unknown-linux-gnu + +query stack during panic: +#0 [typeck] type-checking `runners::kzg::_::::deserialize::::visit_map::::deserialize` +#1 [analysis] running analysis passes on this crate +end of query stack diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs new file mode 100644 index 000000000..a5ce8189f --- /dev/null +++ b/spec-tests/runners/kzg.rs @@ -0,0 +1,5 @@ +use crate::{test_case::TestCase, test_utils::Error}; + +pub fn dispatch(_test: &TestCase) -> Result<(), Error> { + todo!() +} diff --git a/spec-tests/runners/mod.rs b/spec-tests/runners/mod.rs index 701747b20..5e860c576 100644 --- a/spec-tests/runners/mod.rs +++ b/spec-tests/runners/mod.rs @@ -3,6 +3,7 @@ pub mod epoch_processing; pub mod finality; pub mod fork; pub mod genesis; +pub mod kzg; pub mod light_client; pub mod merkle_proof; pub mod operations; diff --git a/spec-tests/test_case.rs b/spec-tests/test_case.rs index dec062260..350c9415c 100644 --- a/spec-tests/test_case.rs +++ b/spec-tests/test_case.rs @@ -1,7 +1,7 @@ use crate::{ runners::{ - bls, epoch_processing, finality, fork, genesis, light_client, merkle_proof, operations, - random, rewards, sanity, shuffling, ssz_static, transition, + bls, epoch_processing, finality, fork, genesis, kzg, light_client, merkle_proof, + operations, random, rewards, sanity, shuffling, ssz_static, transition, }, test_meta::TestMeta, Config, Context, @@ -48,8 +48,8 @@ impl TestCase { Shuffling => shuffling::dispatch(self), SszStatic => ssz_static::dispatch(self), Transition => transition::dispatch(self), - Kzg => todo!(), LightClient => light_client::dispatch(self), + Kzg => kzg::dispatch(self), MerkleProof => merkle_proof::dispatch(self), Sync => todo!(), SszGeneric => unreachable!(), diff --git a/spec-tests/test_meta.rs b/spec-tests/test_meta.rs index 9d70ee6d4..d06be1b2d 100644 --- a/spec-tests/test_meta.rs +++ b/spec-tests/test_meta.rs @@ -83,7 +83,7 @@ pub enum Runner { impl Runner { pub fn should_ignore(&self) -> bool { - matches!(self, Self::ForkChoice | Self::Kzg | Self::Sync) + matches!(self, Self::ForkChoice | Self::LightClient | Self::MerkleProof | Self::Sync) } // Do not collect these tests. From e478927e5a7a51fd6910ffbc23f532fe3b91f781 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Fri, 29 Mar 2024 12:30:29 -0600 Subject: [PATCH 02/27] Boilerplate for handlers. Create (wip) `BlobToKzgCommitmentTestCase` --- spec-tests/runners/kzg.rs | 64 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 61 insertions(+), 3 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index a5ce8189f..f6e4340a8 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -1,5 +1,63 @@ -use crate::{test_case::TestCase, test_utils::Error}; +use crate::{ + test_case::TestCase, + test_utils::{load_yaml, Error}, +}; +use ethereum_consensus::deneb::{ + mainnet as spec, + polynomial_commitments::{blob_to_kzg_commitment, KzgCommitment, KzgSettings}, +}; +use serde::Deserialize; +use serde_with::{serde_as, DefaultOnError}; -pub fn dispatch(_test: &TestCase) -> Result<(), Error> { - todo!() +pub fn dispatch(test: &TestCase) -> Result<(), Error> { + let meta = &test.meta; + let path = &test.data_path; + match meta.handler.0.as_str() { + "blob_to_kzg_commitment" => { + let test_case = BlobToKzgCommitmentTestCase::from(path); + test_case.run(); + Ok(()) + } + "compute_kzg_proof" => { + todo!() + } + "verify_kzg_proof" => { + todo!() + } + "compute_blob_kzg_proof" => { + todo!() + } + "verify_blob_kzg_proof" => { + todo!() + } + "verify_blob_kzg_proof_batch" => { + todo!() + } + } +} + +#[serde_as] +#[derive(Debug, Deserialize)] +struct BlobToKzgCommitmentInput { + #[serde_as(deserialize_as = "DefaultOnError")] + blob: spec::Blob, + #[serde_as(deserialize_as = "DefaultOnError")] + kzg_settings: KzgSettings, +} + +#[derive(Debug, Deserialize)] +pub struct BlobToKzgCommitmentTestCase { + input: BlobToKzgCommitmentInput, + output: KzgCommitment, +} + +impl BlobToKzgCommitmentTestCase { + pub fn from(test_case_path: &str) -> Self { + let path = test_case_path.to_string() + "/data.yaml"; + load_yaml(&path) + } + + pub fn run(&self) -> bool { + blob_to_kzg_commitment(&self.input.blob, &self.input.kzg_settings).is_ok() + } } From 56a5f70317a80c2a16f757de62fb3e79f8c82713 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Tue, 2 Apr 2024 10:51:18 -0600 Subject: [PATCH 03/27] Attempts to create `blob_to_kzg_commitment()` test case. (Test fails for some reason) --- spec-tests/runners/kzg.rs | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index f6e4340a8..7cd9c32b9 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -4,18 +4,20 @@ use crate::{ }; use ethereum_consensus::deneb::{ mainnet as spec, - polynomial_commitments::{blob_to_kzg_commitment, KzgCommitment, KzgSettings}, + polynomial_commitments::{self, blob_to_kzg_commitment, KzgCommitment}, + presets::TRUSTED_SETUP_JSON, }; use serde::Deserialize; -use serde_with::{serde_as, DefaultOnError}; pub fn dispatch(test: &TestCase) -> Result<(), Error> { let meta = &test.meta; let path = &test.data_path; + let kzg_settings = polynomial_commitments::kzg_settings_from_json(TRUSTED_SETUP_JSON)?; + match meta.handler.0.as_str() { "blob_to_kzg_commitment" => { let test_case = BlobToKzgCommitmentTestCase::from(path); - test_case.run(); + test_case.run(&test_case.blob, &kzg_settings); Ok(()) } "compute_kzg_proof" => { @@ -33,22 +35,14 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { "verify_blob_kzg_proof_batch" => { todo!() } + _ => todo!(), } } -#[serde_as] -#[derive(Debug, Deserialize)] -struct BlobToKzgCommitmentInput { - #[serde_as(deserialize_as = "DefaultOnError")] - blob: spec::Blob, - #[serde_as(deserialize_as = "DefaultOnError")] - kzg_settings: KzgSettings, -} - #[derive(Debug, Deserialize)] pub struct BlobToKzgCommitmentTestCase { - input: BlobToKzgCommitmentInput, - output: KzgCommitment, + blob: spec::Blob, + output: Option, } impl BlobToKzgCommitmentTestCase { @@ -57,7 +51,13 @@ impl BlobToKzgCommitmentTestCase { load_yaml(&path) } - pub fn run(&self) -> bool { - blob_to_kzg_commitment(&self.input.blob, &self.input.kzg_settings).is_ok() + pub fn run( + &self, + blob: &spec::Blob, + kzg_settings: &polynomial_commitments::KzgSettings, + ) -> bool { + let kzg_commitment = blob_to_kzg_commitment(blob, kzg_settings).unwrap(); + println!("Kzg commitment: {}", kzg_commitment); + &kzg_commitment == self.output.as_ref().unwrap() } } From fc9613488ae5f41cfc6e5b93e75db93f306660a8 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Tue, 2 Apr 2024 14:09:46 -0600 Subject: [PATCH 04/27] Create `blob_to_kzg_commitment()` handler. Passes "valid blob" tests --- spec-tests/runners/kzg.rs | 19 ++++++++++++++++--- 1 file changed, 16 insertions(+), 3 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 7cd9c32b9..e27eab6ce 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -16,8 +16,21 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { match meta.handler.0.as_str() { "blob_to_kzg_commitment" => { - let test_case = BlobToKzgCommitmentTestCase::from(path); - test_case.run(&test_case.blob, &kzg_settings); + // Load test case ---- + let path = path.to_string() + "/data.yaml"; + let test_data: serde_yaml::Value = load_yaml(&path); + let input = test_data.get("input").unwrap(); + let output_yaml = test_data.get("output").unwrap(); + let blob_yaml = input.get("blob").unwrap(); + let blob: spec::Blob = serde_yaml::from_value(blob_yaml.clone()).unwrap(); + let output: polynomial_commitments::KzgCommitment = + serde_yaml::from_value(output_yaml.clone()).unwrap(); + + // TODO: Verify all test case format conditions + + // Run test ---- + let kzg_commitment = blob_to_kzg_commitment(&blob, &kzg_settings).unwrap(); + assert!(kzg_commitment == output); Ok(()) } "compute_kzg_proof" => { @@ -41,7 +54,7 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { #[derive(Debug, Deserialize)] pub struct BlobToKzgCommitmentTestCase { - blob: spec::Blob, + input: spec::Blob, output: Option, } From e5155d2b7eaeda89e24ae90e2dba03de511f1869 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Tue, 2 Apr 2024 16:11:33 -0600 Subject: [PATCH 05/27] Implements `blob_to_kzg_commitment()` handler --- .../src/deneb/polynomial_commitments.rs | 2 +- spec-tests/runners/kzg.rs | 44 +++++++++++++------ 2 files changed, 32 insertions(+), 14 deletions(-) diff --git a/ethereum-consensus/src/deneb/polynomial_commitments.rs b/ethereum-consensus/src/deneb/polynomial_commitments.rs index d65621be2..78c9bb3cf 100644 --- a/ethereum-consensus/src/deneb/polynomial_commitments.rs +++ b/ethereum-consensus/src/deneb/polynomial_commitments.rs @@ -1,7 +1,7 @@ use crate::{ deneb::blob_sidecar::Blob, primitives::Bytes32, ssz::prelude::*, Error as ConsensusError, }; -pub use c_kzg::KzgSettings; +pub use c_kzg::{Error as CKzgError, KzgSettings}; use thiserror::Error; pub const BYTES_PER_FIELD_ELEMENT: usize = 32; diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index e27eab6ce..9047bf36d 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -3,16 +3,18 @@ use crate::{ test_utils::{load_yaml, Error}, }; use ethereum_consensus::deneb::{ - mainnet as spec, - polynomial_commitments::{self, blob_to_kzg_commitment, KzgCommitment}, + mainnet::Blob, + polynomial_commitments::{ + blob_to_kzg_commitment, kzg_settings_from_json, CKzgError, + Error as PolynomialCommitmentsError, KzgCommitment, + }, presets::TRUSTED_SETUP_JSON, }; -use serde::Deserialize; pub fn dispatch(test: &TestCase) -> Result<(), Error> { let meta = &test.meta; let path = &test.data_path; - let kzg_settings = polynomial_commitments::kzg_settings_from_json(TRUSTED_SETUP_JSON)?; + let kzg_settings = kzg_settings_from_json(TRUSTED_SETUP_JSON)?; match meta.handler.0.as_str() { "blob_to_kzg_commitment" => { @@ -22,16 +24,31 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { let input = test_data.get("input").unwrap(); let output_yaml = test_data.get("output").unwrap(); let blob_yaml = input.get("blob").unwrap(); - let blob: spec::Blob = serde_yaml::from_value(blob_yaml.clone()).unwrap(); - let output: polynomial_commitments::KzgCommitment = - serde_yaml::from_value(output_yaml.clone()).unwrap(); - // TODO: Verify all test case format conditions + let input_result: Result = serde_yaml::from_value(blob_yaml.clone()); + let output_result: Result, _> = + serde_yaml::from_value(output_yaml.clone()); - // Run test ---- - let kzg_commitment = blob_to_kzg_commitment(&blob, &kzg_settings).unwrap(); - assert!(kzg_commitment == output); - Ok(()) + match (input_result, output_result) { + (Ok(blob), Ok(Some(expected))) => { + let kzg_commitment = blob_to_kzg_commitment(&blob, &kzg_settings).unwrap(); + assert!(kzg_commitment == expected); + Ok(()) + } + (Err(_), Ok(None)) => { + // Expected state for failed test case + Ok(()) + } + (Ok(blob), Ok(None)) => { + let result = blob_to_kzg_commitment(&blob, &kzg_settings); + assert!(matches!( + result, + Err(PolynomialCommitmentsError::CKzg(CKzgError::CError(..))) + )); + Ok(()) + } + _ => unreachable!("not possible"), + } } "compute_kzg_proof" => { todo!() @@ -51,7 +68,7 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { _ => todo!(), } } - +/* #[derive(Debug, Deserialize)] pub struct BlobToKzgCommitmentTestCase { input: spec::Blob, @@ -74,3 +91,4 @@ impl BlobToKzgCommitmentTestCase { &kzg_commitment == self.output.as_ref().unwrap() } } + */ From b67f3d5487e697082de88365bcd8a9c80d3d45a5 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Wed, 3 Apr 2024 14:57:06 -0600 Subject: [PATCH 06/27] Create `compute_kzg_proof` handler --- .../src/deneb/polynomial_commitments.rs | 1 + spec-tests/runners/kzg.rs | 74 +++++++++++-------- 2 files changed, 46 insertions(+), 29 deletions(-) diff --git a/ethereum-consensus/src/deneb/polynomial_commitments.rs b/ethereum-consensus/src/deneb/polynomial_commitments.rs index 78c9bb3cf..88a004845 100644 --- a/ethereum-consensus/src/deneb/polynomial_commitments.rs +++ b/ethereum-consensus/src/deneb/polynomial_commitments.rs @@ -54,6 +54,7 @@ pub enum Error { InvalidProof, } +#[derive(Debug, PartialEq)] pub struct ProofAndEvaluation { pub proof: KzgProof, pub evaluation: FieldElement, diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 9047bf36d..14e8aba94 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -5,8 +5,9 @@ use crate::{ use ethereum_consensus::deneb::{ mainnet::Blob, polynomial_commitments::{ - blob_to_kzg_commitment, kzg_settings_from_json, CKzgError, - Error as PolynomialCommitmentsError, KzgCommitment, + blob_to_kzg_commitment, compute_kzg_proof, kzg_settings_from_json, CKzgError, + Error as PolynomialCommitmentsError, FieldElement, KzgCommitment, KzgProof, + ProofAndEvaluation, }, presets::TRUSTED_SETUP_JSON, }; @@ -21,9 +22,9 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { // Load test case ---- let path = path.to_string() + "/data.yaml"; let test_data: serde_yaml::Value = load_yaml(&path); - let input = test_data.get("input").unwrap(); + let input_yaml = test_data.get("input").unwrap(); let output_yaml = test_data.get("output").unwrap(); - let blob_yaml = input.get("blob").unwrap(); + let blob_yaml = input_yaml.get("blob").unwrap(); let input_result: Result = serde_yaml::from_value(blob_yaml.clone()); let output_result: Result, _> = @@ -51,7 +52,46 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { } } "compute_kzg_proof" => { - todo!() + // Load test case ---- + let path = path.to_string() + "/data.yaml"; + let test_data: serde_yaml::Value = load_yaml(&path); + let input_yaml = test_data.get("input").unwrap(); + let output_yaml = test_data.get("output").unwrap(); + let blob_yaml = input_yaml.get("blob").unwrap(); + let z_yaml = input_yaml.get("z").unwrap(); + + let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); + let input_z_result: Result = serde_yaml::from_value(z_yaml.clone()); + let output_result: Result, _> = + serde_yaml::from_value(output_yaml.clone()); + + match (input_blob_result, input_z_result, output_result) { + // All maps for yaml file deserialized correctly + (Ok(blob), Ok(z), Ok(Some(expected))) => { + let proof_and_evaluation = compute_kzg_proof(&blob, &z, &kzg_settings).unwrap(); + let expected = ProofAndEvaluation { proof: expected.0, evaluation: expected.1 }; + assert_eq!(proof_and_evaluation, expected); + Ok(()) + } + (Err(_), Ok(_), Ok(None)) => { + // Expected state for failed test case - invalid length blob + Ok(()) + } + (Ok(blob), Ok(z), Ok(None)) => { + let result = compute_kzg_proof(&blob, &z, &kzg_settings); + assert!(matches!( + result, + Err(PolynomialCommitmentsError::CKzg(CKzgError::CError(..))) + )); + Ok(()) + } + + (Ok(_), Err(_), Ok(None)) => { + // Expected state for failed test case - invalid evaluation point + Ok(()) + } + _ => unreachable!("not possible"), + } } "verify_kzg_proof" => { todo!() @@ -68,27 +108,3 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { _ => todo!(), } } -/* -#[derive(Debug, Deserialize)] -pub struct BlobToKzgCommitmentTestCase { - input: spec::Blob, - output: Option, -} - -impl BlobToKzgCommitmentTestCase { - pub fn from(test_case_path: &str) -> Self { - let path = test_case_path.to_string() + "/data.yaml"; - load_yaml(&path) - } - - pub fn run( - &self, - blob: &spec::Blob, - kzg_settings: &polynomial_commitments::KzgSettings, - ) -> bool { - let kzg_commitment = blob_to_kzg_commitment(blob, kzg_settings).unwrap(); - println!("Kzg commitment: {}", kzg_commitment); - &kzg_commitment == self.output.as_ref().unwrap() - } -} - */ From 37f7bb7c31b4dfd5a2f31222ac500c8968028501 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Wed, 3 Apr 2024 15:56:28 -0600 Subject: [PATCH 07/27] Iterate on feedback --- .../src/deneb/polynomial_commitments.rs | 2 +- spec-tests/runners/kzg.rs | 35 +++++++++---------- 2 files changed, 17 insertions(+), 20 deletions(-) diff --git a/ethereum-consensus/src/deneb/polynomial_commitments.rs b/ethereum-consensus/src/deneb/polynomial_commitments.rs index 88a004845..a977345d9 100644 --- a/ethereum-consensus/src/deneb/polynomial_commitments.rs +++ b/ethereum-consensus/src/deneb/polynomial_commitments.rs @@ -1,7 +1,7 @@ use crate::{ deneb::blob_sidecar::Blob, primitives::Bytes32, ssz::prelude::*, Error as ConsensusError, }; -pub use c_kzg::{Error as CKzgError, KzgSettings}; +pub use c_kzg::KzgSettings; use thiserror::Error; pub const BYTES_PER_FIELD_ELEMENT: usize = 32; diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 14e8aba94..6754f2aaf 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -5,7 +5,7 @@ use crate::{ use ethereum_consensus::deneb::{ mainnet::Blob, polynomial_commitments::{ - blob_to_kzg_commitment, compute_kzg_proof, kzg_settings_from_json, CKzgError, + blob_to_kzg_commitment, compute_kzg_proof, kzg_settings_from_json, Error as PolynomialCommitmentsError, FieldElement, KzgCommitment, KzgProof, ProofAndEvaluation, }, @@ -31,21 +31,18 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { serde_yaml::from_value(output_yaml.clone()); match (input_result, output_result) { - (Ok(blob), Ok(Some(expected))) => { + (Ok(blob), Ok(Some(expected_commmitment))) => { let kzg_commitment = blob_to_kzg_commitment(&blob, &kzg_settings).unwrap(); - assert!(kzg_commitment == expected); + assert!(kzg_commitment == expected_commmitment); Ok(()) } (Err(_), Ok(None)) => { - // Expected state for failed test case + // Note: Expected state for failed test case Ok(()) } (Ok(blob), Ok(None)) => { let result = blob_to_kzg_commitment(&blob, &kzg_settings); - assert!(matches!( - result, - Err(PolynomialCommitmentsError::CKzg(CKzgError::CError(..))) - )); + assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) } _ => unreachable!("not possible"), @@ -66,28 +63,28 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { serde_yaml::from_value(output_yaml.clone()); match (input_blob_result, input_z_result, output_result) { - // All maps for yaml file deserialized correctly - (Ok(blob), Ok(z), Ok(Some(expected))) => { + // Note: All maps for yaml file deserialized correctly + (Ok(blob), Ok(z), Ok(Some(expected_proof_and_evaluation))) => { let proof_and_evaluation = compute_kzg_proof(&blob, &z, &kzg_settings).unwrap(); - let expected = ProofAndEvaluation { proof: expected.0, evaluation: expected.1 }; - assert_eq!(proof_and_evaluation, expected); + let expected_proof_and_evaluation = ProofAndEvaluation { + proof: expected_proof_and_evaluation.0, + evaluation: expected_proof_and_evaluation.1, + }; + assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); Ok(()) } (Err(_), Ok(_), Ok(None)) => { - // Expected state for failed test case - invalid length blob + // Note: Expected state for failed test case - invalid length blob Ok(()) } (Ok(blob), Ok(z), Ok(None)) => { let result = compute_kzg_proof(&blob, &z, &kzg_settings); - assert!(matches!( - result, - Err(PolynomialCommitmentsError::CKzg(CKzgError::CError(..))) - )); + assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) } (Ok(_), Err(_), Ok(None)) => { - // Expected state for failed test case - invalid evaluation point + // Note: Expected state for failed test case - invalid evaluation point Ok(()) } _ => unreachable!("not possible"), @@ -105,6 +102,6 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { "verify_blob_kzg_proof_batch" => { todo!() } - _ => todo!(), + handler => unreachable!("no tests for {handler}"), } } From 184a7090e877c48fb0e1e797f7772360520486db Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Thu, 4 Apr 2024 20:35:34 -0600 Subject: [PATCH 08/27] Implements happy case to kzg proof verification. WIP for unhappy cases --- spec-tests/runners/kzg.rs | 63 ++++++++++++++++++++++++++++++++++----- 1 file changed, 55 insertions(+), 8 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 6754f2aaf..d6dc33a7e 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -5,7 +5,7 @@ use crate::{ use ethereum_consensus::deneb::{ mainnet::Blob, polynomial_commitments::{ - blob_to_kzg_commitment, compute_kzg_proof, kzg_settings_from_json, + blob_to_kzg_commitment, compute_kzg_proof, kzg_settings_from_json, verify_kzg_proof, Error as PolynomialCommitmentsError, FieldElement, KzgCommitment, KzgProof, ProofAndEvaluation, }, @@ -23,8 +23,8 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { let path = path.to_string() + "/data.yaml"; let test_data: serde_yaml::Value = load_yaml(&path); let input_yaml = test_data.get("input").unwrap(); - let output_yaml = test_data.get("output").unwrap(); let blob_yaml = input_yaml.get("blob").unwrap(); + let output_yaml = test_data.get("output").unwrap(); let input_result: Result = serde_yaml::from_value(blob_yaml.clone()); let output_result: Result, _> = @@ -37,7 +37,7 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { Ok(()) } (Err(_), Ok(None)) => { - // Note: Expected state for failed test case + // Note: Expected state for invalid length blob Ok(()) } (Ok(blob), Ok(None)) => { @@ -53,9 +53,9 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { let path = path.to_string() + "/data.yaml"; let test_data: serde_yaml::Value = load_yaml(&path); let input_yaml = test_data.get("input").unwrap(); - let output_yaml = test_data.get("output").unwrap(); let blob_yaml = input_yaml.get("blob").unwrap(); let z_yaml = input_yaml.get("z").unwrap(); + let output_yaml = test_data.get("output").unwrap(); let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); let input_z_result: Result = serde_yaml::from_value(z_yaml.clone()); @@ -74,7 +74,7 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { Ok(()) } (Err(_), Ok(_), Ok(None)) => { - // Note: Expected state for failed test case - invalid length blob + // Note: Expected state for invalid length blob Ok(()) } (Ok(blob), Ok(z), Ok(None)) => { @@ -82,16 +82,63 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) } - (Ok(_), Err(_), Ok(None)) => { - // Note: Expected state for failed test case - invalid evaluation point + // Note: Expected state for invalid evaluation point Ok(()) } _ => unreachable!("not possible"), } } "verify_kzg_proof" => { - todo!() + // Load test case ---- + let path = path.to_string() + "/data.yaml"; + let test_data: serde_yaml::Value = load_yaml(&path); + let input_yaml = test_data.get("input").unwrap(); + let commitment_yaml = input_yaml.get("commitment").unwrap(); + let z_yaml = input_yaml.get("z").unwrap(); + let y_yaml = input_yaml.get("y").unwrap(); + let proof_yaml = input_yaml.get("proof").unwrap(); + let output_yaml = test_data.get("output").unwrap(); + + let input_commitment_result: Result = + serde_yaml::from_value(commitment_yaml.clone()); + let input_z_result: Result = serde_yaml::from_value(z_yaml.clone()); + let input_y_result: Result = serde_yaml::from_value(y_yaml.clone()); + let input_proof_result: Result = + serde_yaml::from_value(proof_yaml.clone()); + let output_result: Result, _> = + serde_yaml::from_value(output_yaml.clone()); + + match ( + input_commitment_result, + input_z_result, + input_y_result, + input_proof_result, + output_result, + ) { + ( + Ok(commitment), + Ok(z), + Ok(y), + Ok(proof), + Ok(Some(expected_verification_status)), + ) => { + assert!( + verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings).is_ok() + == expected_verification_status + ); + Ok(()) + } + // Note: If the commitment or proof or z or y is invalid... + (Ok(commitment), Ok(z), Ok(y), Ok(proof), Ok(None)) => { + let result = verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings); + assert!(matches!(result, Err(..))); + Ok(()) + } + + // TODO: Implement remaining test case states + _ => unreachable!("not possible"), + } } "compute_blob_kzg_proof" => { todo!() From ccba416f8bddf5598c45eddeb500804754387887 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Fri, 5 Apr 2024 11:45:08 -0600 Subject: [PATCH 09/27] Create "verify_kzg_proof" handler. (All tests pass) --- spec-tests/runners/kzg.rs | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index d6dc33a7e..2044c7048 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -73,15 +73,15 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); Ok(()) } - (Err(_), Ok(_), Ok(None)) => { - // Note: Expected state for invalid length blob - Ok(()) - } (Ok(blob), Ok(z), Ok(None)) => { let result = compute_kzg_proof(&blob, &z, &kzg_settings); assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) } + (Err(_), Ok(_), Ok(None)) => { + // Note: Expected state for invalid length blob + Ok(()) + } (Ok(_), Err(_), Ok(None)) => { // Note: Expected state for invalid evaluation point Ok(()) @@ -129,14 +129,18 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { ); Ok(()) } - // Note: If the commitment or proof or z or y is invalid... + // Note: If the commitment or proof or z or y is malformed... + (Err(_), Ok(_), Ok(_), Ok(_), Ok(None)) => Ok(()), + (Ok(_), Err(_), Ok(_), Ok(_), Ok(None)) => Ok(()), + (Ok(_), Ok(_), Err(_), Ok(_), Ok(None)) => Ok(()), + (Ok(_), Ok(_), Ok(_), Err(_), Ok(None)) => Ok(()), + // Note: This match catches no failing tests. Is the test suite incomplete? Or does deserialization + // into the types catch all invalid state for inputs here? (unlike tests utilizing blobs) (Ok(commitment), Ok(z), Ok(y), Ok(proof), Ok(None)) => { let result = verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings); assert!(matches!(result, Err(..))); Ok(()) } - - // TODO: Implement remaining test case states _ => unreachable!("not possible"), } } From fbea38c753fdcc8a376e256ae677062673d357eb Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Fri, 5 Apr 2024 12:44:45 -0600 Subject: [PATCH 10/27] Place testing logic within internal `run` functions --- spec-tests/runners/kzg.rs | 293 +++++++++++++++++++++----------------- 1 file changed, 159 insertions(+), 134 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 2044c7048..326e36e0a 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -6,153 +6,178 @@ use ethereum_consensus::deneb::{ mainnet::Blob, polynomial_commitments::{ blob_to_kzg_commitment, compute_kzg_proof, kzg_settings_from_json, verify_kzg_proof, - Error as PolynomialCommitmentsError, FieldElement, KzgCommitment, KzgProof, + Error as PolynomialCommitmentsError, FieldElement, KzgCommitment, KzgProof, KzgSettings, ProofAndEvaluation, }, presets::TRUSTED_SETUP_JSON, }; pub fn dispatch(test: &TestCase) -> Result<(), Error> { - let meta = &test.meta; - let path = &test.data_path; let kzg_settings = kzg_settings_from_json(TRUSTED_SETUP_JSON)?; - match meta.handler.0.as_str() { - "blob_to_kzg_commitment" => { - // Load test case ---- - let path = path.to_string() + "/data.yaml"; - let test_data: serde_yaml::Value = load_yaml(&path); - let input_yaml = test_data.get("input").unwrap(); - let blob_yaml = input_yaml.get("blob").unwrap(); - let output_yaml = test_data.get("output").unwrap(); - - let input_result: Result = serde_yaml::from_value(blob_yaml.clone()); - let output_result: Result, _> = - serde_yaml::from_value(output_yaml.clone()); - - match (input_result, output_result) { - (Ok(blob), Ok(Some(expected_commmitment))) => { - let kzg_commitment = blob_to_kzg_commitment(&blob, &kzg_settings).unwrap(); - assert!(kzg_commitment == expected_commmitment); - Ok(()) - } - (Err(_), Ok(None)) => { - // Note: Expected state for invalid length blob - Ok(()) - } - (Ok(blob), Ok(None)) => { - let result = blob_to_kzg_commitment(&blob, &kzg_settings); - assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); - Ok(()) - } - _ => unreachable!("not possible"), - } + match test.meta.handler.0.as_str() { + "blob_to_kzg_commitment" => run_blob_to_kzg_commitment_test(test, &kzg_settings), + "compute_kzg_proof" => run_compute_kzg_proof_test(test, &kzg_settings), + "verify_kzg_proof" => run_verify_kzg_proof_test(test, &kzg_settings), + "compute_blob_kzg_proof" => run_compute_blob_kzg_proof_test(test, &kzg_settings), + "verify_blob_kzg_proof" => run_verify_blob_kzg_proof_test(test, &kzg_settings), + "verify_blob_kzg_proof_batch" => run_verify_blob_kzg_proof_batch_test(test, &kzg_settings), + handler => unreachable!("no tests for {handler}"), + } +} + +fn run_blob_to_kzg_commitment_test( + test: &TestCase, + kzg_settings: &KzgSettings, +) -> Result<(), Error> { + let path = &test.data_path; + // Load test case ---- + let path = path.to_string() + "/data.yaml"; + let test_data: serde_yaml::Value = load_yaml(&path); + let input_yaml = test_data.get("input").unwrap(); + let blob_yaml = input_yaml.get("blob").unwrap(); + let output_yaml = test_data.get("output").unwrap(); + + let input_result: Result = serde_yaml::from_value(blob_yaml.clone()); + let output_result: Result, _> = + serde_yaml::from_value(output_yaml.clone()); + + match (input_result, output_result) { + (Ok(blob), Ok(Some(expected_commmitment))) => { + let kzg_commitment = blob_to_kzg_commitment(&blob, &kzg_settings).unwrap(); + assert!(kzg_commitment == expected_commmitment); + Ok(()) } - "compute_kzg_proof" => { - // Load test case ---- - let path = path.to_string() + "/data.yaml"; - let test_data: serde_yaml::Value = load_yaml(&path); - let input_yaml = test_data.get("input").unwrap(); - let blob_yaml = input_yaml.get("blob").unwrap(); - let z_yaml = input_yaml.get("z").unwrap(); - let output_yaml = test_data.get("output").unwrap(); - - let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); - let input_z_result: Result = serde_yaml::from_value(z_yaml.clone()); - let output_result: Result, _> = - serde_yaml::from_value(output_yaml.clone()); - - match (input_blob_result, input_z_result, output_result) { - // Note: All maps for yaml file deserialized correctly - (Ok(blob), Ok(z), Ok(Some(expected_proof_and_evaluation))) => { - let proof_and_evaluation = compute_kzg_proof(&blob, &z, &kzg_settings).unwrap(); - let expected_proof_and_evaluation = ProofAndEvaluation { - proof: expected_proof_and_evaluation.0, - evaluation: expected_proof_and_evaluation.1, - }; - assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); - Ok(()) - } - (Ok(blob), Ok(z), Ok(None)) => { - let result = compute_kzg_proof(&blob, &z, &kzg_settings); - assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); - Ok(()) - } - (Err(_), Ok(_), Ok(None)) => { - // Note: Expected state for invalid length blob - Ok(()) - } - (Ok(_), Err(_), Ok(None)) => { - // Note: Expected state for invalid evaluation point - Ok(()) - } - _ => unreachable!("not possible"), - } + (Err(_), Ok(None)) => { + // Note: Expected state for invalid length blob + Ok(()) } - "verify_kzg_proof" => { - // Load test case ---- - let path = path.to_string() + "/data.yaml"; - let test_data: serde_yaml::Value = load_yaml(&path); - let input_yaml = test_data.get("input").unwrap(); - let commitment_yaml = input_yaml.get("commitment").unwrap(); - let z_yaml = input_yaml.get("z").unwrap(); - let y_yaml = input_yaml.get("y").unwrap(); - let proof_yaml = input_yaml.get("proof").unwrap(); - let output_yaml = test_data.get("output").unwrap(); - - let input_commitment_result: Result = - serde_yaml::from_value(commitment_yaml.clone()); - let input_z_result: Result = serde_yaml::from_value(z_yaml.clone()); - let input_y_result: Result = serde_yaml::from_value(y_yaml.clone()); - let input_proof_result: Result = - serde_yaml::from_value(proof_yaml.clone()); - let output_result: Result, _> = - serde_yaml::from_value(output_yaml.clone()); - - match ( - input_commitment_result, - input_z_result, - input_y_result, - input_proof_result, - output_result, - ) { - ( - Ok(commitment), - Ok(z), - Ok(y), - Ok(proof), - Ok(Some(expected_verification_status)), - ) => { - assert!( - verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings).is_ok() - == expected_verification_status - ); - Ok(()) - } - // Note: If the commitment or proof or z or y is malformed... - (Err(_), Ok(_), Ok(_), Ok(_), Ok(None)) => Ok(()), - (Ok(_), Err(_), Ok(_), Ok(_), Ok(None)) => Ok(()), - (Ok(_), Ok(_), Err(_), Ok(_), Ok(None)) => Ok(()), - (Ok(_), Ok(_), Ok(_), Err(_), Ok(None)) => Ok(()), - // Note: This match catches no failing tests. Is the test suite incomplete? Or does deserialization - // into the types catch all invalid state for inputs here? (unlike tests utilizing blobs) - (Ok(commitment), Ok(z), Ok(y), Ok(proof), Ok(None)) => { - let result = verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings); - assert!(matches!(result, Err(..))); - Ok(()) - } - _ => unreachable!("not possible"), - } + (Ok(blob), Ok(None)) => { + let result = blob_to_kzg_commitment(&blob, &kzg_settings); + assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); + Ok(()) } - "compute_blob_kzg_proof" => { - todo!() + _ => unreachable!("not possible"), + } +} + +fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Result<(), Error> { + let path = &test.data_path; + // Load test case ---- + let path = path.to_string() + "/data.yaml"; + let test_data: serde_yaml::Value = load_yaml(&path); + let input_yaml = test_data.get("input").unwrap(); + let blob_yaml = input_yaml.get("blob").unwrap(); + let z_yaml = input_yaml.get("z").unwrap(); + let output_yaml = test_data.get("output").unwrap(); + + let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); + let input_z_result: Result = serde_yaml::from_value(z_yaml.clone()); + let output_result: Result, _> = + serde_yaml::from_value(output_yaml.clone()); + + match (input_blob_result, input_z_result, output_result) { + // Note: All maps for yaml file deserialized correctly + (Ok(blob), Ok(z), Ok(Some(expected_proof_and_evaluation))) => { + let proof_and_evaluation = compute_kzg_proof(&blob, &z, &kzg_settings).unwrap(); + let expected_proof_and_evaluation = ProofAndEvaluation { + proof: expected_proof_and_evaluation.0, + evaluation: expected_proof_and_evaluation.1, + }; + assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); + Ok(()) } - "verify_blob_kzg_proof" => { - todo!() + (Ok(blob), Ok(z), Ok(None)) => { + let result = compute_kzg_proof(&blob, &z, &kzg_settings); + assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); + Ok(()) } - "verify_blob_kzg_proof_batch" => { - todo!() + (Err(_), Ok(_), Ok(None)) => { + // Note: Expected state for invalid length blob + Ok(()) } - handler => unreachable!("no tests for {handler}"), + (Ok(_), Err(_), Ok(None)) => { + // Note: Expected state for invalid evaluation point + Ok(()) + } + _ => unreachable!("not possible"), } } + +fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Result<(), Error> { + let path = &test.data_path; + // Load test case ---- + let path = path.to_string() + "/data.yaml"; + let test_data: serde_yaml::Value = load_yaml(&path); + let input_yaml = test_data.get("input").unwrap(); + let commitment_yaml = input_yaml.get("commitment").unwrap(); + let z_yaml = input_yaml.get("z").unwrap(); + let y_yaml = input_yaml.get("y").unwrap(); + let proof_yaml = input_yaml.get("proof").unwrap(); + let output_yaml = test_data.get("output").unwrap(); + + let input_commitment_result: Result = + serde_yaml::from_value(commitment_yaml.clone()); + let input_z_result: Result = serde_yaml::from_value(z_yaml.clone()); + let input_y_result: Result = serde_yaml::from_value(y_yaml.clone()); + let input_proof_result: Result = serde_yaml::from_value(proof_yaml.clone()); + let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); + + match ( + input_commitment_result, + input_z_result, + input_y_result, + input_proof_result, + output_result, + ) { + (Ok(commitment), Ok(z), Ok(y), Ok(proof), Ok(Some(expected_verification_status))) => { + assert!( + verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings).is_ok() + == expected_verification_status + ); + Ok(()) + } + // Note: If the commitment or proof or z or y is malformed... + (Err(_), Ok(_), Ok(_), Ok(_), Ok(None)) => Ok(()), + (Ok(_), Err(_), Ok(_), Ok(_), Ok(None)) => Ok(()), + (Ok(_), Ok(_), Err(_), Ok(_), Ok(None)) => Ok(()), + (Ok(_), Ok(_), Ok(_), Err(_), Ok(None)) => Ok(()), + + // Note: This match catches no failing tests. Is the test suite incomplete? Or would + // deserialization into the types catch all invalid state for inputs here? + // (unlike tests utilizing blobs) + (Ok(commitment), Ok(z), Ok(y), Ok(proof), Ok(None)) => { + let result = verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings); + assert!(matches!(result, Err(..))); + Ok(()) + } + _ => unreachable!("not possible"), + } +} + +fn run_compute_blob_kzg_proof_test( + test: &TestCase, + kzg_settings: &KzgSettings, +) -> Result<(), Error> { + let path = &test.data_path; + + todo!() +} + +fn run_verify_blob_kzg_proof_test( + test: &TestCase, + kzg_settings: &KzgSettings, +) -> Result<(), Error> { + let path = &test.data_path; + + todo!() +} + +fn run_verify_blob_kzg_proof_batch_test( + test: &TestCase, + kzg_settings: &KzgSettings, +) -> Result<(), Error> { + let path = &test.data_path; + + todo!() +} From a902107ee1059ad0fc3f990f76861fe11a7446d4 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Sat, 6 Apr 2024 09:20:24 -0600 Subject: [PATCH 11/27] refactor `run_verify_kzg_proof_test` to simplify deserialization --- spec-tests/runners/kzg.rs | 80 +++++++++++++++++++++++---------------- 1 file changed, 48 insertions(+), 32 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 326e36e0a..ddf139277 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -114,44 +114,60 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res let z_yaml = input_yaml.get("z").unwrap(); let y_yaml = input_yaml.get("y").unwrap(); let proof_yaml = input_yaml.get("proof").unwrap(); - let output_yaml = test_data.get("output").unwrap(); - let input_commitment_result: Result = - serde_yaml::from_value(commitment_yaml.clone()); - let input_z_result: Result = serde_yaml::from_value(z_yaml.clone()); - let input_y_result: Result = serde_yaml::from_value(y_yaml.clone()); - let input_proof_result: Result = serde_yaml::from_value(proof_yaml.clone()); + let output_yaml = test_data.get("output").unwrap(); let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); + let output = output_result.unwrap(); + + // Check the deserialization of each input + let commitment = match serde_yaml::from_value(commitment_yaml.clone()) { + Ok(commitment) => commitment, + Err(_) => { + assert!(output.is_none()); + return Ok(()) + } + }; - match ( - input_commitment_result, - input_z_result, - input_y_result, - input_proof_result, - output_result, - ) { - (Ok(commitment), Ok(z), Ok(y), Ok(proof), Ok(Some(expected_verification_status))) => { - assert!( - verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings).is_ok() - == expected_verification_status - ); - Ok(()) + let z = match serde_yaml::from_value(z_yaml.clone()) { + Ok(z) => z, + Err(_) => { + assert!(output.is_none()); + return Ok(()) } - // Note: If the commitment or proof or z or y is malformed... - (Err(_), Ok(_), Ok(_), Ok(_), Ok(None)) => Ok(()), - (Ok(_), Err(_), Ok(_), Ok(_), Ok(None)) => Ok(()), - (Ok(_), Ok(_), Err(_), Ok(_), Ok(None)) => Ok(()), - (Ok(_), Ok(_), Ok(_), Err(_), Ok(None)) => Ok(()), - - // Note: This match catches no failing tests. Is the test suite incomplete? Or would - // deserialization into the types catch all invalid state for inputs here? - // (unlike tests utilizing blobs) - (Ok(commitment), Ok(z), Ok(y), Ok(proof), Ok(None)) => { - let result = verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings); - assert!(matches!(result, Err(..))); + }; + + let y = match serde_yaml::from_value(y_yaml.clone()) { + Ok(y) => y, + Err(_) => { + assert!(output.is_none()); + return Ok(()) + } + }; + + let proof = match serde_yaml::from_value(proof_yaml.clone()) { + Ok(proof) => proof, + Err(_) => { + assert!(output.is_none()); + return Ok(()) + } + }; + + let result = verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings); + if let Some(expected_validity) = output { + // some `output` was present, use inner value to determine if the spec code should succeed + // or fail + if expected_validity { + assert!(result.is_ok()); + Ok(()) + } else { + assert!(result.is_err()); Ok(()) } - _ => unreachable!("not possible"), + } else { + // `output` is `null`, implying the spec code should always fail + let result = verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings); + assert!(result.is_err()); + Ok(()) } } From 9a921b6622d70c31dfafe4ce5d040afa946997ae Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Sat, 6 Apr 2024 10:09:11 -0600 Subject: [PATCH 12/27] Add semicolons (formatter told me to) --- spec-tests/runners/kzg.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index ddf139277..9dbd86706 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -124,7 +124,7 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res Ok(commitment) => commitment, Err(_) => { assert!(output.is_none()); - return Ok(()) + return Ok(()); } }; @@ -132,7 +132,7 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res Ok(z) => z, Err(_) => { assert!(output.is_none()); - return Ok(()) + return Ok(()); } }; @@ -140,7 +140,7 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res Ok(y) => y, Err(_) => { assert!(output.is_none()); - return Ok(()) + return Ok(()); } }; @@ -148,7 +148,7 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res Ok(proof) => proof, Err(_) => { assert!(output.is_none()); - return Ok(()) + return Ok(()); } }; From 318dd202d2d9118e8ee37a4877d33ed90bb8f199 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Tue, 9 Apr 2024 09:31:37 -0600 Subject: [PATCH 13/27] Create "compute_blob_kzg_proof" handler --- spec-tests/runners/kzg.rs | 45 +++++++++++++++++++++++++++++++++------ 1 file changed, 39 insertions(+), 6 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 9dbd86706..252073860 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -5,9 +5,9 @@ use crate::{ use ethereum_consensus::deneb::{ mainnet::Blob, polynomial_commitments::{ - blob_to_kzg_commitment, compute_kzg_proof, kzg_settings_from_json, verify_kzg_proof, - Error as PolynomialCommitmentsError, FieldElement, KzgCommitment, KzgProof, KzgSettings, - ProofAndEvaluation, + blob_to_kzg_commitment, compute_blob_kzg_proof, compute_kzg_proof, kzg_settings_from_json, + verify_kzg_proof, Error as PolynomialCommitmentsError, FieldElement, KzgCommitment, + KzgProof, KzgSettings, ProofAndEvaluation, }, presets::TRUSTED_SETUP_JSON, }; @@ -38,11 +38,11 @@ fn run_blob_to_kzg_commitment_test( let blob_yaml = input_yaml.get("blob").unwrap(); let output_yaml = test_data.get("output").unwrap(); - let input_result: Result = serde_yaml::from_value(blob_yaml.clone()); + let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); - match (input_result, output_result) { + match (input_blob_result, output_result) { (Ok(blob), Ok(Some(expected_commmitment))) => { let kzg_commitment = blob_to_kzg_commitment(&blob, &kzg_settings).unwrap(); assert!(kzg_commitment == expected_commmitment); @@ -176,8 +176,41 @@ fn run_compute_blob_kzg_proof_test( kzg_settings: &KzgSettings, ) -> Result<(), Error> { let path = &test.data_path; + // Load test case ---- + let path = path.to_string() + "/data.yaml"; + let test_data: serde_yaml::Value = load_yaml(&path); + let input_yaml = test_data.get("input").unwrap(); + let blob_yaml = input_yaml.get("blob").unwrap(); + let commitment_yaml = input_yaml.get("commitment").unwrap(); + let output_yaml = test_data.get("output").unwrap(); - todo!() + let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); + let input_commitment_result: Result = + serde_yaml::from_value(commitment_yaml.clone()); + let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); + + match (input_blob_result, input_commitment_result, output_result) { + // Note: All maps for yaml file deserialized correctly + (Ok(blob), Ok(commitment), Ok(Some(expected_proof))) => { + let proof = compute_blob_kzg_proof(&blob, &commitment, &kzg_settings).unwrap(); + assert_eq!(proof, expected_proof); + Ok(()) + } + (Ok(blob), Ok(commitment), Ok(None)) => { + let result = compute_blob_kzg_proof(&blob, &commitment, &kzg_settings); + assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); + Ok(()) + } + (Err(_), Ok(_), Ok(None)) => { + // Note: Expected state for invalid length blob + Ok(()) + } + (Ok(_), Err(_), Ok(None)) => { + // Note: Expected state for invalid evaluation point + Ok(()) + } + _ => unreachable!("not possible"), + } } fn run_verify_blob_kzg_proof_test( From a969b2ee66595e804a8d941455bb9a97bed3b3be Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Tue, 9 Apr 2024 09:49:17 -0600 Subject: [PATCH 14/27] Fix formatting warnings --- spec-tests/runners/kzg.rs | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 252073860..fb1edbf26 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -44,7 +44,7 @@ fn run_blob_to_kzg_commitment_test( match (input_blob_result, output_result) { (Ok(blob), Ok(Some(expected_commmitment))) => { - let kzg_commitment = blob_to_kzg_commitment(&blob, &kzg_settings).unwrap(); + let kzg_commitment = blob_to_kzg_commitment(&blob, kzg_settings).unwrap(); assert!(kzg_commitment == expected_commmitment); Ok(()) } @@ -53,7 +53,7 @@ fn run_blob_to_kzg_commitment_test( Ok(()) } (Ok(blob), Ok(None)) => { - let result = blob_to_kzg_commitment(&blob, &kzg_settings); + let result = blob_to_kzg_commitment(&blob, kzg_settings); assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) } @@ -79,7 +79,7 @@ fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Re match (input_blob_result, input_z_result, output_result) { // Note: All maps for yaml file deserialized correctly (Ok(blob), Ok(z), Ok(Some(expected_proof_and_evaluation))) => { - let proof_and_evaluation = compute_kzg_proof(&blob, &z, &kzg_settings).unwrap(); + let proof_and_evaluation = compute_kzg_proof(&blob, &z, kzg_settings).unwrap(); let expected_proof_and_evaluation = ProofAndEvaluation { proof: expected_proof_and_evaluation.0, evaluation: expected_proof_and_evaluation.1, @@ -88,7 +88,7 @@ fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Re Ok(()) } (Ok(blob), Ok(z), Ok(None)) => { - let result = compute_kzg_proof(&blob, &z, &kzg_settings); + let result = compute_kzg_proof(&blob, &z, kzg_settings); assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) } @@ -152,7 +152,7 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res } }; - let result = verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings); + let result = verify_kzg_proof(&commitment, &z, &y, &proof, kzg_settings); if let Some(expected_validity) = output { // some `output` was present, use inner value to determine if the spec code should succeed // or fail @@ -165,7 +165,7 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res } } else { // `output` is `null`, implying the spec code should always fail - let result = verify_kzg_proof(&commitment, &z, &y, &proof, &kzg_settings); + let result = verify_kzg_proof(&commitment, &z, &y, &proof, kzg_settings); assert!(result.is_err()); Ok(()) } @@ -192,12 +192,12 @@ fn run_compute_blob_kzg_proof_test( match (input_blob_result, input_commitment_result, output_result) { // Note: All maps for yaml file deserialized correctly (Ok(blob), Ok(commitment), Ok(Some(expected_proof))) => { - let proof = compute_blob_kzg_proof(&blob, &commitment, &kzg_settings).unwrap(); + let proof = compute_blob_kzg_proof(&blob, &commitment, kzg_settings).unwrap(); assert_eq!(proof, expected_proof); Ok(()) } (Ok(blob), Ok(commitment), Ok(None)) => { - let result = compute_blob_kzg_proof(&blob, &commitment, &kzg_settings); + let result = compute_blob_kzg_proof(&blob, &commitment, kzg_settings); assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) } @@ -215,18 +215,18 @@ fn run_compute_blob_kzg_proof_test( fn run_verify_blob_kzg_proof_test( test: &TestCase, - kzg_settings: &KzgSettings, + _kzg_settings: &KzgSettings, ) -> Result<(), Error> { - let path = &test.data_path; + let _path = &test.data_path; todo!() } fn run_verify_blob_kzg_proof_batch_test( test: &TestCase, - kzg_settings: &KzgSettings, + _kzg_settings: &KzgSettings, ) -> Result<(), Error> { - let path = &test.data_path; + let _path = &test.data_path; todo!() } From 8040acb288a3ada89de05a883874a47207b01530 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Tue, 9 Apr 2024 14:03:29 -0600 Subject: [PATCH 15/27] `unwrap()` on all outputs --- spec-tests/runners/kzg.rs | 60 +++++++++++++++++++++++++++------------ 1 file changed, 42 insertions(+), 18 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index fb1edbf26..f7c70be93 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -6,8 +6,8 @@ use ethereum_consensus::deneb::{ mainnet::Blob, polynomial_commitments::{ blob_to_kzg_commitment, compute_blob_kzg_proof, compute_kzg_proof, kzg_settings_from_json, - verify_kzg_proof, Error as PolynomialCommitmentsError, FieldElement, KzgCommitment, - KzgProof, KzgSettings, ProofAndEvaluation, + verify_blob_kzg_proof, verify_kzg_proof, Error as PolynomialCommitmentsError, FieldElement, + KzgCommitment, KzgProof, KzgSettings, ProofAndEvaluation, }, presets::TRUSTED_SETUP_JSON, }; @@ -41,18 +41,19 @@ fn run_blob_to_kzg_commitment_test( let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); + let output = output_result.unwrap(); - match (input_blob_result, output_result) { - (Ok(blob), Ok(Some(expected_commmitment))) => { + match (input_blob_result, output) { + (Ok(blob), Some(expected_commmitment)) => { let kzg_commitment = blob_to_kzg_commitment(&blob, kzg_settings).unwrap(); assert!(kzg_commitment == expected_commmitment); Ok(()) } - (Err(_), Ok(None)) => { + (Err(_), None) => { // Note: Expected state for invalid length blob Ok(()) } - (Ok(blob), Ok(None)) => { + (Ok(blob), None) => { let result = blob_to_kzg_commitment(&blob, kzg_settings); assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) @@ -75,10 +76,11 @@ fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Re let input_z_result: Result = serde_yaml::from_value(z_yaml.clone()); let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); + let output = output_result.unwrap(); - match (input_blob_result, input_z_result, output_result) { + match (input_blob_result, input_z_result, output) { // Note: All maps for yaml file deserialized correctly - (Ok(blob), Ok(z), Ok(Some(expected_proof_and_evaluation))) => { + (Ok(blob), Ok(z), Some(expected_proof_and_evaluation)) => { let proof_and_evaluation = compute_kzg_proof(&blob, &z, kzg_settings).unwrap(); let expected_proof_and_evaluation = ProofAndEvaluation { proof: expected_proof_and_evaluation.0, @@ -87,16 +89,16 @@ fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Re assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); Ok(()) } - (Ok(blob), Ok(z), Ok(None)) => { + (Ok(blob), Ok(z), None) => { let result = compute_kzg_proof(&blob, &z, kzg_settings); assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) } - (Err(_), Ok(_), Ok(None)) => { + (Err(_), Ok(_), None) => { // Note: Expected state for invalid length blob Ok(()) } - (Ok(_), Err(_), Ok(None)) => { + (Ok(_), Err(_), None) => { // Note: Expected state for invalid evaluation point Ok(()) } @@ -188,24 +190,25 @@ fn run_compute_blob_kzg_proof_test( let input_commitment_result: Result = serde_yaml::from_value(commitment_yaml.clone()); let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); + let output = output_result.unwrap(); - match (input_blob_result, input_commitment_result, output_result) { + match (input_blob_result, input_commitment_result, output) { // Note: All maps for yaml file deserialized correctly - (Ok(blob), Ok(commitment), Ok(Some(expected_proof))) => { + (Ok(blob), Ok(commitment), Some(expected_proof)) => { let proof = compute_blob_kzg_proof(&blob, &commitment, kzg_settings).unwrap(); assert_eq!(proof, expected_proof); Ok(()) } - (Ok(blob), Ok(commitment), Ok(None)) => { + (Ok(blob), Ok(commitment), None) => { let result = compute_blob_kzg_proof(&blob, &commitment, kzg_settings); assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) } - (Err(_), Ok(_), Ok(None)) => { + (Err(_), Ok(_), None) => { // Note: Expected state for invalid length blob Ok(()) } - (Ok(_), Err(_), Ok(None)) => { + (Ok(_), Err(_), None) => { // Note: Expected state for invalid evaluation point Ok(()) } @@ -215,9 +218,30 @@ fn run_compute_blob_kzg_proof_test( fn run_verify_blob_kzg_proof_test( test: &TestCase, - _kzg_settings: &KzgSettings, + kzg_settings: &KzgSettings, ) -> Result<(), Error> { - let _path = &test.data_path; + let path = &test.data_path; + // Load test case ---- + let path = path.to_string() + "/data.yaml"; + let test_data: serde_yaml::Value = load_yaml(&path); + let input_yaml = test_data.get("input").unwrap(); + let blob_yaml = input_yaml.get("blob").unwrap(); + let commitment_yaml = input_yaml.get("commitment").unwrap(); + let proof_yaml = input_yaml.get("proof").unwrap(); + let output_yaml = test_data.get("output").unwrap(); + + let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); + let input_commitment_result: Result = + serde_yaml::from_value(commitment_yaml.clone()); + let input_proof_result: Result = serde_yaml::from_value(proof_yaml.clone()); + let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); + let output = output_result.unwrap(); + + match (input_blob_result, input_commitment_result, input_proof_result, output) { + (Ok(blob), Ok(commitment), Ok(proof), Some(expected_validity)) => { + let result = verify_blob_kzg_proof(&blob, &commitment, &proof, kzg_settings); + } + } todo!() } From aa997fd1a69cd6269e98d0e395d379b5ca056b6f Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Tue, 9 Apr 2024 15:14:26 -0600 Subject: [PATCH 16/27] Creates "verify_blob_kzg_proof" handler. (WIP) Test cases with invalid proof FAIL --- spec-tests/runners/kzg.rs | 32 ++++++++++++++++++++------------ 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index f7c70be93..582154bd2 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -193,7 +193,6 @@ fn run_compute_blob_kzg_proof_test( let output = output_result.unwrap(); match (input_blob_result, input_commitment_result, output) { - // Note: All maps for yaml file deserialized correctly (Ok(blob), Ok(commitment), Some(expected_proof)) => { let proof = compute_blob_kzg_proof(&blob, &commitment, kzg_settings).unwrap(); assert_eq!(proof, expected_proof); @@ -204,14 +203,9 @@ fn run_compute_blob_kzg_proof_test( assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); Ok(()) } - (Err(_), Ok(_), None) => { - // Note: Expected state for invalid length blob - Ok(()) - } - (Ok(_), Err(_), None) => { - // Note: Expected state for invalid evaluation point - Ok(()) - } + (Err(_), Ok(_), None) => Ok(()), + (Ok(_), Err(_), None) => Ok(()), + (Err(_), Err(_), None) => Ok(()), _ => unreachable!("not possible"), } } @@ -238,12 +232,26 @@ fn run_verify_blob_kzg_proof_test( let output = output_result.unwrap(); match (input_blob_result, input_commitment_result, input_proof_result, output) { - (Ok(blob), Ok(commitment), Ok(proof), Some(expected_validity)) => { + (Ok(blob), Ok(commitment), Ok(proof), Some(_expected_validity)) => { let result = verify_blob_kzg_proof(&blob, &commitment, &proof, kzg_settings); + // Note: expected_validity is never compared. This is ok, right? + assert!(result.is_ok()); + Ok(()) } - } + (Ok(blob), Ok(commitment), Ok(proof), None) => { + let result = verify_blob_kzg_proof(&blob, &commitment, &proof, kzg_settings); + assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); + Ok(()) + } + // Note: "Err(_), Err(_), ..." and other variants are possible. Should i either match on + // those cases or check for individual deserializations like + // `run_verify_kzg_proof_test`? + (Err(_), Ok(_), Ok(_), None) => Ok(()), + (Ok(_), Err(_), Ok(_), None) => Ok(()), + (Ok(_), Ok(_), Err(_), None) => Ok(()), - todo!() + _ => unreachable!("not possible"), + } } fn run_verify_blob_kzg_proof_batch_test( From d2f0af93f52b0e84fb1711b1e8cbf89f8c531873 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Wed, 10 Apr 2024 10:35:43 -0600 Subject: [PATCH 17/27] Create "verify_blob_kzg_proof" handler --- spec-tests/runners/kzg.rs | 60 +++++++++++++++++++++++++-------------- 1 file changed, 39 insertions(+), 21 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 582154bd2..40c004e79 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -222,35 +222,53 @@ fn run_verify_blob_kzg_proof_test( let blob_yaml = input_yaml.get("blob").unwrap(); let commitment_yaml = input_yaml.get("commitment").unwrap(); let proof_yaml = input_yaml.get("proof").unwrap(); - let output_yaml = test_data.get("output").unwrap(); - let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); - let input_commitment_result: Result = - serde_yaml::from_value(commitment_yaml.clone()); - let input_proof_result: Result = serde_yaml::from_value(proof_yaml.clone()); + let output_yaml = test_data.get("output").unwrap(); let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); let output = output_result.unwrap(); - match (input_blob_result, input_commitment_result, input_proof_result, output) { - (Ok(blob), Ok(commitment), Ok(proof), Some(_expected_validity)) => { - let result = verify_blob_kzg_proof(&blob, &commitment, &proof, kzg_settings); - // Note: expected_validity is never compared. This is ok, right? + // Check the deserialization of each input. Checks for validity. + let blob: Blob = match serde_yaml::from_value(blob_yaml.clone()) { + Ok(blob) => blob, + Err(_) => { + assert!(output.is_none()); + return Ok(()); + } + }; + + let commitment = match serde_yaml::from_value(commitment_yaml.clone()) { + Ok(commitment) => commitment, + Err(_) => { + assert!(output.is_none()); + return Ok(()); + } + }; + + let proof = match serde_yaml::from_value(proof_yaml.clone()) { + Ok(proof) => proof, + Err(_) => { + assert!(output.is_none()); + return Ok(()); + } + }; + + let result = verify_blob_kzg_proof(&blob, &commitment, &proof, kzg_settings); + // Then check for incorrect proofs with if else statements on expected_validity. + if let Some(expected_validity) = output { + // some `output` was present, use inner value to determine if the spec code should succeed + // or fail + if expected_validity { assert!(result.is_ok()); Ok(()) - } - (Ok(blob), Ok(commitment), Ok(proof), None) => { - let result = verify_blob_kzg_proof(&blob, &commitment, &proof, kzg_settings); - assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); + } else { + assert!(result.is_err()); Ok(()) } - // Note: "Err(_), Err(_), ..." and other variants are possible. Should i either match on - // those cases or check for individual deserializations like - // `run_verify_kzg_proof_test`? - (Err(_), Ok(_), Ok(_), None) => Ok(()), - (Ok(_), Err(_), Ok(_), None) => Ok(()), - (Ok(_), Ok(_), Err(_), None) => Ok(()), - - _ => unreachable!("not possible"), + } else { + // `output` is `null`, implying the spec code should always fail + let result = verify_blob_kzg_proof(&blob, &commitment, &proof, kzg_settings); + assert!(result.is_err()); + Ok(()) } } From 00e28486fde59346e925c3d5689d91182ceb4b4f Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Wed, 10 Apr 2024 11:27:31 -0600 Subject: [PATCH 18/27] Removes ice file. Removes LightClient and MerkleProof test runners from `should_ignore()` --- rustc-ice-2024-03-29T15_01_52-72620.txt | 59 ------------------------- spec-tests/runners/kzg.rs | 6 +++ spec-tests/test_meta.rs | 2 +- 3 files changed, 7 insertions(+), 60 deletions(-) delete mode 100644 rustc-ice-2024-03-29T15_01_52-72620.txt diff --git a/rustc-ice-2024-03-29T15_01_52-72620.txt b/rustc-ice-2024-03-29T15_01_52-72620.txt deleted file mode 100644 index 5f1d4846e..000000000 --- a/rustc-ice-2024-03-29T15_01_52-72620.txt +++ /dev/null @@ -1,59 +0,0 @@ -thread 'rustc' panicked at compiler/rustc_middle/src/util/bug.rs:35:44: -Box -stack backtrace: - 0: 0x7fbdc9658a7f - std::backtrace_rs::backtrace::libunwind::trace::hafd7b517e60b27ef - at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/../../backtrace/src/backtrace/libunwind.rs:104:5 - 1: 0x7fbdc9658a7f - std::backtrace_rs::backtrace::trace_unsynchronized::h3dcf1c8471111015 - at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/../../backtrace/src/backtrace/mod.rs:66:5 - 2: 0x7fbdc9658a7f - std::backtrace::Backtrace::create::h089f041334eb3d98 - at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/backtrace.rs:331:13 - 3: 0x7fbdc96589c0 - std::backtrace::Backtrace::force_capture::hb73638146ba678c1 - at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/backtrace.rs:312:9 - 4: 0x7fbdc6286686 - std[7f1acebbb10ad2f1]::panicking::update_hook::>::{closure#0} - 5: 0x7fbdc9673812 - as core::ops::function::Fn>::call::h4bcc70abf9c70518 - at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/alloc/src/boxed.rs:2030:9 - 6: 0x7fbdc9673812 - std::panicking::rust_panic_with_hook::h4d6de4d4c8a288c8 - at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/panicking.rs:783:13 - 7: 0x7fbdc62b2434 - std[7f1acebbb10ad2f1]::panicking::begin_panic::::{closure#0} - 8: 0x7fbdc62af086 - std[7f1acebbb10ad2f1]::sys_common::backtrace::__rust_end_short_backtrace::::{closure#0}, !> - 9: 0x7fbdc62aa706 - std[7f1acebbb10ad2f1]::panicking::begin_panic:: - 10: 0x7fbdc62bbb61 - ::emit_producing_guarantee - 11: 0x7fbdc673b921 - rustc_middle[f473203dd8788d4]::util::bug::opt_span_bug_fmt::::{closure#0} - 12: 0x7fbdc671f38a - rustc_middle[f473203dd8788d4]::ty::context::tls::with_opt::::{closure#0}, !>::{closure#0} - 13: 0x7fbdc671f228 - rustc_middle[f473203dd8788d4]::ty::context::tls::with_context_opt::::{closure#0}, !>::{closure#0}, !> - 14: 0x7fbdc4c57760 - rustc_middle[f473203dd8788d4]::util::bug::bug_fmt - 15: 0x7fbdc673a06b - rustc_middle[f473203dd8788d4]::ty::typeck_results::invalid_hir_id_for_typeck_results - 16: 0x7fbdc78675c7 - ::pat_ty - 17: 0x7fbdc7876cdf - rustc_hir_typeck[11925a8be78966b0]::typeck - 18: 0x7fbdc78720e9 - rustc_query_impl[e5835872ae7aea92]::plumbing::__rust_begin_short_backtrace::> - 19: 0x7fbdc7a91df3 - rustc_query_system[6be8a39ca75c4004]::query::plumbing::try_execute_query::>, false, false, false>, rustc_query_impl[e5835872ae7aea92]::plumbing::QueryCtxt, true> - 20: 0x7fbdc7eb6309 - rustc_query_impl[e5835872ae7aea92]::query_impl::typeck::get_query_incr::__rust_end_short_backtrace - 21: 0x7fbdc7eb5692 - ::par_body_owners::::{closure#0} - 22: 0x7fbdc7eb3f5d - rustc_hir_analysis[9ecbd17abd23d13]::check_crate - 23: 0x7fbdc82bfeef - rustc_interface[117b78f67e30e948]::passes::analysis - 24: 0x7fbdc82bfb59 - rustc_query_impl[e5835872ae7aea92]::plumbing::__rust_begin_short_backtrace::> - 25: 0x7fbdc8373b22 - rustc_query_system[6be8a39ca75c4004]::query::plumbing::try_execute_query::>, false, false, false>, rustc_query_impl[e5835872ae7aea92]::plumbing::QueryCtxt, true> - 26: 0x7fbdc837372e - rustc_query_impl[e5835872ae7aea92]::query_impl::analysis::get_query_incr::__rust_end_short_backtrace - 27: 0x7fbdc82af20f - rustc_interface[117b78f67e30e948]::interface::run_compiler::, rustc_driver_impl[2b260be814c7fc23]::run_compiler::{closure#0}>::{closure#0} - 28: 0x7fbdc85f0997 - std[7f1acebbb10ad2f1]::sys_common::backtrace::__rust_begin_short_backtrace::, rustc_driver_impl[2b260be814c7fc23]::run_compiler::{closure#0}>::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>>::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>> - 29: 0x7fbdc85f07c4 - <::spawn_unchecked_, rustc_driver_impl[2b260be814c7fc23]::run_compiler::{closure#0}>::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>>::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[8e23e68bd98ccc77]::result::Result<(), rustc_span[38a3e6a15b4ad553]::ErrorGuaranteed>>::{closure#1} as core[8e23e68bd98ccc77]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} - 30: 0x7fbdc967cf75 - as core::ops::function::FnOnce>::call_once::hd60fe919ef7a3acd - at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/alloc/src/boxed.rs:2016:9 - 31: 0x7fbdc967cf75 - as core::ops::function::FnOnce>::call_once::h735e8292ab8c5296 - at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/alloc/src/boxed.rs:2016:9 - 32: 0x7fbdc967cf75 - std::sys::pal::unix::thread::Thread::new::thread_start::hd8e133aac405ea58 - at /rustc/7d3702e472b99be0f5de6608dd87af1df8f99428/library/std/src/sys/pal/unix/thread.rs:108:17 - 33: 0x7fbdc3097b5a - start_thread - at ./nptl/pthread_create.c:444:8 - 34: 0x7fbdc31285fc - __GI___clone3 - at ./misc/../sysdeps/unix/sysv/linux/x86_64/clone3.S:78 - 35: 0x0 - - - -rustc version: 1.78.0-nightly (7d3702e47 2024-03-06) -platform: x86_64-unknown-linux-gnu - -query stack during panic: -#0 [typeck] type-checking `runners::kzg::_::::deserialize::::visit_map::::deserialize` -#1 [analysis] running analysis passes on this crate -end of query stack diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 40c004e79..b308bfc7b 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -43,6 +43,8 @@ fn run_blob_to_kzg_commitment_test( serde_yaml::from_value(output_yaml.clone()); let output = output_result.unwrap(); + // TODO: Check the deserialization of each input + match (input_blob_result, output) { (Ok(blob), Some(expected_commmitment)) => { let kzg_commitment = blob_to_kzg_commitment(&blob, kzg_settings).unwrap(); @@ -78,6 +80,8 @@ fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Re serde_yaml::from_value(output_yaml.clone()); let output = output_result.unwrap(); + // TODO: Check the deserialization of each input + match (input_blob_result, input_z_result, output) { // Note: All maps for yaml file deserialized correctly (Ok(blob), Ok(z), Some(expected_proof_and_evaluation)) => { @@ -192,6 +196,8 @@ fn run_compute_blob_kzg_proof_test( let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); let output = output_result.unwrap(); + // TODO: Check the deserialization of each input + match (input_blob_result, input_commitment_result, output) { (Ok(blob), Ok(commitment), Some(expected_proof)) => { let proof = compute_blob_kzg_proof(&blob, &commitment, kzg_settings).unwrap(); diff --git a/spec-tests/test_meta.rs b/spec-tests/test_meta.rs index d06be1b2d..4c2341f65 100644 --- a/spec-tests/test_meta.rs +++ b/spec-tests/test_meta.rs @@ -83,7 +83,7 @@ pub enum Runner { impl Runner { pub fn should_ignore(&self) -> bool { - matches!(self, Self::ForkChoice | Self::LightClient | Self::MerkleProof | Self::Sync) + matches!(self, Self::ForkChoice | Self::Sync) } // Do not collect these tests. From fb2d1b01dadb83cd4e629c52f0c0ee89e3e42ef4 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Wed, 10 Apr 2024 13:20:55 -0600 Subject: [PATCH 19/27] Convert all handler logic to deserialize input before handling test output logic --- spec-tests/runners/kzg.rs | 156 ++++++++++++++++++++------------------ 1 file changed, 81 insertions(+), 75 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index b308bfc7b..8e45c7498 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -6,8 +6,8 @@ use ethereum_consensus::deneb::{ mainnet::Blob, polynomial_commitments::{ blob_to_kzg_commitment, compute_blob_kzg_proof, compute_kzg_proof, kzg_settings_from_json, - verify_blob_kzg_proof, verify_kzg_proof, Error as PolynomialCommitmentsError, FieldElement, - KzgCommitment, KzgProof, KzgSettings, ProofAndEvaluation, + verify_blob_kzg_proof, verify_kzg_proof, FieldElement, KzgCommitment, KzgProof, + KzgSettings, ProofAndEvaluation, }, presets::TRUSTED_SETUP_JSON, }; @@ -38,35 +38,40 @@ fn run_blob_to_kzg_commitment_test( let blob_yaml = input_yaml.get("blob").unwrap(); let output_yaml = test_data.get("output").unwrap(); - let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); let output = output_result.unwrap(); - // TODO: Check the deserialization of each input - - match (input_blob_result, output) { - (Ok(blob), Some(expected_commmitment)) => { - let kzg_commitment = blob_to_kzg_commitment(&blob, kzg_settings).unwrap(); - assert!(kzg_commitment == expected_commmitment); - Ok(()) - } - (Err(_), None) => { - // Note: Expected state for invalid length blob - Ok(()) + // Check the deserialization of input(s) + let blob: Blob = match serde_yaml::from_value(blob_yaml.clone()) { + Ok(blob) => blob, + Err(_) => { + assert!(output.is_none()); + return Ok(()); } - (Ok(blob), None) => { - let result = blob_to_kzg_commitment(&blob, kzg_settings); - assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); - Ok(()) + }; + + let result = blob_to_kzg_commitment(&blob, kzg_settings); + if let Some(expected_commitment) = output { + // some `output` was present, use inner value to determine if the spec code should succeed + // or fail + match result { + Ok(commitment) => { + assert_eq!(commitment, expected_commitment); + Ok(()) + } + Err(_) => Ok(()), } - _ => unreachable!("not possible"), + } else { + // `output` is `null`, implying the spec code should always fail + let result = blob_to_kzg_commitment(&blob, kzg_settings); + assert!(result.is_err()); + Ok(()) } } fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Result<(), Error> { let path = &test.data_path; - // Load test case ---- let path = path.to_string() + "/data.yaml"; let test_data: serde_yaml::Value = load_yaml(&path); let input_yaml = test_data.get("input").unwrap(); @@ -74,45 +79,48 @@ fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Re let z_yaml = input_yaml.get("z").unwrap(); let output_yaml = test_data.get("output").unwrap(); - let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); - let input_z_result: Result = serde_yaml::from_value(z_yaml.clone()); let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); let output = output_result.unwrap(); - // TODO: Check the deserialization of each input - - match (input_blob_result, input_z_result, output) { - // Note: All maps for yaml file deserialized correctly - (Ok(blob), Ok(z), Some(expected_proof_and_evaluation)) => { - let proof_and_evaluation = compute_kzg_proof(&blob, &z, kzg_settings).unwrap(); - let expected_proof_and_evaluation = ProofAndEvaluation { - proof: expected_proof_and_evaluation.0, - evaluation: expected_proof_and_evaluation.1, - }; - assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); - Ok(()) - } - (Ok(blob), Ok(z), None) => { - let result = compute_kzg_proof(&blob, &z, kzg_settings); - assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); - Ok(()) + let blob: Blob = match serde_yaml::from_value(blob_yaml.clone()) { + Ok(blob) => blob, + Err(_) => { + assert!(output.is_none()); + return Ok(()); } - (Err(_), Ok(_), None) => { - // Note: Expected state for invalid length blob - Ok(()) + }; + + let z = match serde_yaml::from_value(z_yaml.clone()) { + Ok(z) => z, + Err(_) => { + assert!(output.is_none()); + return Ok(()); } - (Ok(_), Err(_), None) => { - // Note: Expected state for invalid evaluation point - Ok(()) + }; + + let result = compute_kzg_proof(&blob, &z, kzg_settings); + if let Some(expected_proof_and_evaluation) = output { + match result { + Ok(proof_and_evaluation) => { + let expected_proof_and_evaluation = ProofAndEvaluation { + proof: expected_proof_and_evaluation.0, + evaluation: expected_proof_and_evaluation.1, + }; + assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); + return Ok(()); + } + Err(_) => Ok(()), } - _ => unreachable!("not possible"), + } else { + let result = compute_kzg_proof(&blob, &z, kzg_settings); + assert!(result.is_err()); + Ok(()) } } fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Result<(), Error> { let path = &test.data_path; - // Load test case ---- let path = path.to_string() + "/data.yaml"; let test_data: serde_yaml::Value = load_yaml(&path); let input_yaml = test_data.get("input").unwrap(); @@ -125,7 +133,6 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); let output = output_result.unwrap(); - // Check the deserialization of each input let commitment = match serde_yaml::from_value(commitment_yaml.clone()) { Ok(commitment) => commitment, Err(_) => { @@ -160,8 +167,6 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res let result = verify_kzg_proof(&commitment, &z, &y, &proof, kzg_settings); if let Some(expected_validity) = output { - // some `output` was present, use inner value to determine if the spec code should succeed - // or fail if expected_validity { assert!(result.is_ok()); Ok(()) @@ -170,7 +175,6 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res Ok(()) } } else { - // `output` is `null`, implying the spec code should always fail let result = verify_kzg_proof(&commitment, &z, &y, &proof, kzg_settings); assert!(result.is_err()); Ok(()) @@ -182,7 +186,6 @@ fn run_compute_blob_kzg_proof_test( kzg_settings: &KzgSettings, ) -> Result<(), Error> { let path = &test.data_path; - // Load test case ---- let path = path.to_string() + "/data.yaml"; let test_data: serde_yaml::Value = load_yaml(&path); let input_yaml = test_data.get("input").unwrap(); @@ -190,29 +193,38 @@ fn run_compute_blob_kzg_proof_test( let commitment_yaml = input_yaml.get("commitment").unwrap(); let output_yaml = test_data.get("output").unwrap(); - let input_blob_result: Result = serde_yaml::from_value(blob_yaml.clone()); - let input_commitment_result: Result = - serde_yaml::from_value(commitment_yaml.clone()); let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); let output = output_result.unwrap(); - // TODO: Check the deserialization of each input + let blob: Blob = match serde_yaml::from_value(blob_yaml.clone()) { + Ok(blob) => blob, + Err(_) => { + assert!(output.is_none()); + return Ok(()); + } + }; - match (input_blob_result, input_commitment_result, output) { - (Ok(blob), Ok(commitment), Some(expected_proof)) => { - let proof = compute_blob_kzg_proof(&blob, &commitment, kzg_settings).unwrap(); - assert_eq!(proof, expected_proof); - Ok(()) + let commitment = match serde_yaml::from_value(commitment_yaml.clone()) { + Ok(commitment) => commitment, + Err(_) => { + assert!(output.is_none()); + return Ok(()); } - (Ok(blob), Ok(commitment), None) => { - let result = compute_blob_kzg_proof(&blob, &commitment, kzg_settings); - assert!(matches!(result, Err(PolynomialCommitmentsError::CKzg(..)))); - Ok(()) + }; + + let result = compute_blob_kzg_proof(&blob, &commitment, kzg_settings); + if let Some(expected_proof) = output { + match result { + Ok(proof) => { + assert_eq!(proof, expected_proof); + Ok(()) + } + Err(_) => Ok(()), } - (Err(_), Ok(_), None) => Ok(()), - (Ok(_), Err(_), None) => Ok(()), - (Err(_), Err(_), None) => Ok(()), - _ => unreachable!("not possible"), + } else { + let result = compute_blob_kzg_proof(&blob, &commitment, kzg_settings); + assert!(result.is_err()); + Ok(()) } } @@ -221,7 +233,6 @@ fn run_verify_blob_kzg_proof_test( kzg_settings: &KzgSettings, ) -> Result<(), Error> { let path = &test.data_path; - // Load test case ---- let path = path.to_string() + "/data.yaml"; let test_data: serde_yaml::Value = load_yaml(&path); let input_yaml = test_data.get("input").unwrap(); @@ -233,7 +244,6 @@ fn run_verify_blob_kzg_proof_test( let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); let output = output_result.unwrap(); - // Check the deserialization of each input. Checks for validity. let blob: Blob = match serde_yaml::from_value(blob_yaml.clone()) { Ok(blob) => blob, Err(_) => { @@ -259,10 +269,7 @@ fn run_verify_blob_kzg_proof_test( }; let result = verify_blob_kzg_proof(&blob, &commitment, &proof, kzg_settings); - // Then check for incorrect proofs with if else statements on expected_validity. if let Some(expected_validity) = output { - // some `output` was present, use inner value to determine if the spec code should succeed - // or fail if expected_validity { assert!(result.is_ok()); Ok(()) @@ -271,7 +278,6 @@ fn run_verify_blob_kzg_proof_test( Ok(()) } } else { - // `output` is `null`, implying the spec code should always fail let result = verify_blob_kzg_proof(&blob, &commitment, &proof, kzg_settings); assert!(result.is_err()); Ok(()) From 490a7902dbe67baf85aaa55e260aef5479cd0bba Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Thu, 11 Apr 2024 10:27:56 -0600 Subject: [PATCH 20/27] Create "verify_blob_kzg_proof_batch" handler. All kzg tests pass! --- .../src/deneb/polynomial_commitments.rs | 2 +- spec-tests/runners/kzg.rs | 63 ++++++++++++++++--- 2 files changed, 56 insertions(+), 9 deletions(-) diff --git a/ethereum-consensus/src/deneb/polynomial_commitments.rs b/ethereum-consensus/src/deneb/polynomial_commitments.rs index a977345d9..192035dab 100644 --- a/ethereum-consensus/src/deneb/polynomial_commitments.rs +++ b/ethereum-consensus/src/deneb/polynomial_commitments.rs @@ -54,7 +54,7 @@ pub enum Error { InvalidProof, } -#[derive(Debug, PartialEq)] +#[derive(Debug, Eq, PartialEq)] pub struct ProofAndEvaluation { pub proof: KzgProof, pub evaluation: FieldElement, diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 8e45c7498..e3bc5fca1 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -6,13 +6,15 @@ use ethereum_consensus::deneb::{ mainnet::Blob, polynomial_commitments::{ blob_to_kzg_commitment, compute_blob_kzg_proof, compute_kzg_proof, kzg_settings_from_json, - verify_blob_kzg_proof, verify_kzg_proof, FieldElement, KzgCommitment, KzgProof, - KzgSettings, ProofAndEvaluation, + verify_blob_kzg_proof, verify_blob_kzg_proof_batch, verify_kzg_proof, FieldElement, + KzgCommitment, KzgProof, KzgSettings, ProofAndEvaluation, }, presets::TRUSTED_SETUP_JSON, }; pub fn dispatch(test: &TestCase) -> Result<(), Error> { + // TODO: Figure out why all tests fail when importing kzg settings via .context() + // let kzg_settings = &test.context().kzg_settings; let kzg_settings = kzg_settings_from_json(TRUSTED_SETUP_JSON)?; match test.meta.handler.0.as_str() { @@ -169,15 +171,15 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res if let Some(expected_validity) = output { if expected_validity { assert!(result.is_ok()); - Ok(()) + return Ok(()); } else { assert!(result.is_err()); - Ok(()) + return Ok(()); } } else { let result = verify_kzg_proof(&commitment, &z, &y, &proof, kzg_settings); assert!(result.is_err()); - Ok(()) + return Ok(()); } } @@ -286,9 +288,54 @@ fn run_verify_blob_kzg_proof_test( fn run_verify_blob_kzg_proof_batch_test( test: &TestCase, - _kzg_settings: &KzgSettings, + kzg_settings: &KzgSettings, ) -> Result<(), Error> { - let _path = &test.data_path; + let path = &test.data_path; + let path = path.to_string() + "/data.yaml"; + let test_data: serde_yaml::Value = load_yaml(&path); + let input_yaml = test_data.get("input").unwrap(); + let blobs_yaml = input_yaml.get("blobs").unwrap(); + let commitments_yaml = input_yaml.get("commitments").unwrap(); + let proofs_yaml = input_yaml.get("proofs").unwrap(); + let output_yaml = test_data.get("output").unwrap(); - todo!() + let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); + let output = output_result.unwrap(); + + let blobs: Vec = match serde_yaml::from_value(blobs_yaml.clone()) { + Ok(blobs) => blobs, + Err(_) => { + assert!(output.is_none()); + return Ok(()); + } + }; + let commitments: Vec = match serde_yaml::from_value(commitments_yaml.clone()) { + Ok(commitments) => commitments, + Err(_) => { + assert!(output.is_none()); + return Ok(()); + } + }; + let proofs: Vec = match serde_yaml::from_value(proofs_yaml.clone()) { + Ok(commitments) => commitments, + Err(_) => { + assert!(output.is_none()); + return Ok(()); + } + }; + + let result = verify_blob_kzg_proof_batch(&blobs, &commitments, &proofs, kzg_settings); + if let Some(expected_validity) = output { + if expected_validity { + assert!(result.is_ok()); + return Ok(()); + } else { + assert!(result.is_err()); + return Ok(()); + } + } else { + let result = verify_blob_kzg_proof_batch(&blobs, &commitments, &proofs, kzg_settings); + assert!(result.is_err()); + return Ok(()); + } } From 9983d2ef3ccc6ea3e470623b5b2e2c84f4c40b89 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Thu, 11 Apr 2024 10:30:29 -0600 Subject: [PATCH 21/27] Remove unnecessary `return` statements --- spec-tests/runners/kzg.rs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index e3bc5fca1..52f9b3113 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -110,7 +110,7 @@ fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Re evaluation: expected_proof_and_evaluation.1, }; assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); - return Ok(()); + Ok(()) } Err(_) => Ok(()), } @@ -171,15 +171,15 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res if let Some(expected_validity) = output { if expected_validity { assert!(result.is_ok()); - return Ok(()); + Ok(()) } else { assert!(result.is_err()); - return Ok(()); + Ok(()) } } else { let result = verify_kzg_proof(&commitment, &z, &y, &proof, kzg_settings); assert!(result.is_err()); - return Ok(()); + Ok(()) } } @@ -328,14 +328,14 @@ fn run_verify_blob_kzg_proof_batch_test( if let Some(expected_validity) = output { if expected_validity { assert!(result.is_ok()); - return Ok(()); + Ok(()) } else { assert!(result.is_err()); - return Ok(()); + Ok(()) } } else { let result = verify_blob_kzg_proof_batch(&blobs, &commitments, &proofs, kzg_settings); assert!(result.is_err()); - return Ok(()); + Ok(()) } } From b69723c607e059a55efc742b2af18bf39dd124e4 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Thu, 11 Apr 2024 13:51:56 -0600 Subject: [PATCH 22/27] Iterates on feedback from Alex --- .../src/deneb/polynomial_commitments.rs | 2 +- spec-tests/runners/kzg.rs | 31 ++++++------------- 2 files changed, 10 insertions(+), 23 deletions(-) diff --git a/ethereum-consensus/src/deneb/polynomial_commitments.rs b/ethereum-consensus/src/deneb/polynomial_commitments.rs index 192035dab..de79137d2 100644 --- a/ethereum-consensus/src/deneb/polynomial_commitments.rs +++ b/ethereum-consensus/src/deneb/polynomial_commitments.rs @@ -54,7 +54,7 @@ pub enum Error { InvalidProof, } -#[derive(Debug, Eq, PartialEq)] +#[derive(Debug, PartialEq, Eq)] pub struct ProofAndEvaluation { pub proof: KzgProof, pub evaluation: FieldElement, diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 52f9b3113..086955f8c 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -39,10 +39,7 @@ fn run_blob_to_kzg_commitment_test( let input_yaml = test_data.get("input").unwrap(); let blob_yaml = input_yaml.get("blob").unwrap(); let output_yaml = test_data.get("output").unwrap(); - - let output_result: Result, _> = - serde_yaml::from_value(output_yaml.clone()); - let output = output_result.unwrap(); + let output: Option = serde_yaml::from_value(output_yaml.clone()).unwrap(); // Check the deserialization of input(s) let blob: Blob = match serde_yaml::from_value(blob_yaml.clone()) { @@ -80,10 +77,8 @@ fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Re let blob_yaml = input_yaml.get("blob").unwrap(); let z_yaml = input_yaml.get("z").unwrap(); let output_yaml = test_data.get("output").unwrap(); - - let output_result: Result, _> = - serde_yaml::from_value(output_yaml.clone()); - let output = output_result.unwrap(); + let output: Option<(KzgProof, FieldElement)> = + serde_yaml::from_value(output_yaml.clone()).unwrap(); let blob: Blob = match serde_yaml::from_value(blob_yaml.clone()) { Ok(blob) => blob, @@ -130,10 +125,8 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res let z_yaml = input_yaml.get("z").unwrap(); let y_yaml = input_yaml.get("y").unwrap(); let proof_yaml = input_yaml.get("proof").unwrap(); - let output_yaml = test_data.get("output").unwrap(); - let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); - let output = output_result.unwrap(); + let output: Option = serde_yaml::from_value(output_yaml.clone()).unwrap(); let commitment = match serde_yaml::from_value(commitment_yaml.clone()) { Ok(commitment) => commitment, @@ -194,9 +187,7 @@ fn run_compute_blob_kzg_proof_test( let blob_yaml = input_yaml.get("blob").unwrap(); let commitment_yaml = input_yaml.get("commitment").unwrap(); let output_yaml = test_data.get("output").unwrap(); - - let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); - let output = output_result.unwrap(); + let output: Option = serde_yaml::from_value(output_yaml.clone()).unwrap(); let blob: Blob = match serde_yaml::from_value(blob_yaml.clone()) { Ok(blob) => blob, @@ -241,10 +232,8 @@ fn run_verify_blob_kzg_proof_test( let blob_yaml = input_yaml.get("blob").unwrap(); let commitment_yaml = input_yaml.get("commitment").unwrap(); let proof_yaml = input_yaml.get("proof").unwrap(); - let output_yaml = test_data.get("output").unwrap(); - let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); - let output = output_result.unwrap(); + let output: Option = serde_yaml::from_value(output_yaml.clone()).unwrap(); let blob: Blob = match serde_yaml::from_value(blob_yaml.clone()) { Ok(blob) => blob, @@ -298,9 +287,7 @@ fn run_verify_blob_kzg_proof_batch_test( let commitments_yaml = input_yaml.get("commitments").unwrap(); let proofs_yaml = input_yaml.get("proofs").unwrap(); let output_yaml = test_data.get("output").unwrap(); - - let output_result: Result, _> = serde_yaml::from_value(output_yaml.clone()); - let output = output_result.unwrap(); + let output: Option = serde_yaml::from_value(output_yaml.clone()).unwrap(); let blobs: Vec = match serde_yaml::from_value(blobs_yaml.clone()) { Ok(blobs) => blobs, @@ -316,8 +303,8 @@ fn run_verify_blob_kzg_proof_batch_test( return Ok(()); } }; - let proofs: Vec = match serde_yaml::from_value(proofs_yaml.clone()) { - Ok(commitments) => commitments, + let proofs: Vec = match serde_yaml::from_value(proofs_yaml.clone()) { + Ok(proofs) => proofs, Err(_) => { assert!(output.is_none()); return Ok(()); From dc36dab08e71ec1d07a3837b0d975fa08d93e940 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Mon, 15 Apr 2024 12:00:05 -0600 Subject: [PATCH 23/27] Accesses `KZGSettings` via `.context()` within test runner --- spec-tests/main.rs | 4 ++-- spec-tests/runners/kzg.rs | 11 ++++------- spec-tests/test_case.rs | 2 +- 3 files changed, 7 insertions(+), 10 deletions(-) diff --git a/spec-tests/main.rs b/spec-tests/main.rs index e7071901a..151608401 100644 --- a/spec-tests/main.rs +++ b/spec-tests/main.rs @@ -69,7 +69,7 @@ fn visit_dir( } else { if entries.is_empty() { // some spurious test dirs exist - return Ok(()) + return Ok(()); } let test_case_paths = entries .iter() @@ -87,7 +87,7 @@ fn visit_dir( let test_case = parse_test_case(&test_case_paths, path_mask, context.clone()); if test_case.meta.should_skip() { - return Ok(()) + return Ok(()); } let name = test_case.name(); let should_ignore = test_case.meta.should_ignore(); diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 086955f8c..7696df1cc 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -5,17 +5,14 @@ use crate::{ use ethereum_consensus::deneb::{ mainnet::Blob, polynomial_commitments::{ - blob_to_kzg_commitment, compute_blob_kzg_proof, compute_kzg_proof, kzg_settings_from_json, - verify_blob_kzg_proof, verify_blob_kzg_proof_batch, verify_kzg_proof, FieldElement, - KzgCommitment, KzgProof, KzgSettings, ProofAndEvaluation, + blob_to_kzg_commitment, compute_blob_kzg_proof, compute_kzg_proof, verify_blob_kzg_proof, + verify_blob_kzg_proof_batch, verify_kzg_proof, FieldElement, KzgCommitment, KzgProof, + KzgSettings, ProofAndEvaluation, }, - presets::TRUSTED_SETUP_JSON, }; pub fn dispatch(test: &TestCase) -> Result<(), Error> { - // TODO: Figure out why all tests fail when importing kzg settings via .context() - // let kzg_settings = &test.context().kzg_settings; - let kzg_settings = kzg_settings_from_json(TRUSTED_SETUP_JSON)?; + let kzg_settings = &test.context().kzg_settings; match test.meta.handler.0.as_str() { "blob_to_kzg_commitment" => run_blob_to_kzg_commitment_test(test, &kzg_settings), diff --git a/spec-tests/test_case.rs b/spec-tests/test_case.rs index 350c9415c..03579e8d6 100644 --- a/spec-tests/test_case.rs +++ b/spec-tests/test_case.rs @@ -29,7 +29,7 @@ impl TestCase { match self.meta.config { Config::Mainnet => &self.context.mainnet, Config::Minimal => &self.context.minimal, - _ => unreachable!(), + Config::General => &self.context.mainnet, } } From 9c911cd01c344045929bff0d3903d95ea8eb8e82 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Mon, 15 Apr 2024 12:12:42 -0600 Subject: [PATCH 24/27] Fixes Clippy warnings --- spec-tests/runners/kzg.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 7696df1cc..0d354f946 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -15,12 +15,12 @@ pub fn dispatch(test: &TestCase) -> Result<(), Error> { let kzg_settings = &test.context().kzg_settings; match test.meta.handler.0.as_str() { - "blob_to_kzg_commitment" => run_blob_to_kzg_commitment_test(test, &kzg_settings), - "compute_kzg_proof" => run_compute_kzg_proof_test(test, &kzg_settings), - "verify_kzg_proof" => run_verify_kzg_proof_test(test, &kzg_settings), - "compute_blob_kzg_proof" => run_compute_blob_kzg_proof_test(test, &kzg_settings), - "verify_blob_kzg_proof" => run_verify_blob_kzg_proof_test(test, &kzg_settings), - "verify_blob_kzg_proof_batch" => run_verify_blob_kzg_proof_batch_test(test, &kzg_settings), + "blob_to_kzg_commitment" => run_blob_to_kzg_commitment_test(test, kzg_settings), + "compute_kzg_proof" => run_compute_kzg_proof_test(test, kzg_settings), + "verify_kzg_proof" => run_verify_kzg_proof_test(test, kzg_settings), + "compute_blob_kzg_proof" => run_compute_blob_kzg_proof_test(test, kzg_settings), + "verify_blob_kzg_proof" => run_verify_blob_kzg_proof_test(test, kzg_settings), + "verify_blob_kzg_proof_batch" => run_verify_blob_kzg_proof_batch_test(test, kzg_settings), handler => unreachable!("no tests for {handler}"), } } From 12bd77905de541bcb00bc40b6828261a3ff97939 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Tue, 16 Apr 2024 12:02:16 -0600 Subject: [PATCH 25/27] Remove semicolons after `return` from main.rs --- spec-tests/main.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/spec-tests/main.rs b/spec-tests/main.rs index 151608401..e7071901a 100644 --- a/spec-tests/main.rs +++ b/spec-tests/main.rs @@ -69,7 +69,7 @@ fn visit_dir( } else { if entries.is_empty() { // some spurious test dirs exist - return Ok(()); + return Ok(()) } let test_case_paths = entries .iter() @@ -87,7 +87,7 @@ fn visit_dir( let test_case = parse_test_case(&test_case_paths, path_mask, context.clone()); if test_case.meta.should_skip() { - return Ok(()); + return Ok(()) } let name = test_case.name(); let should_ignore = test_case.meta.should_ignore(); From 8c6c80348386a22cdf126d2a27a1b9ac95f02538 Mon Sep 17 00:00:00 2001 From: EchoAlice Date: Tue, 16 Apr 2024 13:00:01 -0600 Subject: [PATCH 26/27] Changes `if let Some` logic for handlers --- spec-tests/runners/kzg.rs | 38 ++++++++++++-------------------------- 1 file changed, 12 insertions(+), 26 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 0d354f946..7b2b3ae24 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -51,13 +51,9 @@ fn run_blob_to_kzg_commitment_test( if let Some(expected_commitment) = output { // some `output` was present, use inner value to determine if the spec code should succeed // or fail - match result { - Ok(commitment) => { - assert_eq!(commitment, expected_commitment); - Ok(()) - } - Err(_) => Ok(()), - } + let commitment = result.unwrap(); + assert_eq!(commitment, expected_commitment); + Ok(()) } else { // `output` is `null`, implying the spec code should always fail let result = blob_to_kzg_commitment(&blob, kzg_settings); @@ -94,18 +90,12 @@ fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Re }; let result = compute_kzg_proof(&blob, &z, kzg_settings); - if let Some(expected_proof_and_evaluation) = output { - match result { - Ok(proof_and_evaluation) => { - let expected_proof_and_evaluation = ProofAndEvaluation { - proof: expected_proof_and_evaluation.0, - evaluation: expected_proof_and_evaluation.1, - }; - assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); - Ok(()) - } - Err(_) => Ok(()), - } + if let Some(outputs) = output { + let proof_and_evaluation = result.unwrap(); + let expected_proof_and_evaluation = + ProofAndEvaluation { proof: outputs.0, evaluation: outputs.1 }; + assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); + Ok(()) } else { let result = compute_kzg_proof(&blob, &z, kzg_settings); assert!(result.is_err()); @@ -204,13 +194,9 @@ fn run_compute_blob_kzg_proof_test( let result = compute_blob_kzg_proof(&blob, &commitment, kzg_settings); if let Some(expected_proof) = output { - match result { - Ok(proof) => { - assert_eq!(proof, expected_proof); - Ok(()) - } - Err(_) => Ok(()), - } + let proof = result.unwrap(); + assert_eq!(proof, expected_proof); + Ok(()) } else { let result = compute_blob_kzg_proof(&blob, &commitment, kzg_settings); assert!(result.is_err()); From cffaeb8acf57d22dbbb7d789c42ac70a74a44e10 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Tue, 16 Apr 2024 13:35:34 -0600 Subject: [PATCH 27/27] Apply suggestions from code review Remove duplicate evaluations --- spec-tests/runners/kzg.rs | 6 ------ 1 file changed, 6 deletions(-) diff --git a/spec-tests/runners/kzg.rs b/spec-tests/runners/kzg.rs index 7b2b3ae24..67836f393 100644 --- a/spec-tests/runners/kzg.rs +++ b/spec-tests/runners/kzg.rs @@ -56,7 +56,6 @@ fn run_blob_to_kzg_commitment_test( Ok(()) } else { // `output` is `null`, implying the spec code should always fail - let result = blob_to_kzg_commitment(&blob, kzg_settings); assert!(result.is_err()); Ok(()) } @@ -97,7 +96,6 @@ fn run_compute_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Re assert_eq!(proof_and_evaluation, expected_proof_and_evaluation); Ok(()) } else { - let result = compute_kzg_proof(&blob, &z, kzg_settings); assert!(result.is_err()); Ok(()) } @@ -157,7 +155,6 @@ fn run_verify_kzg_proof_test(test: &TestCase, kzg_settings: &KzgSettings) -> Res Ok(()) } } else { - let result = verify_kzg_proof(&commitment, &z, &y, &proof, kzg_settings); assert!(result.is_err()); Ok(()) } @@ -198,7 +195,6 @@ fn run_compute_blob_kzg_proof_test( assert_eq!(proof, expected_proof); Ok(()) } else { - let result = compute_blob_kzg_proof(&blob, &commitment, kzg_settings); assert!(result.is_err()); Ok(()) } @@ -252,7 +248,6 @@ fn run_verify_blob_kzg_proof_test( Ok(()) } } else { - let result = verify_blob_kzg_proof(&blob, &commitment, &proof, kzg_settings); assert!(result.is_err()); Ok(()) } @@ -304,7 +299,6 @@ fn run_verify_blob_kzg_proof_batch_test( Ok(()) } } else { - let result = verify_blob_kzg_proof_batch(&blobs, &commitments, &proofs, kzg_settings); assert!(result.is_err()); Ok(()) }