feature/implement verkle tree follow commitment scheme interface

verkletree/examples/test_commitment.rs

@@ -0,0 +1,28 @@
+use verkletree::verkletree::*;
+use zkmemory::commitment::commitment_scheme::CommitmentScheme;
+extern crate alloc;
+use ff::Field;
+use halo2_proofs::halo2curves::bn256::Fr;
+use rand::thread_rng;
+
+fn main() {
+    let rng = thread_rng();
+    let elements: Vec<Fr> = (0..16 * 16).map(|_| Fr::random(rng.clone())).collect();
+
+    let vk_commitment_scheme = VerkleTreeCommitmentScheme::setup(Some(2));
+
+    let indices: Vec<usize> = vec![2, 3, 3, 3];
+    let leaf = elements[16 * 16 - 2];
+
+    let witness = VerkleTreeWitness {
+        leaf,
+        elements,
+        indices,
+    };
+
+    let root = vk_commitment_scheme.commit(witness.clone());
+
+    let opening = vk_commitment_scheme.open(witness.clone());
+
+    assert!(vk_commitment_scheme.verify(root, opening, witness))
+}

verkletree/examples/test.rs → verkletree/examples/test_verkle_tree.rs

@@ -9,7 +9,13 @@ fn main() {
     let (circuit, root) = create_verkle_tree_proof(leaf, indices);
 
     let k = 10;
+
     let mut prover = VerkleTreeProver::new(k, circuit, true);
+    let (params, vk) = prover.get_verifier_params();
+
+    let mut verifier = VerkleTreeVerifier::new(params, vk, true);
+
     let proof = prover.create_proof(leaf, root);
-    assert!(prover.verify(proof, leaf, root))
+
+    assert!(verifier.verify(proof, leaf, root))
 }

verkletree/src/circuit.rs

