chore: remove fixed test vector from consensus_specs

Author: kevaundray

eip7594/benches/benchmark.rs

@@ -1,5 +1,5 @@
+use bls12_381::Scalar;
 use criterion::{criterion_group, criterion_main, Criterion};
-use eip7594::consensus_specs_fixed_test_vector::eth_polynomial;
 use kzg_multi_open::{
     create_eth_commit_opening_keys, fk20::naive, polynomial::domain::Domain, reverse_bit_order,
 };
@@ -8,7 +8,9 @@ use kzg_multi_open::{
 pub fn bench_compute_proof_with_naive_fk20(c: &mut Criterion) {
     const POLYNOMIAL_LEN: usize = 4096;
 
-    let mut polynomial_4096 = eth_polynomial();
+    let mut polynomial_4096: Vec<_> = (0..POLYNOMIAL_LEN)
+        .map(|i| -Scalar::from(i as u64))
+        .collect();
     reverse_bit_order(&mut polynomial_4096);
     let domain = Domain::new(POLYNOMIAL_LEN);
     let polynomial_4096 = domain.ifft_scalars(polynomial_4096);

eip7594/src/consensus_specs_fixed_test_vector.rs

@@ -2,9 +2,6 @@ use constants::{BYTES_PER_BLOB, BYTES_PER_CELL, BYTES_PER_COMMITMENT};
 use prover::ProverContext;
 use verifier::VerifierContext;
 
-// TODO: We can remove this once we hook up the consensus-specs fixed test vectors.
-pub mod consensus_specs_fixed_test_vector;
-
 pub mod constants;
 pub mod prover;
 mod serialization;
@@ -51,14 +48,13 @@ impl PeerDASContext {
 
 #[cfg(test)]
 mod tests {
+    use bls12_381::Scalar;
     use kzg_multi_open::polynomial::domain::Domain;
     use kzg_multi_open::{
         create_eth_commit_opening_keys, fk20::naive, proof::compute_multi_opening_naive,
         reverse_bit_order,
     };
 
-    use crate::consensus_specs_fixed_test_vector::eth_polynomial;
-
     // This test becomes redundant once we have consensus-specs fixed test vectors
     // added. Although, it may be beneficial to test consensus-specs fixed test vectors against
     // the naive implementation, if it doesn't add too much overhead.
@@ -81,7 +77,9 @@ mod tests {
 
         const NUMBER_OF_PROOFS: usize = NUMBER_OF_POINTS_TO_EVALUATE / NUMBER_OF_POINTS_PER_PROOF;
         let proof_domain = Domain::new(NUMBER_OF_PROOFS);
-        let mut polynomial = eth_polynomial();
+        let mut polynomial: Vec<_> = (0..POLYNOMIAL_LEN)
+            .map(|i| -Scalar::from(i as u64))
+            .collect();
         // Polynomial really corresponds to the evaluation form, so we need
         // to apply bit reverse order and then IFFT to get the coefficients
         reverse_bit_order(&mut polynomial);

eip7594/src/lib.rs

@@ -188,51 +188,3 @@ pub(crate) fn evaluation_sets_to_cells<T: AsRef<[Scalar]>>(
         .try_into()
         .unwrap_or_else(|_| panic!("expected {} number of cells", CELLS_PER_EXT_BLOB))
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        consensus_specs_fixed_test_vector::{eth_commitment, BLOB_STR, CELLS_STR, PROOFS_STR},
-        prover::ProverContext,
-    };
-
-    #[test]
-    fn test_polynomial_commitment_matches() {
-        let ctx = ProverContext::new();
-
-        let blob_bytes = hex::decode(BLOB_STR).unwrap();
-
-        let got_commitment = ctx
-            .blob_to_kzg_commitment(&blob_bytes.try_into().unwrap())
-            .unwrap();
-        let expected_commitment = eth_commitment().to_compressed();
-
-        assert_eq!(got_commitment, expected_commitment);
-    }
-
-    #[test]
-    fn test_computing_proofs() {
-        // Setup
-        let ctx = ProverContext::new();
-
-        let blob_bytes = hex::decode(BLOB_STR).unwrap();
-
-        let (got_cells, got_proofs) = ctx
-            .compute_cells_and_kzg_proofs(&blob_bytes.try_into().unwrap())
-            .unwrap();
-
-        let expected_proofs = PROOFS_STR;
-        let expected_cells = CELLS_STR;
-
-        for k in 0..expected_proofs.len() {
-            let expected_proof_str = expected_proofs[k];
-            let expected_cell_str = expected_cells[k];
-
-            let got_proof_str = hex::encode(&got_proofs[k]);
-            let got_cells_str = hex::encode(&*got_cells[k]);
-
-            assert_eq!(got_cells_str, expected_cell_str);
-            assert_eq!(got_proof_str, expected_proof_str);
-        }
-    }
-}

eip7594/src/prover.rs

@@ -307,13 +307,7 @@ fn sanity_check_cells_and_cell_ids(
 #[cfg(test)]
 mod tests {
 
-    use std::ops::Range;
-
-    use crate::{
-        consensus_specs_fixed_test_vector::{CELLS_STR, COMMITMENT_STR, PROOFS_STR},
-        constants::CELLS_PER_EXT_BLOB,
-        verifier::{is_cell_ids_unique, VerifierContext},
-    };
+    use crate::verifier::is_cell_ids_unique;
 
     #[test]
     fn test_cell_ids_unique() {
@@ -326,95 +320,4 @@ mod tests {
         let cell_ids = vec![0, 0, 0];
         assert!(!is_cell_ids_unique(&cell_ids));
     }
-
-    #[test]
-    fn test_proofs_verify() {
-        // Setup
-        let ctx = VerifierContext::new();
-
-        let commitment_str = COMMITMENT_STR;
-        let commitment_bytes: [u8; 48] = hex::decode(commitment_str).unwrap().try_into().unwrap();
-
-        let proofs_str = PROOFS_STR;
-        let proofs_bytes: Vec<[u8; 48]> = proofs_str
-            .iter()
-            .map(|proof_str| hex::decode(proof_str).unwrap().try_into().unwrap())
-            .collect();
-
-        let cells_str = CELLS_STR;
-        let cells_bytes: Vec<Vec<u8>> = cells_str
-            .into_iter()
-            .map(|cell_str| hex::decode(cell_str).unwrap())
-            .collect();
-
-        for k in 0..proofs_bytes.len() {
-            let proof_bytes = proofs_bytes[k];
-            let cell_bytes = cells_bytes[k].clone().try_into().unwrap();
-            let cell_id = k as u64;
-
-            assert!(ctx
-                .verify_cell_kzg_proof(&commitment_bytes, cell_id, &cell_bytes, &proof_bytes)
-                .is_ok());
-        }
-
-        assert!(ctx
-            .verify_cell_kzg_proof_batch(
-                vec![&commitment_bytes; proofs_bytes.len()],
-                vec![0; proofs_bytes.len()],
-                (0..proofs_bytes.len()).map(|x| x as u64).collect(),
-                cells_bytes
-                    .iter()
-                    .map(Vec::as_slice)
-                    .map(|cell| cell.try_into().unwrap())
-                    .collect(),
-                proofs_bytes
-                    .iter()
-                    .map(|proof| proof.try_into().unwrap())
-                    .collect(),
-            )
-            .is_ok());
-    }
-
-    #[test]
-    fn test_recover_all_cells() {
-        let ctx = VerifierContext::new();
-        let num_cells_to_keep = CELLS_PER_EXT_BLOB / 2;
-
-        fn generate_unique_random_numbers(range: Range<u64>, n: usize) -> Vec<u64> {
-            use rand::prelude::SliceRandom;
-            let mut numbers: Vec<_> = range.into_iter().collect();
-            numbers.shuffle(&mut rand::thread_rng());
-            numbers.into_iter().take(n).collect()
-        }
-
-        let cell_ids_to_keep = generate_unique_random_numbers(0..128, num_cells_to_keep);
-        let cells_as_hex_strings: Vec<_> = cell_ids_to_keep
-            .iter()
-            .map(|cell_id| CELLS_STR[*cell_id as usize])
-            .collect();
-        let cells_to_keep: Vec<_> = cells_as_hex_strings
-            .into_iter()
-            .map(|cell_str| hex::decode(cell_str).unwrap())
-            .collect();
-
-        let all_cells: Vec<_> = CELLS_STR
-            .into_iter()
-            .map(|cell_str| hex::decode(cell_str).unwrap())
-            .collect();
-
-        let recovered_cells = ctx
-            .recover_all_cells(
-                cell_ids_to_keep,
-                cells_to_keep
-                    .iter()
-                    .map(Vec::as_slice)
-                    .map(|v| v.try_into().unwrap())
-                    .collect(),
-            )
-            .unwrap();
-
-        for (recovered_cell, expected_cell) in recovered_cells.into_iter().zip(all_cells) {
-            assert_eq!(&recovered_cell[..], &expected_cell[..])
-        }
-    }
 }