From 818d47ce306ef15217981c23db893d8414bda856 Mon Sep 17 00:00:00 2001 From: Kevaundray Wedderburn Date: Sun, 28 Jan 2024 23:40:26 +0000 Subject: [PATCH 01/14] draft alt design for create-proof --- ffi_interface/src/lib.rs | 94 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index a206d97..3a779d2 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -287,6 +287,100 @@ pub fn create_proof(input: Vec) -> Vec { proof.to_bytes().unwrap() } +// This is an alternative implementation of create_proof +pub fn create_proof_alt(input: Vec) -> Vec { + // - Checks for the serialized proof queries + /// + // Define the chunk size (8257 bytes) + // C_i, f_i(X), z_i, y_i + // 32, 8192, 1, 32 + // = 8257 + const CHUNK_SIZE: usize = 8257; // TODO: get this from ipa-multipoint + + if input.len() % CHUNK_SIZE != 0 { + // TODO: change this to an error + panic!("Input length must be a multiple of {}", CHUNK_SIZE); + } + let num_proofs = input.len() / CHUNK_SIZE; + + let proofs_bytes = input.chunks_exact(CHUNK_SIZE); + assert!( + proofs_bytes.remainder().is_empty(), + "There should be no left over bytes when chunking the proof" + ); + + // - Deserialize proof queries + // + let mut prover_queries: Vec = Vec::with_capacity(num_proofs); + + for proof_bytes in proofs_bytes { + let prover_query = deserialize_proof_query(&proof_bytes); + prover_queries.push(prover_query); + } + + // - Create proofs + // + // TODO: This should be passed in as a pointer + let precomp = PrecomputedWeights::new(256); + + let crs = CRS::default(); + let mut transcript = Transcript::new(b"verkle"); + // TODO: This should not need to clone the CRS, but instead take a reference + + let proof = MultiPoint::open(crs.clone(), &precomp, &mut transcript, prover_queries); + proof.to_bytes().expect("cannot serialize proof") +} + +#[must_use] +fn deserialize_proof_query(bytes: &[u8]) -> ProverQuery { + // Commitment + let (commitment, mut bytes) = take_group_element(bytes); + + // f_x is a polynomial of degree 255, so we have 256 Fr elements + const NUMBER_OF_EVALUATIONS: usize = 256; + let mut collect_lagrange_basis: Vec = Vec::with_capacity(NUMBER_OF_EVALUATIONS); + for _ in 0..NUMBER_OF_EVALUATIONS { + let (scalar, offsetted_bytes) = take_scalar(bytes); + collect_lagrange_basis.push(scalar); + bytes = offsetted_bytes; + } + + // The input point is a single byte + let (z_i, bytes) = take_byte(bytes); + + // The evaluation is a single scalar + let (y_i, bytes) = take_scalar(bytes); + + assert!(bytes.is_empty(), "we should have consumed all the bytes"); + + ProverQuery { + commitment, + poly: LagrangeBasis::new(collect_lagrange_basis), + point: z_i, + result: y_i, + } +} + +#[must_use] +fn take_group_element(bytes: &[u8]) -> (Element, &[u8]) { + let element = Element::from_bytes(&bytes[0..32]).expect("could not deserialize element"); + // Increment the slice by 32 bytes + (element, &bytes[32..]) +} + +#[must_use] +fn take_byte(bytes: &[u8]) -> (usize, &[u8]) { + let z_i = bytes[0] as usize; + // Increment the slice by 32 bytes + (z_i, &bytes[1..]) +} +#[must_use] +fn take_scalar(bytes: &[u8]) -> (Fr, &[u8]) { + let y_i = fr_from_le_bytes(&bytes[0..32]).expect("could not deserialize y_i"); + // Increment the slice by 32 bytes + (y_i, &bytes[32..]) +} + #[cfg(test)] mod tests { use ipa_multipoint::{ From 2050dbbe82b3e419c208c49f8c73260eaecb5258 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Wed, 31 Jan 2024 20:23:40 +0100 Subject: [PATCH 02/14] feat(ffi_interface): prover and verifier exposed calls --- ffi_interface/src/lib.rs | 70 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 69 insertions(+), 1 deletion(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index 9e09841..16cac8b 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -10,7 +10,7 @@ use banderwagon::{trait_defs::*, Element}; use ipa_multipoint::committer::{Committer, DefaultCommitter}; use ipa_multipoint::crs::CRS; use ipa_multipoint::lagrange_basis::{LagrangeBasis, PrecomputedWeights}; -use ipa_multipoint::multiproof::{MultiPoint, ProverQuery}; +use ipa_multipoint::multiproof::{MultiPoint, ProverQuery, MultiPointProof, VerifierQuery}; use ipa_multipoint::transcript::Transcript; /// Context holds all of the necessary components needed for cryptographic operations @@ -359,6 +359,53 @@ pub fn create_proof_alt(input: Vec) -> Vec { proof.to_bytes().expect("cannot serialize proof") } +/// Receives a proof and a tuple (C_i, z_i, y_i) +/// Where C_i is a commitment to f_i(X) serialized as 64 bytes (uncompressed commitment) +/// z_i is index of the point in the polynomial: 1 byte (number from 1 to 256) +/// y_i is the evaluation of the polynomial at z_i i.e value we are opening: 32 bytes or Fr (scalar field element) +/// Returns true of false. +/// Proof is verified or not. +/// TODO: Test this function. +#[allow(dead_code)] +fn exposed_verify_call( + precomputed_weights: &mut PrecomputedWeights, + transcript: &mut Transcript, + input: Vec, +) -> bool { + // Proof bytes are 576 bytes + // First 32 bytes is the g_x_comm_bytes + // Next 544 bytes are part of IPA proof. + let proof_bytes = &input[0..576]; + + let proof = MultiPointProof::from_bytes(proof_bytes, 256).unwrap(); + + let verifier_queries_bytes = &input[576..]; + + // Define the chunk size 64+1+32 = 97 bytes for C_i, z_i, y_i + const CHUNK_SIZE: usize = 97; + + let num_openings = verifier_queries_bytes.len() / CHUNK_SIZE; + + // Create an iterator over the input Vec + let chunked_verifier_queries = verifier_queries_bytes.chunks(CHUNK_SIZE); + + // let mut verifier_queries: Vec = Vec::new(); + + // - Deserialize verifier queries + let mut verifier_queries: Vec = Vec::with_capacity(num_openings); + + for verifier_query_bytes in chunked_verifier_queries { + let verifier_query = deserialize_verifier_query(&verifier_query_bytes); + verifier_queries.push(verifier_query); + } + + let context = Context::new(); + + proof.check(&context.crs, &context.precomputed_weights, &verifier_queries, transcript) +} + + + #[must_use] fn deserialize_proof_query(bytes: &[u8]) -> ProverQuery { // Commitment @@ -389,6 +436,27 @@ fn deserialize_proof_query(bytes: &[u8]) -> ProverQuery { } } +#[must_use] +fn deserialize_verifier_query(bytes: &[u8]) -> VerifierQuery { + // Commitment + let (commitment, bytes) = take_group_element(bytes); + + // The input point is a single byte + let (z_i, bytes) = take_byte(bytes); + + // The evaluation is a single scalar + let (y_i, bytes) = take_scalar(bytes); + + assert!(bytes.is_empty(), "we should have consumed all the bytes"); + + VerifierQuery { + commitment, + point: Fr::from(z_i as u128), + result: y_i, + } +} + + #[must_use] fn take_group_element(bytes: &[u8]) -> (Element, &[u8]) { let element = Element::from_bytes(&bytes[0..32]).expect("could not deserialize element"); From f23273d8ef2f1b73ca2582ab78d56fbbd8ba9501 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Wed, 31 Jan 2024 20:59:32 +0100 Subject: [PATCH 03/14] small changes --- ffi_interface/src/lib.rs | 83 ++++++++-------------------------------- 1 file changed, 15 insertions(+), 68 deletions(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index 16cac8b..15495d5 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -259,64 +259,7 @@ fn fr_from_le_bytes(bytes: &[u8]) -> Result { /// Returns a proof serialized as bytes /// /// This function assumes that the domain is always 256 values and commitment is 32bytes. -/// TODO: change commitment to 64bytes since we are moving to uncompressed commitment. pub fn create_proof(input: Vec) -> Vec { - // Define the chunk size (8257 bytes) - // C_i, f_i(X), z_i, y_i - // 32, 8192, 1, 32 - // = 8257 - let chunk_size = 8257; - // Create an iterator over the input Vec - let chunked_data = input.chunks(chunk_size); - - let mut prover_queries: Vec = Vec::new(); - - for chunk in chunked_data.into_iter() { - if chunk.len() >= chunk_size { - let data = chunk; - let commitment = Element::from_bytes(&data[0..32]).unwrap(); - - // Create f_x from the next 8192 bytes - let f_i_x: Vec = chunk[32..8224].to_vec(); - - let chunked_f_i_x_data = f_i_x.chunks(32); - - let mut collect_lagrange_basis: Vec = Vec::new(); - for chunk_f_i_x in chunked_f_i_x_data.into_iter() { - if chunk_f_i_x.len() >= 32 { - let data_f_i_x = chunk_f_i_x; - let fr_data_f_i_x = Fr::from_be_bytes_mod_order(data_f_i_x); - collect_lagrange_basis.push(fr_data_f_i_x); - } - } - - let lagrange_basis = LagrangeBasis::new(collect_lagrange_basis); - - let z_i: usize = chunk[8224] as usize; - - let y_i = Fr::from_be_bytes_mod_order(&chunk[8225..8257]); - - let prover_query = ProverQuery { - commitment, - poly: lagrange_basis, - point: z_i, - result: y_i, - }; - prover_queries.push(prover_query); - } - } - // TODO: This should be passed in as a pointer - let precomp = PrecomputedWeights::new(256); - - let crs = CRS::default(); - let mut transcript = Transcript::new(b"verkle"); - // TODO: This should not need to clone the CRS, but instead take a reference - let proof = MultiPoint::open(crs.clone(), &precomp, &mut transcript, prover_queries); - proof.to_bytes().unwrap() -} - -// This is an alternative implementation of create_proof -pub fn create_proof_alt(input: Vec) -> Vec { // - Checks for the serialized proof queries /// // Define the chunk size (8257 bytes) @@ -329,7 +272,7 @@ pub fn create_proof_alt(input: Vec) -> Vec { // TODO: change this to an error panic!("Input length must be a multiple of {}", CHUNK_SIZE); } - let num_proofs = input.len() / CHUNK_SIZE; + let num_openings = input.len() / CHUNK_SIZE; let proofs_bytes = input.chunks_exact(CHUNK_SIZE); assert!( @@ -339,7 +282,7 @@ pub fn create_proof_alt(input: Vec) -> Vec { // - Deserialize proof queries // - let mut prover_queries: Vec = Vec::with_capacity(num_proofs); + let mut prover_queries: Vec = Vec::with_capacity(num_openings); for proof_bytes in proofs_bytes { let prover_query = deserialize_proof_query(&proof_bytes); @@ -368,29 +311,31 @@ pub fn create_proof_alt(input: Vec) -> Vec { /// TODO: Test this function. #[allow(dead_code)] fn exposed_verify_call( - precomputed_weights: &mut PrecomputedWeights, - transcript: &mut Transcript, - input: Vec, + input: Vec ) -> bool { // Proof bytes are 576 bytes // First 32 bytes is the g_x_comm_bytes - // Next 544 bytes are part of IPA proof. + // Next 544 bytes are part of IPA proof. Domain size is always 256. Explanation is in IPAProof::from_bytes(). let proof_bytes = &input[0..576]; let proof = MultiPointProof::from_bytes(proof_bytes, 256).unwrap(); let verifier_queries_bytes = &input[576..]; - // Define the chunk size 64+1+32 = 97 bytes for C_i, z_i, y_i - const CHUNK_SIZE: usize = 97; + // Define the chunk size 32+1+32 = 65 bytes for C_i, z_i, y_i + const CHUNK_SIZE: usize = 65; + + if verifier_queries_bytes.len() % CHUNK_SIZE != 0 { + // TODO: change this to an error + panic!("Verifier queries bytes length must be a multiple of {}", CHUNK_SIZE); + } + let num_openings = verifier_queries_bytes.len() / CHUNK_SIZE; // Create an iterator over the input Vec let chunked_verifier_queries = verifier_queries_bytes.chunks(CHUNK_SIZE); - // let mut verifier_queries: Vec = Vec::new(); - // - Deserialize verifier queries let mut verifier_queries: Vec = Vec::with_capacity(num_openings); @@ -401,7 +346,9 @@ fn exposed_verify_call( let context = Context::new(); - proof.check(&context.crs, &context.precomputed_weights, &verifier_queries, transcript) + let mut transcript = Transcript::new(b"verkle"); + + proof.check(&context.crs, &context.precomputed_weights, &verifier_queries, &mut transcript) } From df749bf8912b09c8996fefbb9ed86e78db4ea107 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Wed, 31 Jan 2024 21:00:08 +0100 Subject: [PATCH 04/14] cargo fmt and clippy --- ffi_interface/src/lib.rs | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index 15495d5..25f8822 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -10,7 +10,7 @@ use banderwagon::{trait_defs::*, Element}; use ipa_multipoint::committer::{Committer, DefaultCommitter}; use ipa_multipoint::crs::CRS; use ipa_multipoint::lagrange_basis::{LagrangeBasis, PrecomputedWeights}; -use ipa_multipoint::multiproof::{MultiPoint, ProverQuery, MultiPointProof, VerifierQuery}; +use ipa_multipoint::multiproof::{MultiPoint, MultiPointProof, ProverQuery, VerifierQuery}; use ipa_multipoint::transcript::Transcript; /// Context holds all of the necessary components needed for cryptographic operations @@ -285,7 +285,7 @@ pub fn create_proof(input: Vec) -> Vec { let mut prover_queries: Vec = Vec::with_capacity(num_openings); for proof_bytes in proofs_bytes { - let prover_query = deserialize_proof_query(&proof_bytes); + let prover_query = deserialize_proof_query(proof_bytes); prover_queries.push(prover_query); } @@ -310,9 +310,7 @@ pub fn create_proof(input: Vec) -> Vec { /// Proof is verified or not. /// TODO: Test this function. #[allow(dead_code)] -fn exposed_verify_call( - input: Vec -) -> bool { +fn exposed_verify_call(input: Vec) -> bool { // Proof bytes are 576 bytes // First 32 bytes is the g_x_comm_bytes // Next 544 bytes are part of IPA proof. Domain size is always 256. Explanation is in IPAProof::from_bytes(). @@ -327,10 +325,12 @@ fn exposed_verify_call( if verifier_queries_bytes.len() % CHUNK_SIZE != 0 { // TODO: change this to an error - panic!("Verifier queries bytes length must be a multiple of {}", CHUNK_SIZE); + panic!( + "Verifier queries bytes length must be a multiple of {}", + CHUNK_SIZE + ); } - let num_openings = verifier_queries_bytes.len() / CHUNK_SIZE; // Create an iterator over the input Vec @@ -340,7 +340,7 @@ fn exposed_verify_call( let mut verifier_queries: Vec = Vec::with_capacity(num_openings); for verifier_query_bytes in chunked_verifier_queries { - let verifier_query = deserialize_verifier_query(&verifier_query_bytes); + let verifier_query = deserialize_verifier_query(verifier_query_bytes); verifier_queries.push(verifier_query); } @@ -348,11 +348,14 @@ fn exposed_verify_call( let mut transcript = Transcript::new(b"verkle"); - proof.check(&context.crs, &context.precomputed_weights, &verifier_queries, &mut transcript) + proof.check( + &context.crs, + &context.precomputed_weights, + &verifier_queries, + &mut transcript, + ) } - - #[must_use] fn deserialize_proof_query(bytes: &[u8]) -> ProverQuery { // Commitment @@ -403,7 +406,6 @@ fn deserialize_verifier_query(bytes: &[u8]) -> VerifierQuery { } } - #[must_use] fn take_group_element(bytes: &[u8]) -> (Element, &[u8]) { let element = Element::from_bytes(&bytes[0..32]).expect("could not deserialize element"); From 26cd2e2a2df36fc8ba4e6a32046b2ee3b36936e4 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Wed, 31 Jan 2024 22:35:55 +0100 Subject: [PATCH 05/14] add test prover-verifier --- ffi_interface/src/lib.rs | 82 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 82 insertions(+) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index 25f8822..cd732d2 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -565,3 +565,85 @@ mod pedersen_hash_tests { assert_eq!(expected_hash, got_hash_hex); } } + +#[cfg(test)] +mod prover_verifier_test { + + + use super::Context; + use crate::exposed_verify_call; + use crate::fr_to_le_bytes; + + use ipa_multipoint::{ + committer::{Committer}, + lagrange_basis::LagrangeBasis, + multiproof::ProverQuery, + }; + + #[test] + fn test_one_opening_create_proof_verify_proof() { + let a_0 = banderwagon::Fr::from(123u128); + let a_1 = banderwagon::Fr::from(123u128); + let a_2 = banderwagon::Fr::from(456u128); + let a_3 = banderwagon::Fr::from(789u128); + + let mut _poly: LagrangeBasis; + let mut all_vals = Vec::new(); + for _i in 0..64 { + all_vals.push(a_0); + all_vals.push(a_1); + all_vals.push(a_2); + all_vals.push(a_3); + } + let poly = LagrangeBasis::new(all_vals.clone()); + + let context = Context::new(); + + let commitment = context + .committer + .commit_lagrange(all_vals.as_slice()); + + let _prover_query = ProverQuery { + commitment, + poly, + point: 0, + result: a_0, + }; + + let commitment_bytes = commitment.to_bytes(); + + let mut poly_bytes: Vec = Vec::new(); + + for val in all_vals.clone() { + let bytes = fr_to_le_bytes(val); + poly_bytes.extend_from_slice(&bytes); + } + + let point_bytes = [0u8; 1]; + + let result_bytes = fr_to_le_bytes(a_0); + + let mut create_prover_bytes: Vec = Vec::new(); + + create_prover_bytes.extend_from_slice(&commitment_bytes); + create_prover_bytes.extend_from_slice(&poly_bytes); + create_prover_bytes.extend_from_slice(&point_bytes); + create_prover_bytes.extend_from_slice(&result_bytes); + + let proof_bytes = super::create_proof(create_prover_bytes); + + let mut create_verifier_bytes: Vec = Vec::new(); + create_verifier_bytes.extend_from_slice(&commitment_bytes); + create_verifier_bytes.extend_from_slice(&point_bytes); + create_verifier_bytes.extend_from_slice(&result_bytes); + + let mut verifier_call_bytes: Vec = Vec::new(); + + verifier_call_bytes.extend_from_slice(&proof_bytes); + verifier_call_bytes.extend_from_slice(&create_verifier_bytes); + + let test = exposed_verify_call(verifier_call_bytes); + + assert!(test); + } +} From 8a28f272a3774a4420bd7ff30302626ffe8b24e6 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Wed, 31 Jan 2024 22:38:02 +0100 Subject: [PATCH 06/14] small change --- ffi_interface/src/lib.rs | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index cd732d2..2b9f8a9 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -568,16 +568,13 @@ mod pedersen_hash_tests { #[cfg(test)] mod prover_verifier_test { - use super::Context; use crate::exposed_verify_call; use crate::fr_to_le_bytes; - + use ipa_multipoint::{ - committer::{Committer}, - lagrange_basis::LagrangeBasis, - multiproof::ProverQuery, + committer::Committer, lagrange_basis::LagrangeBasis, multiproof::ProverQuery, }; #[test] @@ -599,9 +596,7 @@ mod prover_verifier_test { let context = Context::new(); - let commitment = context - .committer - .commit_lagrange(all_vals.as_slice()); + let commitment = context.committer.commit_lagrange(all_vals.as_slice()); let _prover_query = ProverQuery { commitment, @@ -642,8 +637,8 @@ mod prover_verifier_test { verifier_call_bytes.extend_from_slice(&proof_bytes); verifier_call_bytes.extend_from_slice(&create_verifier_bytes); - let test = exposed_verify_call(verifier_call_bytes); + let verified = exposed_verify_call(verifier_call_bytes); - assert!(test); + assert!(verified); } } From 7d7f65dfafd235614868bbedd95af9b27dbe62e9 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Wed, 31 Jan 2024 22:39:43 +0100 Subject: [PATCH 07/14] test other value --- ffi_interface/src/lib.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index 2b9f8a9..731777d 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -601,7 +601,7 @@ mod prover_verifier_test { let _prover_query = ProverQuery { commitment, poly, - point: 0, + point: 2, result: a_0, }; @@ -614,9 +614,9 @@ mod prover_verifier_test { poly_bytes.extend_from_slice(&bytes); } - let point_bytes = [0u8; 1]; + let point_bytes = [2u8; 1]; - let result_bytes = fr_to_le_bytes(a_0); + let result_bytes = fr_to_le_bytes(a_2); let mut create_prover_bytes: Vec = Vec::new(); From d0b7afe5798b891b6e9c8fbaf044d279808a0592 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Mon, 5 Feb 2024 18:18:46 +0100 Subject: [PATCH 08/14] add multiple openings test --- ffi_interface/src/lib.rs | 57 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index 731777d..feb42c2 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -641,4 +641,61 @@ mod prover_verifier_test { assert!(verified); } + + #[test] + fn test_multiple_openings_create_proof_verify_proof() { + let a_0 = banderwagon::Fr::from(123u128); + let a_1 = banderwagon::Fr::from(123u128); + let a_2 = banderwagon::Fr::from(456u128); + let a_3 = banderwagon::Fr::from(789u128); + let context = Context::new(); + + let mut create_prover_bytes: Vec = Vec::new(); + + let mut create_verifier_bytes: Vec = Vec::new(); + for _iterate in 0..100 { + let mut _poly: LagrangeBasis; + let mut all_vals = Vec::new(); + for _i in 0..64 { + all_vals.push(a_0); + all_vals.push(a_1); + all_vals.push(a_2); + all_vals.push(a_3); + } + let commitment = context.committer.commit_lagrange(all_vals.as_slice()); + let commitment_bytes = commitment.to_bytes(); + + let mut poly_bytes: Vec = Vec::new(); + + for val in all_vals.clone() { + let bytes = fr_to_le_bytes(val); + poly_bytes.extend_from_slice(&bytes); + } + + let point_bytes = [2u8; 1]; + + let result_bytes = fr_to_le_bytes(a_2); + + + create_prover_bytes.extend_from_slice(&commitment_bytes); + create_prover_bytes.extend_from_slice(&poly_bytes); + create_prover_bytes.extend_from_slice(&point_bytes); + create_prover_bytes.extend_from_slice(&result_bytes); + + + create_verifier_bytes.extend_from_slice(&commitment_bytes); + create_verifier_bytes.extend_from_slice(&point_bytes); + create_verifier_bytes.extend_from_slice(&result_bytes); + } + let proof_bytes = super::create_proof(create_prover_bytes); + + let mut verifier_call_bytes: Vec = Vec::new(); + + verifier_call_bytes.extend_from_slice(&proof_bytes); + verifier_call_bytes.extend_from_slice(&create_verifier_bytes); + + let verified = exposed_verify_call(verifier_call_bytes); + + assert!(verified); + } } From 23e50fbe4c732563da56d0394c4eba218d568623 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Mon, 5 Feb 2024 18:23:54 +0100 Subject: [PATCH 09/14] cargo fmt --- ffi_interface/src/lib.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index feb42c2..28feb5f 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -666,23 +666,21 @@ mod prover_verifier_test { let commitment_bytes = commitment.to_bytes(); let mut poly_bytes: Vec = Vec::new(); - + for val in all_vals.clone() { let bytes = fr_to_le_bytes(val); poly_bytes.extend_from_slice(&bytes); } - + let point_bytes = [2u8; 1]; - + let result_bytes = fr_to_le_bytes(a_2); - - + create_prover_bytes.extend_from_slice(&commitment_bytes); create_prover_bytes.extend_from_slice(&poly_bytes); create_prover_bytes.extend_from_slice(&point_bytes); create_prover_bytes.extend_from_slice(&result_bytes); - create_verifier_bytes.extend_from_slice(&commitment_bytes); create_verifier_bytes.extend_from_slice(&point_bytes); create_verifier_bytes.extend_from_slice(&result_bytes); From a8db63589cbee8b110e3f98bd35b61ef97a8a99b Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Mon, 5 Feb 2024 18:25:32 +0100 Subject: [PATCH 10/14] fix --- ffi_interface/src/lib.rs | 8 -------- 1 file changed, 8 deletions(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index 28feb5f..6a44df8 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -592,19 +592,11 @@ mod prover_verifier_test { all_vals.push(a_2); all_vals.push(a_3); } - let poly = LagrangeBasis::new(all_vals.clone()); let context = Context::new(); let commitment = context.committer.commit_lagrange(all_vals.as_slice()); - let _prover_query = ProverQuery { - commitment, - poly, - point: 2, - result: a_0, - }; - let commitment_bytes = commitment.to_bytes(); let mut poly_bytes: Vec = Vec::new(); From 0420bc2b18b279d94097ccd4971a83ef9b346493 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Mon, 5 Feb 2024 18:27:04 +0100 Subject: [PATCH 11/14] cargo fmt --- ffi_interface/src/lib.rs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index 6a44df8..fc5152e 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -573,9 +573,7 @@ mod prover_verifier_test { use crate::exposed_verify_call; use crate::fr_to_le_bytes; - use ipa_multipoint::{ - committer::Committer, lagrange_basis::LagrangeBasis, multiproof::ProverQuery, - }; + use ipa_multipoint::{committer::Committer, lagrange_basis::LagrangeBasis}; #[test] fn test_one_opening_create_proof_verify_proof() { From db09b7dbb95e200a4bc84ce1d20aa39cddfe83f7 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Mon, 5 Feb 2024 18:32:45 +0100 Subject: [PATCH 12/14] fix merge --- ffi_interface/src/lib.rs | 49 ---------------------------------------- 1 file changed, 49 deletions(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index 0eb3a24..11bafe9 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -470,55 +470,6 @@ pub fn create_proof_alt(input: Vec) -> Vec { proof.to_bytes().expect("cannot serialize proof") } -#[must_use] -fn deserialize_proof_query(bytes: &[u8]) -> ProverQuery { - // Commitment - let (commitment, mut bytes) = take_group_element(bytes); - - // f_x is a polynomial of degree 255, so we have 256 Fr elements - const NUMBER_OF_EVALUATIONS: usize = 256; - let mut collect_lagrange_basis: Vec = Vec::with_capacity(NUMBER_OF_EVALUATIONS); - for _ in 0..NUMBER_OF_EVALUATIONS { - let (scalar, offsetted_bytes) = take_scalar(bytes); - collect_lagrange_basis.push(scalar); - bytes = offsetted_bytes; - } - - // The input point is a single byte - let (z_i, bytes) = take_byte(bytes); - - // The evaluation is a single scalar - let (y_i, bytes) = take_scalar(bytes); - - assert!(bytes.is_empty(), "we should have consumed all the bytes"); - - ProverQuery { - commitment, - poly: LagrangeBasis::new(collect_lagrange_basis), - point: z_i, - result: y_i, - } -} - -#[must_use] -fn take_group_element(bytes: &[u8]) -> (Element, &[u8]) { - let element = Element::from_bytes(&bytes[0..32]).expect("could not deserialize element"); - // Increment the slice by 32 bytes - (element, &bytes[32..]) -} - -#[must_use] -fn take_byte(bytes: &[u8]) -> (usize, &[u8]) { - let z_i = bytes[0] as usize; - // Increment the slice by 32 bytes - (z_i, &bytes[1..]) -} -#[must_use] -fn take_scalar(bytes: &[u8]) -> (Fr, &[u8]) { - let y_i = fr_from_le_bytes(&bytes[0..32]).expect("could not deserialize y_i"); - // Increment the slice by 32 bytes - (y_i, &bytes[32..]) -} #[cfg(test)] mod tests { From 034f07b487aa9952aafdacf7fc0db2a936aa4822 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Mon, 5 Feb 2024 18:34:22 +0100 Subject: [PATCH 13/14] fix --- ffi_interface/src/lib.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index 11bafe9..fe743bd 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -470,7 +470,6 @@ pub fn create_proof_alt(input: Vec) -> Vec { proof.to_bytes().expect("cannot serialize proof") } - #[cfg(test)] mod tests { use banderwagon::Fr; From 7774ee432dca7496ea2e104e1fad48e1a7fb3515 Mon Sep 17 00:00:00 2001 From: Dragan Pilipovic Date: Mon, 5 Feb 2024 18:38:19 +0100 Subject: [PATCH 14/14] keep only create_proof --- ffi_interface/src/lib.rs | 44 ---------------------------------------- 1 file changed, 44 deletions(-) diff --git a/ffi_interface/src/lib.rs b/ffi_interface/src/lib.rs index fe743bd..fc5152e 100644 --- a/ffi_interface/src/lib.rs +++ b/ffi_interface/src/lib.rs @@ -426,50 +426,6 @@ fn take_scalar(bytes: &[u8]) -> (Fr, &[u8]) { (y_i, &bytes[32..]) } -// This is an alternative implementation of create_proof -pub fn create_proof_alt(input: Vec) -> Vec { - // - Checks for the serialized proof queries - /// - // Define the chunk size (8257 bytes) - // C_i, f_i(X), z_i, y_i - // 32, 8192, 1, 32 - // = 8257 - const CHUNK_SIZE: usize = 8257; // TODO: get this from ipa-multipoint - - if input.len() % CHUNK_SIZE != 0 { - // TODO: change this to an error - panic!("Input length must be a multiple of {}", CHUNK_SIZE); - } - let num_proofs = input.len() / CHUNK_SIZE; - - let proofs_bytes = input.chunks_exact(CHUNK_SIZE); - assert!( - proofs_bytes.remainder().is_empty(), - "There should be no left over bytes when chunking the proof" - ); - - // - Deserialize proof queries - // - let mut prover_queries: Vec = Vec::with_capacity(num_proofs); - - for proof_bytes in proofs_bytes { - let prover_query = deserialize_proof_query(proof_bytes); - prover_queries.push(prover_query); - } - - // - Create proofs - // - // TODO: This should be passed in as a pointer - let precomp = PrecomputedWeights::new(256); - - let crs = CRS::default(); - let mut transcript = Transcript::new(b"verkle"); - // TODO: This should not need to clone the CRS, but instead take a reference - - let proof = MultiPoint::open(crs.clone(), &precomp, &mut transcript, prover_queries); - proof.to_bytes().expect("cannot serialize proof") -} - #[cfg(test)] mod tests { use banderwagon::Fr;