@@ -17,7 +17,7 @@ use halo2_proofs::{
     },
     plonk::{
         create_proof, keygen_pk, keygen_vk, verify_proof, Advice, Circuit, Column,
-        ConstraintSystem, Error, Expression, Fixed, Instance, ProvingKey, Selector,
+        ConstraintSystem, Error, Expression, Fixed, Instance, ProvingKey, Selector, VerifyingKey,
     },
     poly::{
         commitment::{Blind, ParamsProver},
@@ -37,9 +37,10 @@ use poseidon::{
     poseidon_constants::{MDS_FR, MDS_INV_FR, ROUND_CONSTANTS_FR},
     poseidon_hash::Mtrx,
 };
+use rand::thread_rng;
 use rand_core::OsRng;
-use zkmemory::commitment::kzg::create_kzg_proof;
-use zkmemory::commitment::kzg::verify_kzg_proof;
+
+use zkmemory::commitment::kzg::{create_kzg_proof, verify_kzg_proof};
 use zkmemory::constraints;
 
 pub(crate) const OMEGA_POWER: [Fr; 5] = [
@@ -49,7 +50,6 @@ pub(crate) const OMEGA_POWER: [Fr; 5] = [
     Fr::from_raw([0x0157, 0, 0, 0]),
     Fr::from_raw([0x0961, 0, 0, 0]),
 ];
-use rand::thread_rng;
 
 #[derive(Clone, Copy)]
 /// Verkle tree config
@@ -337,81 +337,10 @@ impl Spec<Fr, 3, 2> for OrchardNullifier {
     }
 }
 
-pub struct VerkleTreeProver<S: Spec<Fr, W, R>, const W: usize, const R: usize, const A: usize> {
-    params: ParamsKZG<Bn256>,
-    pk: ProvingKey<G1Affine>,
-    circuit: VerkleTreeCircuit<S, W, R, A>,
-    expected: bool,
-}
-
-impl<S: Spec<Fr, W, R>, const W: usize, const R: usize, const A: usize>
-    VerkleTreeProver<S, W, R, A>
-{
-    /// initialize the parameters for the prover
-    pub fn new(k: u32, circuit: VerkleTreeCircuit<S, W, R, A>, expected: bool) -> Self {
-        let params = ParamsKZG::<Bn256>::setup(k, OsRng);
-        let vk = keygen_vk(&params, &circuit).expect("Cannot initialize verify key");
-        let pk = keygen_pk(&params, vk.clone(), &circuit).expect("Cannot initialize proving key");
-
-        Self {
-            params,
-            pk,
-            circuit,
-            expected,
-        }
-    }
-
-    /// Create proof for the permutation circuit
-    pub fn create_proof(&mut self, leaf: Fr, root: Fr) -> Vec<u8> {
-        let mut transcript =
-            Blake2bWrite::<Vec<u8>, G1Affine, Challenge255<G1Affine>>::init(vec![]);
-        create_proof::<
-            KZGCommitmentScheme<Bn256>,
-            ProverSHPLONK<'_, Bn256>,
-            Challenge255<G1Affine>,
-            OsRng,
-            Blake2bWrite<Vec<u8>, G1Affine, Challenge255<G1Affine>>,
-            VerkleTreeCircuit<S, W, R, A>,
-        >(
-            &self.params,
-            &self.pk,
-            &[self.circuit.clone()],
-            &[&[&[leaf, root]]],
-            OsRng,
-            &mut transcript,
-        )
-        .expect("Fail to create proof.");
-        transcript.finalize()
-    }
-
-    /// Verify the proof (by comparing the result with expected value)
-    pub fn verify(&mut self, proof: Vec<u8>, leaf: Fr, root: Fr) -> bool {
-        let strategy = SingleStrategy::new(&self.params);
-        let mut transcript =
-            Blake2bRead::<&[u8], G1Affine, Challenge255<G1Affine>>::init(&proof[..]);
-        let result = verify_proof::<
-            KZGCommitmentScheme<Bn256>,
-            VerifierSHPLONK<'_, Bn256>,
-            Challenge255<G1Affine>,
-            Blake2bRead<&[u8], G1Affine, Challenge255<G1Affine>>,
-            SingleStrategy<'_, Bn256>,
-        >(
-            &self.params,
-            self.pk.get_vk(),
-            strategy,
-            &[&[&[leaf, root]]],
-            &mut transcript,
-        );
-        match result {
-            Ok(()) => self.expected,
-            Err(_) => !self.expected,
-        }
-    }
-}
-
 /// A KZG struct for the purpose of testing the correctness of the Verkle tree circuit
+#[derive(Clone, Debug)]
 pub struct KZGStruct {
-    kzg_params: ParamsKZG<Bn256>,
+    pub kzg_params: ParamsKZG<Bn256>,
     domain: EvaluationDomain<Fr>,
 }
 
@@ -510,6 +439,124 @@ pub fn create_verkle_tree_proof(
     (circuit, root)
 }
 
+pub struct VerkleTreeVerifier {
+    params: ParamsKZG<Bn256>,
+    pub vk: VerifyingKey<G1Affine>,
+    expected: bool,
+}
+
+impl VerkleTreeVerifier {
+    /// initialize the verfier
+    pub fn new(params: ParamsKZG<Bn256>, vk: VerifyingKey<G1Affine>, expected: bool) -> Self {
+        Self {
+            params,
+            vk,
+            expected,
+        }
+    }
+
+    /// Verify the proof (by comparing the result with expected value)
+    pub fn verify(&mut self, proof: Vec<u8>, leaf: Fr, root: Fr) -> bool {
+        let strategy = SingleStrategy::new(&self.params);
+        let mut transcript =
+            Blake2bRead::<&[u8], G1Affine, Challenge255<G1Affine>>::init(&proof[..]);
+        let result = verify_proof::<
+            KZGCommitmentScheme<Bn256>,
+            VerifierSHPLONK<'_, Bn256>,
+            Challenge255<G1Affine>,
+            Blake2bRead<&[u8], G1Affine, Challenge255<G1Affine>>,
+            SingleStrategy<'_, Bn256>,
+        >(
+            &self.params,
+            &self.vk,
+            strategy,
+            &[&[&[leaf, root]]],
+            &mut transcript,
+        );
+        match result {
+            Ok(()) => self.expected,
+            Err(_) => !self.expected,
+        }
+    }
+}
+
+pub struct VerkleTreeProver<S: Spec<Fr, W, R>, const W: usize, const R: usize, const A: usize> {
+    params: ParamsKZG<Bn256>,
+    pk: ProvingKey<G1Affine>,
+    circuit: VerkleTreeCircuit<S, W, R, A>,
+    expected: bool,
+}
+
+impl<S: Spec<Fr, W, R>, const W: usize, const R: usize, const A: usize>
+    VerkleTreeProver<S, W, R, A>
+{
+    /// initialize the prover
+    pub fn new(k: u32, circuit: VerkleTreeCircuit<S, W, R, A>, expected: bool) -> Self {
+        let params = ParamsKZG::<Bn256>::setup(k, OsRng);
+        let vk = keygen_vk(&params, &circuit).expect("Cannot initialize verify key");
+        let pk = keygen_pk(&params, vk.clone(), &circuit).expect("Cannot initialize proving key");
+
+        Self {
+            params,
+            pk,
+            circuit,
+            expected,
+        }
+    }
+
+    // params to create VerkleTreeVerifier
+    pub fn get_verifier_params(&self) -> (ParamsKZG<Bn256>, VerifyingKey<G1Affine>) {
+        (self.params.clone(), self.pk.get_vk().clone())
+    }
+
+    /// Create proof for the permutation circuit
+    pub fn create_proof(&mut self, leaf: Fr, root: Fr) -> Vec<u8> {
+        let mut transcript: Blake2bWrite<Vec<u8>, G1Affine, Challenge255<G1Affine>> =
+            Blake2bWrite::<Vec<u8>, G1Affine, Challenge255<G1Affine>>::init(vec![]);
+        create_proof::<
+            KZGCommitmentScheme<Bn256>,
+            ProverSHPLONK<'_, Bn256>,
+            Challenge255<G1Affine>,
+            OsRng,
+            Blake2bWrite<Vec<u8>, G1Affine, Challenge255<G1Affine>>,
+            VerkleTreeCircuit<S, W, R, A>,
+        >(
+            &self.params,
+            &self.pk,
+            &[self.circuit.clone()],
+            &[&[&[leaf, root]]],
+            OsRng,
+            &mut transcript,
+        )
+        .expect("Fail to create proof.");
+        transcript.finalize()
+    }
+
+    /// Verify the proof (by comparing the result with expected value)
+    pub fn verify(&mut self, proof: Vec<u8>, leaf: Fr, root: Fr) -> bool {
+        let strategy = SingleStrategy::new(&self.params);
+        let mut transcript =
+            Blake2bRead::<&[u8], G1Affine, Challenge255<G1Affine>>::init(&proof[..]);
+        let result = verify_proof::<
+            KZGCommitmentScheme<Bn256>,
+            VerifierSHPLONK<'_, Bn256>,
+            Challenge255<G1Affine>,
+            Blake2bRead<&[u8], G1Affine, Challenge255<G1Affine>>,
+            SingleStrategy<'_, Bn256>,
+        >(
+            &self.params,
+            self.pk.get_vk(),
+            strategy,
+            &[&[&[leaf, root]]],
+            &mut transcript,
+        );
+        match result {
+            Ok(()) => self.expected,
+            Err(_) => !self.expected,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

verkletree/src/lib.rs

@@ -1,2 +1,5 @@
 /// Verkle Tree circuit
 pub mod circuit;
+
+/// Verkle Tree Commitment Scheme
+pub mod verkletree;