From c6227c196035b0896b1fc41a0b3fd83f44e83e88 Mon Sep 17 00:00:00 2001 From: Alex Kuzmin <6849426+alxkzmn@users.noreply.github.com> Date: Thu, 14 Dec 2023 16:34:12 +0800 Subject: [PATCH] Create KZG multi-openings & verify user ID at the specified index (#224) * Create KZG multi-openings * Verify the inclusion of user ID into the first column polynomial under the same index * Improve code documentation as per PR review * Fix comment * Code review fixes --- kzg_prover/src/circuits/tests.rs | 157 +++++++-- kzg_prover/src/circuits/utils.rs | 330 +++++++++++------- kzg_prover/src/csv/entry_16.csv | 17 - kzg_prover/src/csv/entry_16_bigints.csv | 17 - kzg_prover/src/csv/entry_16_modified.csv | 17 - kzg_prover/src/csv/entry_16_no_overflow.csv | 17 - kzg_prover/src/csv/entry_16_overflow.csv | 17 - kzg_prover/src/csv/entry_16_overflow_2.csv | 17 - .../src/csv/entry_16_switched_order.csv | 17 - 9 files changed, 334 insertions(+), 272 deletions(-) delete mode 100644 kzg_prover/src/csv/entry_16.csv delete mode 100644 kzg_prover/src/csv/entry_16_bigints.csv delete mode 100644 kzg_prover/src/csv/entry_16_modified.csv delete mode 100644 kzg_prover/src/csv/entry_16_no_overflow.csv delete mode 100644 kzg_prover/src/csv/entry_16_overflow.csv delete mode 100644 kzg_prover/src/csv/entry_16_overflow_2.csv delete mode 100644 kzg_prover/src/csv/entry_16_switched_order.csv diff --git a/kzg_prover/src/circuits/tests.rs b/kzg_prover/src/circuits/tests.rs index 40fd6186..e39f0370 100644 --- a/kzg_prover/src/circuits/tests.rs +++ b/kzg_prover/src/circuits/tests.rs @@ -3,7 +3,7 @@ mod test { use crate::circuits::univariate_grand_sum::UnivariateGrandSum; use crate::circuits::utils::{ - full_prover, full_verifier, generate_setup_artifacts, open_grand_sums, open_user_balances, + full_prover, full_verifier, generate_setup_artifacts, open_grand_sums, open_user_points, verify_grand_sum_openings, verify_user_inclusion, }; use crate::cryptocurrency::Cryptocurrency; @@ -20,8 +20,8 @@ mod test { const N_USERS: usize = 16; #[test] - fn test_valid_solvency_v2() { - let path = "src/csv/entry_16.csv"; + fn test_valid_univariate_grand_sum_prover() { + let path = "../csv/entry_16.csv"; let mut entries: Vec> = vec![Entry::init_empty(); N_USERS]; let mut cryptos = vec![Cryptocurrency::init_empty(); N_CURRENCIES]; @@ -36,7 +36,7 @@ mod test { } #[test] - fn test_valid_solvency_v2_full_prover() { + fn test_valid_univariate_grand_sum_full_prover() { const N_USERS: usize = 16; // Initialize an empty circuit @@ -51,13 +51,14 @@ mod test { let (params, pk, vk) = generate_setup_artifacts(K, None, circuit).unwrap(); // Only now we can instantiate the circuit with the actual inputs - let path = "src/csv/entry_16.csv"; + let path = "../csv/entry_16.csv"; let mut entries: Vec> = vec![Entry::init_empty(); N_USERS]; let mut cryptos = vec![Cryptocurrency::init_empty(); N_CURRENCIES]; - parse_csv_to_entries::<&str, N_CURRENCIES, N_BYTES>(path, &mut entries, &mut cryptos) - .unwrap(); + let _ = + parse_csv_to_entries::<&str, N_CURRENCIES, N_BYTES>(path, &mut entries, &mut cryptos) + .unwrap(); // Calculate total for all entry columns let mut csv_total: Vec = vec![BigUint::from(0u32); N_CURRENCIES]; @@ -75,31 +76,32 @@ mod test { valid_prover.assert_satisfied(); // 1. Proving phase - // The Custodian generates the ZK proof + // The Custodian generates the ZK-SNARK Halo2 proof that commits to the user entry values in advice polynomials + // and also range-checks the user balance values let (zk_snark_proof, advice_polys, omega) = full_prover(¶ms, &pk, circuit.clone(), vec![vec![]]); // Both the Custodian and the Verifier know what column range are the balance columns + // (The first column is the user IDs) let balance_column_range = 1..N_CURRENCIES + 1; - // The Custodian makes an opening at x = 0 for the Verifier - // (The first column is the user IDs) - let kzg_proofs = open_grand_sums::( + // The Custodian makes a batch opening proof of all user balance polynomials at x = 0 for the Verifier + let grand_sums_batch_proof = open_grand_sums::( &advice_polys.advice_polys, &advice_polys.advice_blinds, ¶ms, balance_column_range, ); - // The Custodian creates a KZG proof of the 4th user balances inclusion + // The Custodian creates a KZG batch proof of the 4th user ID & balances inclusion let user_index = 3_u16; - let balance_column_range = 1..N_CURRENCIES + 1; - let balance_opening_proofs = open_user_balances::( + let column_range = 0..N_CURRENCIES + 1; + let openings_batch_proof = open_user_points::( &advice_polys.advice_polys, &advice_polys.advice_blinds, ¶ms, - balance_column_range, + column_range, omega, user_index, ); @@ -117,41 +119,134 @@ mod test { // Both the Custodian and the Verifier know what column range are the balance columns let balance_column_range = 1..N_CURRENCIES + 1; - // The Custodian communicates the KZG opening transcripts to the Verifier - // The Verifier verifies the KZG opening transcripts and calculates the grand sums + // The Custodian communicates the KZG batch opening transcript to the Verifier + // The Verifier verifies the KZG batch opening and calculates the grand sums let (verified, grand_sum) = verify_grand_sum_openings::( ¶ms, &zk_snark_proof, - kzg_proofs, + grand_sums_batch_proof, poly_degree, balance_column_range, ); + assert!(verified); for i in 0..N_CURRENCIES { - assert!(verified[i]); assert_eq!(csv_total[i], grand_sum[i]); } - let balance_column_range = 1..N_CURRENCIES + 1; - let (balances_verified, balance_values) = verify_user_inclusion::( + let column_range = 0..N_CURRENCIES + 1; + // The Verifier verifies the inclusion of the 4th user entry + const N_POINTS: usize = N_CURRENCIES + 1; + let (inclusion_verified, id_and_balance_values) = verify_user_inclusion::( ¶ms, &zk_snark_proof, - balance_opening_proofs, - balance_column_range, + &openings_batch_proof, + column_range, omega, user_index, ); + assert!(inclusion_verified); let fourth_user_csv_entry = entries.get(user_index as usize).unwrap(); - for i in 0..N_CURRENCIES { - assert!(balances_verified[i]); - assert_eq!( - *fourth_user_csv_entry.balances().get(i).unwrap(), - balance_values[i] - ); + for i in 0..N_CURRENCIES + 1 { + if i == 0 { + assert_eq!( + *fourth_user_csv_entry.username_as_big_uint(), + id_and_balance_values[i] + ); + } else { + assert_eq!( + *fourth_user_csv_entry.balances().get(i - 1).unwrap(), + id_and_balance_values[i] + ); + } } } + #[test] + fn test_invalid_univariate_grand_sum_proof() { + const N_USERS: usize = 16; + + // Initialize an empty circuit + let circuit = UnivariateGrandSum::::init_empty(); + + // Generate a universal trusted setup for testing purposes. + // + // The verification key (vk) and the proving key (pk) are then generated. + // An empty circuit is used here to emphasize that the circuit inputs are not relevant when generating the keys. + // Important: The dimensions of the circuit used to generate the keys must match those of the circuit used to generate the proof. + // In this case, the dimensions are represented by the number fo users. + let (params, pk, vk) = generate_setup_artifacts(K, None, circuit).unwrap(); + + // Only now we can instantiate the circuit with the actual inputs + let path = "../csv/entry_16.csv"; + + let mut entries: Vec> = vec![Entry::init_empty(); N_USERS]; + let mut cryptos = vec![Cryptocurrency::init_empty(); N_CURRENCIES]; + + parse_csv_to_entries::<&str, N_CURRENCIES, N_BYTES>(path, &mut entries, &mut cryptos) + .unwrap(); + + // Calculate total for all entry columns + let mut csv_total: Vec = vec![BigUint::from(0u32); N_CURRENCIES]; + + for entry in &entries { + for (i, balance) in entry.balances().iter().enumerate() { + csv_total[i] += balance; + } + } + + let circuit = UnivariateGrandSum::::init(entries.to_vec()); + + let valid_prover = MockProver::run(K, &circuit, vec![vec![]]).unwrap(); + + valid_prover.assert_satisfied(); + + // 1. Proving phase + // The Custodian generates the ZK proof + let (zk_snark_proof, advice_polys, omega) = + full_prover(¶ms, &pk, circuit.clone(), vec![vec![]]); + + // The Custodian creates a KZG batch proof of the 4th user ID & balances inclusion + let user_index = 3_u16; + + let column_range = 0..N_CURRENCIES + 1; + let openings_batch_proof = open_user_points::( + &advice_polys.advice_polys, + &advice_polys.advice_blinds, + ¶ms, + column_range, + omega, + user_index, + ); + + // 2. Verification phase + // The Verifier verifies the ZK proof + assert!(full_verifier(¶ms, &vk, &zk_snark_proof, vec![vec![]])); + + // The Verifier is able to independently extract the omega from the verification key + let omega = pk.get_vk().get_domain().get_omega(); + + // Both the Custodian and the Verifier know what column range are the balance columns + let balance_column_range = 1..N_CURRENCIES + 1; + + // Test failure case with the wrong group generator + // Slightly modify the generator + let bad_omega = omega.sub(&Fp::one()); + let (balances_verified, _) = verify_user_inclusion::( + ¶ms, + &zk_snark_proof, + &openings_batch_proof, + balance_column_range, + bad_omega, + user_index, + ); + //The verification should fail + assert!(!balances_verified); + + // TODO add more negative tests + } + // Building a proof using as input a csv file with an entry that is not in range [0, 2^N_BYTES*8 - 1] should fail the range check constraint on the leaf balance #[test] fn test_balance_not_in_range() { @@ -197,10 +292,10 @@ mod test { #[cfg(feature = "dev-graph")] #[test] - fn print_solvency_v2_circuit() { + fn print_univariate_grand_sum_circuit() { use plotters::prelude::*; - let path = "src/csv/entry_16.csv"; + let path = "../csv/entry_16.csv"; let mut entries: Vec> = vec![Entry::init_empty(); N_USERS]; let mut cryptos = vec![Cryptocurrency::init_empty(); N_CURRENCIES]; diff --git a/kzg_prover/src/circuits/utils.rs b/kzg_prover/src/circuits/utils.rs index 7bd73670..32d77b2d 100644 --- a/kzg_prover/src/circuits/utils.rs +++ b/kzg_prover/src/circuits/utils.rs @@ -118,71 +118,110 @@ pub fn full_prover>( (proof, advice_polys, omega) } -/// Creates the univariate polynomial grand sum openings -/// The challenge is set to zero to obtain the constant term of the polynomials +/// Creates the univariate polynomial grand sum openings. +/// The polynomials are evaluated at X = 0 to obtain their constant term. +/// +/// * `N_CURRENCIES` - the number of cryptocurrency balances +/// +/// # Arguments +/// +/// * `advice_polys` - the advice polynomials +/// * `advice_blinds` - the advice polynomials blinds +/// * `params` - the KZG parameters +/// * `balance_column_range` - the range of the balance columns used to calculate the grand sums +/// +/// # Returns +/// +/// * `Vec` - the KZG batch proof containing the quotient polynomial commitments +/// and the evaluations of the polynomials at X = 0 pub fn open_grand_sums( - advice_poly: &[Polynomial], - advice_blind: &[Blind], + advice_polys: &[Polynomial], + advice_blinds: &[Blind], params: &ParamsKZG, balance_column_range: Range, -) -> Vec> { +) -> Vec { let challenge = Fp::zero(); - let mut challenge_opening_proofs = Vec::new(); - balance_column_range.for_each(|i| { - challenge_opening_proofs.push( - create_opening_proof_at_challenge::< - KZGCommitmentScheme, - ProverSHPLONK<'_, Bn256>, - Challenge255, - Blake2bWrite, G1Affine, Challenge255>, - >(params, advice_poly[i].clone(), advice_blind[i], challenge) - .to_vec(), - ) - }); - challenge_opening_proofs + create_opening_proof_at_challenge::< + KZGCommitmentScheme, + ProverSHPLONK<'_, Bn256>, + Challenge255, + Blake2bWrite, G1Affine, Challenge255>, + >( + params, + &advice_polys[balance_column_range], + advice_blinds, + challenge, + ) } -pub fn open_user_balances( - advice_poly: &[Polynomial], - advice_blind: &[Blind], +/// Creates a KZG batch proof for the `advice_polys` polynomial openings +/// at a point corresponding to the `user_index` +/// +/// * `N_CURRENCIES` - the number of cryptocurrency balances +/// +/// # Arguments +/// +/// * `advice_polys` - the advice polynomials +/// * `advice_blinds` - the advice polynomials blinds +/// * `params` - the KZG parameters +/// * `column_range` - the advice column range to be used for the proof +/// * `omega` - $\omega$, the generator of the $2^k$ order multiplicative subgroup used to interpolate the polynomials. +/// * `user_index` - the index of the user whose entry is being proven +/// +/// # Returns +/// +/// * `Vec` - the KZG batch proof containing the quotient polynomial commitments +/// and the evaluations of the polynomials at the point corresponding to the `user_index` +pub fn open_user_points( + advice_polys: &[Polynomial], + advice_blinds: &[Blind], params: &ParamsKZG, - balance_column_range: Range, + column_range: Range, omega: Fp, user_index: u16, -) -> Vec> { +) -> Vec { let omega_raised = omega.pow_vartime([user_index as u64]); - let mut balance_opening_proofs = Vec::new(); - balance_column_range.for_each(|i| { - balance_opening_proofs.push( - create_opening_proof_at_challenge::< - KZGCommitmentScheme, - ProverSHPLONK<'_, Bn256>, - Challenge255, - Blake2bWrite, G1Affine, Challenge255>, - >( - params, - advice_poly[i].clone(), - advice_blind[i], - omega_raised, - ) - .to_vec(), - ) - }); - balance_opening_proofs + create_opening_proof_at_challenge::< + KZGCommitmentScheme, + ProverSHPLONK<'_, Bn256>, + Challenge255, + Blake2bWrite, G1Affine, Challenge255>, + >( + params, + &advice_polys[column_range], + advice_blinds, + omega_raised, + ) } /// Verifies the univariate polynomial grand sum openings +/// and calculates the grand sums +/// +/// * `N_CURRENCIES` - the number of cryptocurrency balances +/// +/// # Arguments +/// +/// * `params` - the KZG parameters +/// * `zk_snark_proof` - the ZK-SNARK proof of the circuit whose advice columns contain the user balance polynomials +/// * `grand_sum_opening_batch_proof` - the KZG batch proof of the grand sum polynomials +/// * `polynomial_degree` - the degree of the polynomials +/// * `balance_column_range` - the range of the advice columns that represent user balances +/// +/// # Returns +/// +/// * `bool` - whether the grand sum openings are verified correctly +/// * `Vec` - the grand sums pub fn verify_grand_sum_openings( params: &ParamsKZG, zk_snark_proof: &[u8], - challenge_opening_proofs: Vec>, + grand_sum_opening_batch_proof: Vec, polynomial_degree: u64, balance_column_range: Range, -) -> (Vec, Vec) { +) -> (bool, Vec) { let mut transcript: Blake2bRead<&[u8], G1Affine, Challenge255> = Blake2bRead::<_, _, Challenge255<_>>::init(zk_snark_proof); - //Read the commitment points for all the advice polynomials from the proof transcript and put them into a vector + //Read the commitment points for all the advice polynomials from the proof transcript and put them into a vector let mut advice_commitments = Vec::new(); for i in 0..N_CURRENCIES + balance_column_range.start { let point = transcript.read_point().unwrap(); @@ -192,82 +231,105 @@ pub fn verify_grand_sum_openings( } } - let mut verification_results = Vec::::new(); - let mut constant_terms = Vec::::new(); - - for (i, advice_commitment) in advice_commitments.iter().enumerate() { - let (verified, constant_term) = verify_opening::< - KZGCommitmentScheme, - VerifierSHPLONK<'_, Bn256>, - Challenge255, - Blake2bRead<_, _, Challenge255<_>>, - AccumulatorStrategy<_>, - >( - params, - &challenge_opening_proofs[i], - Fp::zero(), - *advice_commitment, - ); - verification_results.push(verified); - - if verified { - constant_terms.push(fp_to_big_uint(constant_term * Fp::from(polynomial_degree))); - } else { - constant_terms.push(BigUint::from(0u8)); - } - } - (verification_results, constant_terms) + let (verified, constant_terms) = verify_opening::< + KZGCommitmentScheme, + VerifierSHPLONK<'_, Bn256>, + Challenge255, + Blake2bRead<_, _, Challenge255<_>>, + AccumulatorStrategy<_>, + N_CURRENCIES, + >( + params, + &grand_sum_opening_batch_proof, + Fp::zero(), + &advice_commitments, + ); + + ( + verified, + constant_terms + .iter() + .map(|eval| fp_to_big_uint(eval * Fp::from(polynomial_degree))) + .collect(), + ) } -pub fn verify_user_inclusion( +/// Verifies the KZG batch proof of the polynomial openings being the evaluations +/// of the advice polynomials at the point corresponding to the user index +/// +/// * `N_POINTS` - the size of the user entry being verified (e.g., 1 ID value + 4 balance values = 5) +/// +/// # Arguments +/// * `params` - the KZG parameters +/// * `zk_snark_proof` - the ZK-SNARK proof of the circuit whose advice columns contain the user entry polynomials +/// * `balance_opening_batch_proof` - the KZG batch proof of the user entry polynomials +/// * `column_range` - the range of the advice columns that represent user entry +/// * `omega` - $\omega$, the generator of the $2^k$ order multiplicative subgroup used to interpolate the polynomials. +/// * `user_index` - the index of the user whose entry is being proven +/// +/// # Returns +/// * `bool` - whether the user entry openings are verified correctly +/// * `Vec` - the evaluations of the advice polynomials at the point corresponding to the user index +pub fn verify_user_inclusion( params: &ParamsKZG, zk_snark_proof: &[u8], - balance_opening_proofs: Vec>, - balance_column_range: Range, + balance_opening_batch_proof: &[u8], + column_range: Range, omega: Fp, user_index: u16, -) -> (Vec, Vec) { +) -> (bool, Vec) { let mut transcript: Blake2bRead<&[u8], G1Affine, Challenge255> = Blake2bRead::<_, _, Challenge255<_>>::init(zk_snark_proof); //Read the commitment points for all the advice polynomials from the proof transcript and put them into a vector let mut advice_commitments = Vec::new(); - for i in 0..N_CURRENCIES + balance_column_range.start { + for i in 0..column_range.end { let point = transcript.read_point().unwrap(); - // Skip the balances column commitment - if i != 0 { + //Skip advice polynomial commitments before the desired range + if i >= column_range.start { advice_commitments.push(point); } } let mut verification_results = Vec::::new(); - let mut balances = Vec::::new(); - - for (i, advice_commitment) in advice_commitments.iter().enumerate() { - let (verified, eval_at_challenge) = verify_opening::< - KZGCommitmentScheme, - VerifierSHPLONK<'_, Bn256>, - Challenge255, - Blake2bRead<_, _, Challenge255<_>>, - AccumulatorStrategy<_>, - >( - params, - &balance_opening_proofs[i], - omega.pow_vartime([user_index as u64]), - *advice_commitment, - ); - verification_results.push(verified); - - if verified { - balances.push(fp_to_big_uint(eval_at_challenge)); - } else { - balances.push(BigUint::from(0u8)); - } - } - (verification_results, balances) + + let (verified, evaluations_at_challenge) = verify_opening::< + KZGCommitmentScheme, + VerifierSHPLONK<'_, Bn256>, + Challenge255, + Blake2bRead<_, _, Challenge255<_>>, + AccumulatorStrategy<_>, + N_POINTS, + >( + params, + balance_opening_batch_proof, + omega.pow_vartime([user_index as u64]), + &advice_commitments, + ); + verification_results.push(verified); + + ( + verified, + evaluations_at_challenge + .iter() + .map(|eval| fp_to_big_uint(*eval)) + .collect(), + ) } -/// Creates a KZG proof for a polynomial evaluation at a challenge +/// Creates a KZG batch proof for the polynomial evaluations at a challenge +/// +/// # Arguments +/// +/// * `params` - the KZG parameters +/// * `polynomials` - the polynomials to be opened +/// * `blinds` - the polynomials blinds +/// * `challenge` - the challenge at which the polynomials are evaluated +/// +/// # Returns +/// +/// * `Vec` containing the quotient polynomial commitments +/// and the evaluations of the polynomials at the challenge fn create_opening_proof_at_challenge< 'params, Scheme: CommitmentScheme, @@ -276,8 +338,8 @@ fn create_opening_proof_at_challenge< T: TranscriptWriterBuffer, Scheme::Curve, E>, >( params: &'params Scheme::ParamsProver, - poly: Polynomial<::Scalar, Coeff>, - blind: Blind, + polynomials: &[Polynomial<::Scalar, Coeff>], + blinds: &[Blind], challenge: Fp, ) -> Vec where @@ -285,14 +347,23 @@ where { let mut transcript = T::init(vec![]); - // Evaluate polynomial at the challenge - let eval_at_challenge = eval_polynomial(&poly, challenge); + // Evaluate the polynomials at the challenge + let polynomial_evaluations = polynomials + .iter() + .map(|poly| eval_polynomial(poly, challenge)) + .collect::>(); - // Write evaluation to transcript - transcript.write_scalar(eval_at_challenge).unwrap(); + // Write evaluations to the transcript + polynomial_evaluations + .iter() + .for_each(|eval| transcript.write_scalar(*eval).unwrap()); - // Prepare prover query for the polynomial - let queries = [ProverQuery::new(challenge, &poly, blind)].to_vec(); + // Prepare prover queries for the polynomial + let queries = polynomials + .iter() + .enumerate() + .map(|(i, polynomial)| ProverQuery::new(challenge, polynomial, blinds[i])) + .collect::>(); // Create proof let prover = P::new(params); @@ -304,8 +375,22 @@ where transcript.finalize() } -/// Verifies a KZG proof for a polynomial evaluation at a challenge -pub fn verify_opening< +/// Verifies a KZG batch proof for a polynomial evaluation at a challenge +/// and returns the evaluations of the polynomials at the challenge +/// as well as the verification result +/// +/// # Arguments +/// +/// * `params` - the KZG parameters +/// * `proof` - the KZG batch proof +/// * `challenge` - the challenge at which the polynomials are evaluated +/// * `commitment_points` - the commitment points of the polynomials +/// +/// # Returns +/// +/// * `bool` - whether the proof is verified correctly +/// * `Vec` - the evaluations of the polynomials at the challenge +fn verify_opening< 'a, 'params, Scheme: CommitmentScheme, @@ -313,26 +398,27 @@ pub fn verify_opening< E: EncodedChallenge, T: TranscriptReadBuffer<&'a [u8], Scheme::Curve, E>, Strategy: VerificationStrategy<'params, Scheme, V, Output = Strategy>, + const N_POINTS: usize, >( params: &'params Scheme::ParamsVerifier, proof: &'a [u8], challenge: Fp, - commitment_point: G1Affine, -) -> (bool, Fp) + commitment_points: &[G1Affine], +) -> (bool, Vec) where Scheme::Scalar: WithSmallOrderMulGroup<3>, { let mut transcript = T::init(proof); - // Read the polynomial evaluation from the transcript - let eval_at_challenge = transcript.read_scalar().unwrap(); + // Read the polynomial evaluations from the transcript + let evaluations = (0..N_POINTS) + .map(|_| transcript.read_scalar().unwrap()) + .collect::>(); - // Prepare verifier query for the commitment - let queries = [VerifierQuery::new_commitment( - &commitment_point, - challenge, - eval_at_challenge, - )]; + // Prepare verifier queries for the commitment + let queries = (0..N_POINTS) + .map(|i| VerifierQuery::new_commitment(&commitment_points[i], challenge, evaluations[i])) + .collect::>(); // Initialize the verifier let verifier = V::new(params); @@ -348,7 +434,7 @@ where .unwrap(); // Return the result of the verification - (strategy.finalize(), eval_at_challenge) + (strategy.finalize(), evaluations) } /// Verifies a proof given the public setup, the verification key, the proof and the public inputs of the circuit. diff --git a/kzg_prover/src/csv/entry_16.csv b/kzg_prover/src/csv/entry_16.csv deleted file mode 100644 index 40e14fd3..00000000 --- a/kzg_prover/src/csv/entry_16.csv +++ /dev/null @@ -1,17 +0,0 @@ -username,balance_ETH_ETH,balance_USDT_ETH -dxGaEAii,1,41163 -MBlfbBGI,1,18651 -lAhWlEWZ,1,2087 -nuZweYtO,1,55683 -gbdSwiuY,1,83296 -RZNneNuP,2,16881 -YsscHXkp,1,35479 -RkLzkDun,1,79731 -HlQlnEYI,1,11888 -RqkZOFYe,1,14874 -NjCSRAfD,1,67823 -pHniJMQY,1,22073 -dOGIMzKR,1,10032 -HfMDmNLp,1,34897 -xPLKzCBl,1,30605 -AtwIxZHo,1,31699 diff --git a/kzg_prover/src/csv/entry_16_bigints.csv b/kzg_prover/src/csv/entry_16_bigints.csv deleted file mode 100644 index 04e2e247..00000000 --- a/kzg_prover/src/csv/entry_16_bigints.csv +++ /dev/null @@ -1,17 +0,0 @@ -username,balance_ETH_ETH,balance_USDT_ETH -dxGaEAii,18446744073709551616,79731 -MBlfbBGI,67823,55683 -lAhWlEWZ,18651,22073 -nuZweYtO,22073,35479 -gbdSwiuY,34897,10032 -RZNneNuP,83296,2087 -YsscHXkp,31699,34897 -RkLzkDun,2087,67823 -HlQlnEYI,30605,31699 -RqkZOFYe,16881,16881 -NjCSRAfD,41163,14874 -pHniJMQY,14874,18651 -dOGIMzKR,10032,41163 -HfMDmNLp,55683,83296 -xPLKzCBl,79731,18446744073709551616 -AtwIxZHo,35479,30605 diff --git a/kzg_prover/src/csv/entry_16_modified.csv b/kzg_prover/src/csv/entry_16_modified.csv deleted file mode 100644 index b5496bf2..00000000 --- a/kzg_prover/src/csv/entry_16_modified.csv +++ /dev/null @@ -1,17 +0,0 @@ -username,balance_ETH_ETH,balance_USDT_ETH -dxGaEAii,11888,41163 -MBlfbBGI,67823,18651 -lAhWlEWZ,18651,2087 -nuZweYtO,22073,55683 -gbdSwiuY,34897,83296 -RZNneNuP,83296,16881 -YsscHXkp,31699,35479 -RkLzkDun,2086,79732 -HlQlnEYI,30605,11888 -RqkZOFYe,16881,14874 -NjCSRAfD,41163,67823 -pHniJMQY,14874,22073 -dOGIMzKR,10032,10032 -HfMDmNLp,55683,34897 -xPLKzCBl,79731,30605 -AtwIxZHo,35479,31699 diff --git a/kzg_prover/src/csv/entry_16_no_overflow.csv b/kzg_prover/src/csv/entry_16_no_overflow.csv deleted file mode 100644 index f55f626b..00000000 --- a/kzg_prover/src/csv/entry_16_no_overflow.csv +++ /dev/null @@ -1,17 +0,0 @@ -username,balance_ETH_ETH,balance_USDT_ETH -dxGaEAii,18446744073709551615,0 -MBlfbBGI,0,18446744073709551615 -lAhWlEWZ,0,0 -nuZweYtO,0,0 -gbdSwiuY,0,0 -RZNneNuP,0,0 -YsscHXkp,0,0 -RkLzkDun,0,0 -HlQlnEYI,0,0 -RqkZOFYe,0,0 -NjCSRAfD,0,0 -pHniJMQY,0,0 -dOGIMzKR,0,0 -HfMDmNLp,0,0 -xPLKzCBl,0,0 -AtwIxZHo,0,0 diff --git a/kzg_prover/src/csv/entry_16_overflow.csv b/kzg_prover/src/csv/entry_16_overflow.csv deleted file mode 100644 index 772993d4..00000000 --- a/kzg_prover/src/csv/entry_16_overflow.csv +++ /dev/null @@ -1,17 +0,0 @@ -username,balance_ETH_ETH,balance_USDT_ETH -dxGaEAii,18446744073709551616,0 -MBlfbBGI,0,18446744073709551616 -lAhWlEWZ,0,0 -nuZweYtO,0,0 -gbdSwiuY,0,0 -RZNneNuP,0,0 -YsscHXkp,0,0 -RkLzkDun,0,0 -HlQlnEYI,0,0 -RqkZOFYe,0,0 -NjCSRAfD,0,0 -pHniJMQY,0,0 -dOGIMzKR,0,0 -HfMDmNLp,0,0 -xPLKzCBl,0,0 -AtwIxZHo,0,0 diff --git a/kzg_prover/src/csv/entry_16_overflow_2.csv b/kzg_prover/src/csv/entry_16_overflow_2.csv deleted file mode 100644 index 1a7cc314..00000000 --- a/kzg_prover/src/csv/entry_16_overflow_2.csv +++ /dev/null @@ -1,17 +0,0 @@ -username,balance_ETH_ETH,balance_USDT_ETH -dxGaEAii,18446744073709551615,0 -MBlfbBGI,0,18446744073709551615 -lAhWlEWZ,0,0 -nuZweYtO,0,0 -gbdSwiuY,0,0 -RZNneNuP,0,0 -YsscHXkp,0,0 -RkLzkDun,0,0 -HlQlnEYI,0,0 -RqkZOFYe,0,0 -NjCSRAfD,0,0 -pHniJMQY,0,0 -dOGIMzKR,0,0 -HfMDmNLp,0,0 -xPLKzCBl,0,0 -AtwIxZHo,1,1 diff --git a/kzg_prover/src/csv/entry_16_switched_order.csv b/kzg_prover/src/csv/entry_16_switched_order.csv deleted file mode 100644 index a83d2b46..00000000 --- a/kzg_prover/src/csv/entry_16_switched_order.csv +++ /dev/null @@ -1,17 +0,0 @@ -username,balance_ETH_ETH,balance_USDT_ETH -dxGaEAii,11888,79731 -MBlfbBGI,67823,22073 -lAhWlEWZ,18651,18651 -nuZweYtO,22073,35479 -gbdSwiuY,34897,83296 -RZNneNuP,83296,34897 -YsscHXkp,31699,55683 -RkLzkDun,2087,30605 -HlQlnEYI,30605,10032 -RqkZOFYe,16881,16881 -NjCSRAfD,41163,41163 -pHniJMQY,14874,31699 -dOGIMzKR,10032,11888 -HfMDmNLp,55683,14874 -AtwIxZHo,35479,67823 -xPLKzCBl,79731,2087