Move calldata preparation (#217)

pmikolajczyk41 · web-flow · commit 8912049ba100 · 2025-03-04T13:57:49.000Z
* Remove unused trait

* Move `prepare_calldata` to `solidity-verifiers`

* Move `to_eth` utilities

* imports

* Implicit selector computation

* Rename function
diff --git a/examples/circom_full_flow.rs b/examples/circom_full_flow.rs
@@ -21,18 +21,15 @@ use experimental_frontends::{circom::CircomFCircuit, utils::VecF};
 use folding_schemes::{
     commitment::{kzg::KZG, pedersen::Pedersen},
     folding::{
-        nova::{
-            decider_eth::{prepare_calldata, Decider as DeciderEth},
-            Nova, PreprocessorParam,
-        },
+        nova::{decider_eth::Decider as DeciderEth, Nova, PreprocessorParam},
         traits::CommittedInstanceOps,
     },
     frontend::FCircuit,
     transcript::poseidon::poseidon_canonical_config,
     Decider, Error, FoldingScheme,
 };
 use solidity_verifiers::calldata::{
-    get_function_selector_for_nova_cyclefold_verifier, NovaVerificationMode,
+    prepare_calldata_for_nova_cyclefold_verifier, NovaVerificationMode,
 };
 use solidity_verifiers::{
     evm::{compile_solidity, Evm},
@@ -135,13 +132,8 @@ fn main() -> Result<(), Error> {
     println!("Decider proof verification: {}", verified);
 
     // Now, let's generate the Solidity code that verifies this Decider final proof
-    let function_selector = get_function_selector_for_nova_cyclefold_verifier(
+    let calldata: Vec<u8> = prepare_calldata_for_nova_cyclefold_verifier(
         NovaVerificationMode::Explicit,
-        nova.z_0.len(),
-    );
-
-    let calldata: Vec<u8> = prepare_calldata(
-        function_selector,
         nova.i,
         nova.z_0,
         nova.z_i,
diff --git a/examples/full_flow.rs b/examples/full_flow.rs
@@ -22,18 +22,15 @@ use std::time::Instant;
 use folding_schemes::{
     commitment::{kzg::KZG, pedersen::Pedersen},
     folding::{
-        nova::{
-            decider_eth::{prepare_calldata, Decider as DeciderEth},
-            Nova, PreprocessorParam,
-        },
+        nova::{decider_eth::Decider as DeciderEth, Nova, PreprocessorParam},
         traits::CommittedInstanceOps,
     },
     frontend::FCircuit,
     transcript::poseidon::poseidon_canonical_config,
     Decider, Error, FoldingScheme,
 };
 use solidity_verifiers::calldata::{
-    get_function_selector_for_nova_cyclefold_verifier, NovaVerificationMode,
+    prepare_calldata_for_nova_cyclefold_verifier, NovaVerificationMode,
 };
 use solidity_verifiers::{
     evm::{compile_solidity, Evm},
@@ -120,13 +117,8 @@ fn main() -> Result<(), Error> {
     println!("Decider proof verification: {}", verified);
 
     // Now, let's generate the Solidity code that verifies this Decider final proof
-    let function_selector = get_function_selector_for_nova_cyclefold_verifier(
+    let calldata: Vec<u8> = prepare_calldata_for_nova_cyclefold_verifier(
         NovaVerificationMode::Explicit,
-        nova.z_0.len(),
-    );
-
-    let calldata: Vec<u8> = prepare_calldata(
-        function_selector,
         nova.i,
         nova.z_0,
         nova.z_i,
diff --git a/examples/noir_full_flow.rs b/examples/noir_full_flow.rs
@@ -18,10 +18,7 @@ use experimental_frontends::{noir::NoirFCircuit, utils::VecF};
 use folding_schemes::{
     commitment::{kzg::KZG, pedersen::Pedersen},
     folding::{
-        nova::{
-            decider_eth::{prepare_calldata, Decider as DeciderEth},
-            Nova, PreprocessorParam,
-        },
+        nova::{decider_eth::Decider as DeciderEth, Nova, PreprocessorParam},
         traits::CommittedInstanceOps,
     },
     frontend::FCircuit,
@@ -31,7 +28,7 @@ use folding_schemes::{
 use std::{path::Path, time::Instant};
 
 use solidity_verifiers::calldata::{
-    get_function_selector_for_nova_cyclefold_verifier, NovaVerificationMode,
+    prepare_calldata_for_nova_cyclefold_verifier, NovaVerificationMode,
 };
 use solidity_verifiers::{
     evm::{compile_solidity, Evm},
@@ -107,13 +104,8 @@ fn main() -> Result<(), Error> {
     println!("Decider proof verification: {}", verified);
 
     // Now, let's generate the Solidity code that verifies this Decider final proof
-    let function_selector = get_function_selector_for_nova_cyclefold_verifier(
+    let calldata: Vec<u8> = prepare_calldata_for_nova_cyclefold_verifier(
         NovaVerificationMode::Explicit,
-        nova.z_0.len(),
-    );
-
-    let calldata: Vec<u8> = prepare_calldata(
-        function_selector,
         nova.i,
         nova.z_0,
         nova.z_i,
diff --git a/examples/noname_full_flow.rs b/examples/noname_full_flow.rs
@@ -19,10 +19,7 @@ use experimental_frontends::{noname::NonameFCircuit, utils::VecF};
 use folding_schemes::{
     commitment::{kzg::KZG, pedersen::Pedersen},
     folding::{
-        nova::{
-            decider_eth::{prepare_calldata, Decider as DeciderEth},
-            Nova, PreprocessorParam,
-        },
+        nova::{decider_eth::Decider as DeciderEth, Nova, PreprocessorParam},
         traits::CommittedInstanceOps,
     },
     frontend::FCircuit,
@@ -32,7 +29,7 @@ use folding_schemes::{
 use std::time::Instant;
 
 use solidity_verifiers::calldata::{
-    get_function_selector_for_nova_cyclefold_verifier, NovaVerificationMode,
+    prepare_calldata_for_nova_cyclefold_verifier, NovaVerificationMode,
 };
 use solidity_verifiers::{
     evm::{compile_solidity, Evm},
@@ -128,13 +125,8 @@ fn main() -> Result<(), Error> {
     println!("Decider proof verification: {}", verified);
 
     // Now, let's generate the Solidity code that verifies this Decider final proof
-    let function_selector = get_function_selector_for_nova_cyclefold_verifier(
+    let calldata: Vec<u8> = prepare_calldata_for_nova_cyclefold_verifier(
         NovaVerificationMode::Explicit,
-        nova.z_0.len(),
-    );
-
-    let calldata: Vec<u8> = prepare_calldata(
-        function_selector,
         nova.i,
         nova.z_0,
         nova.z_i,
diff --git a/folding-schemes/src/folding/nova/decider_eth.rs b/folding-schemes/src/folding/nova/decider_eth.rs
@@ -2,8 +2,6 @@
 /// the Decider from decider.rs file will be more efficient.
 /// More details can be found at the documentation page:
 /// https://privacy-scaling-explorations.github.io/sonobe-docs/design/nova-decider-onchain.html
-use ark_bn254::Bn254;
-use ark_groth16::Groth16;
 use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
 use ark_snark::SNARK;
 use ark_std::{
@@ -14,17 +12,12 @@ use core::marker::PhantomData;
 
 pub use super::decider_eth_circuit::DeciderEthCircuit;
 use super::decider_eth_circuit::DeciderNovaGadget;
-use super::{CommittedInstance, Nova};
+use super::Nova;
 use crate::folding::circuits::decider::DeciderEnabledNIFS;
 use crate::folding::traits::{InputizeNonNative, WitnessOps};
 use crate::frontend::FCircuit;
-use crate::utils::eth::ToEth;
 use crate::{
-    commitment::{
-        kzg::{Proof as KZGProof, KZG},
-        pedersen::Params as PedersenParams,
-        CommitmentScheme,
-    },
+    commitment::{kzg::Proof as KZGProof, pedersen::Params as PedersenParams, CommitmentScheme},
     folding::traits::Dummy,
 };
 use crate::{Curve, Error};
@@ -48,6 +41,33 @@ where
     kzg_challenges: [C::ScalarField; 2],
 }
 
+impl<C, CS, S> Proof<C, CS, S>
+where
+    C: Curve,
+    CS: CommitmentScheme<C, ProverChallenge = C::ScalarField, Challenge = C::ScalarField>,
+    S: SNARK<C::ScalarField>,
+{
+    pub fn snark_proof(&self) -> &S::Proof {
+        &self.snark_proof
+    }
+
+    pub fn kzg_proofs(&self) -> &[CS::Proof; 2] {
+        &self.kzg_proofs
+    }
+
+    pub fn cmT(&self) -> &C {
+        &self.cmT
+    }
+
+    pub fn r(&self) -> C::ScalarField {
+        self.r
+    }
+
+    pub fn kzg_challenges(&self) -> [C::ScalarField; 2] {
+        self.kzg_challenges
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq, CanonicalSerialize, CanonicalDeserialize)]
 pub struct VerifierParam<C1, CS_VerifyingKey, S_VerifyingKey>
 where
@@ -244,49 +264,19 @@ where
     }
 }
 
-/// Prepares solidity calldata for calling the NovaDecider contract
-#[allow(clippy::too_many_arguments)]
-pub fn prepare_calldata(
-    function_signature_check: [u8; 4],
-    i: ark_bn254::Fr,
-    z_0: Vec<ark_bn254::Fr>,
-    z_i: Vec<ark_bn254::Fr>,
-    running_instance: &CommittedInstance<ark_bn254::G1Projective>,
-    incoming_instance: &CommittedInstance<ark_bn254::G1Projective>,
-    proof: &Proof<ark_bn254::G1Projective, KZG<Bn254>, Groth16<Bn254>>,
-) -> Result<Vec<u8>, Error> {
-    Ok([
-        function_signature_check.to_eth(),
-        i.to_eth(),   // i
-        z_0.to_eth(), // z_0
-        z_i.to_eth(), // z_i
-        running_instance.cmW.to_eth(),
-        running_instance.cmE.to_eth(),
-        incoming_instance.cmW.to_eth(),
-        proof.cmT.to_eth(),                 // cmT
-        proof.r.to_eth(),                   // r
-        proof.snark_proof.to_eth(),         // pA, pB, pC
-        proof.kzg_challenges.to_eth(),      // challenge_W, challenge_E
-        proof.kzg_proofs[0].eval.to_eth(),  // eval W
-        proof.kzg_proofs[1].eval.to_eth(),  // eval E
-        proof.kzg_proofs[0].proof.to_eth(), // W kzg_proof
-        proof.kzg_proofs[1].proof.to_eth(), // E kzg_proof
-    ]
-    .concat())
-}
-
 #[cfg(test)]
 pub mod tests {
-    use ark_bn254::{Fr, G1Projective as Projective};
-    use ark_grumpkin::Projective as Projective2;
-    use std::time::Instant;
-
     use super::*;
+    use crate::commitment::kzg::KZG;
     use crate::commitment::pedersen::Pedersen;
     use crate::folding::nova::{PreprocessorParam, ProverParams as NovaProverParams};
     use crate::folding::traits::CommittedInstanceOps;
     use crate::frontend::utils::CubicFCircuit;
     use crate::transcript::poseidon::poseidon_canonical_config;
+    use ark_bn254::{Bn254, Fr, G1Projective as Projective};
+    use ark_groth16::Groth16;
+    use ark_grumpkin::Projective as Projective2;
+    use std::time::Instant;
 
     #[test]
     fn test_decider() -> Result<(), Error> {
diff --git a/folding-schemes/src/lib.rs b/folding-schemes/src/lib.rs
@@ -4,7 +4,6 @@
 
 use ark_crypto_primitives::sponge::Absorb;
 use ark_ec::{
-    pairing::Pairing,
     short_weierstrass::{Projective, SWCurveConfig},
     CurveGroup,
 };
@@ -287,26 +286,6 @@ pub trait Decider<
     ) -> Result<bool, Error>;
 }
 
-/// DeciderOnchain extends the Decider into preparing the calldata
-pub trait DeciderOnchain<
-    E: Pairing,
-    C1: Curve<BaseField = C2::ScalarField, ScalarField = C2::BaseField>,
-    C2: Curve,
->
-{
-    type Proof;
-    type CommittedInstance: Clone + Debug;
-
-    fn prepare_calldata(
-        i: C1::ScalarField,
-        z_0: Vec<C1::ScalarField>,
-        z_i: Vec<C1::ScalarField>,
-        running_instance: &Self::CommittedInstance,
-        incoming_instance: &Self::CommittedInstance,
-        proof: Self::Proof,
-    ) -> Result<Vec<u8>, Error>;
-}
-
 /// `Field` trait is a wrapper around `PrimeField` that also includes the
 /// necessary bounds for the field to be used conveniently in folding schemes.
 pub trait Field:
diff --git a/folding-schemes/src/utils/mod.rs b/folding-schemes/src/utils/mod.rs
@@ -11,7 +11,6 @@ use crate::arith::ArithSerializer;
 use crate::commitment::CommitmentScheme;
 use crate::{Curve, Error};
 
-pub mod eth;
 pub mod gadgets;
 pub mod hypercube;
 pub mod lagrange_poly;
diff --git a/solidity-verifiers/Cargo.toml b/solidity-verifiers/Cargo.toml
@@ -6,6 +6,8 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
+ark-ec = { workspace = true }
+ark-ff = { workspace = true }
 ark-groth16 = { workspace = true }
 ark-bn254 = { workspace = true, features = ["r1cs"] }
 ark-poly-commit = { workspace = true }
diff --git a/solidity-verifiers/src/calldata.rs b/solidity-verifiers/src/calldata.rs
@@ -1,5 +1,12 @@
+use crate::utils::eth::ToEth;
+use ark_bn254::Bn254;
+use ark_groth16::Groth16;
 use crypto::digest::Digest;
 use crypto::sha3::Sha3;
+use folding_schemes::commitment::kzg::KZG;
+use folding_schemes::folding::nova::decider_eth::Proof;
+use folding_schemes::folding::nova::CommittedInstance;
+use folding_schemes::Error;
 use num_bigint::BigUint;
 
 /// Specifies which API to use for a proof verification in a contract.
@@ -26,12 +33,41 @@ pub fn get_formatted_calldata(calldata: Vec<u8>) -> Vec<String> {
     formatted_calldata
 }
 
+/// Prepares solidity calldata for calling the NovaDecider contract
+pub fn prepare_calldata_for_nova_cyclefold_verifier(
+    verification_mode: NovaVerificationMode,
+    i: ark_bn254::Fr,
+    z_0: Vec<ark_bn254::Fr>,
+    z_i: Vec<ark_bn254::Fr>,
+    running_instance: &CommittedInstance<ark_bn254::G1Projective>,
+    incoming_instance: &CommittedInstance<ark_bn254::G1Projective>,
+    proof: &Proof<ark_bn254::G1Projective, KZG<Bn254>, Groth16<Bn254>>,
+) -> Result<Vec<u8>, Error> {
+    let selector = get_function_selector(verification_mode, z_0.len());
+
+    Ok([
+        selector.to_eth(),
+        i.to_eth(),   // i
+        z_0.to_eth(), // z_0
+        z_i.to_eth(), // z_i
+        running_instance.cmW.to_eth(),
+        running_instance.cmE.to_eth(),
+        incoming_instance.cmW.to_eth(),
+        proof.cmT().to_eth(),                 // cmT
+        proof.r().to_eth(),                   // r
+        proof.snark_proof().to_eth(),         // pA, pB, pC
+        proof.kzg_challenges().to_eth(),      // challenge_W, challenge_E
+        proof.kzg_proofs()[0].eval.to_eth(),  // eval W
+        proof.kzg_proofs()[1].eval.to_eth(),  // eval E
+        proof.kzg_proofs()[0].proof.to_eth(), // W kzg_proof
+        proof.kzg_proofs()[1].proof.to_eth(), // E kzg_proof
+    ]
+    .concat())
+}
+
 /// Computes the function selector for the nova cyclefold verifier.
 /// It is computed on the fly since it depends on the IVC state length.
-pub fn get_function_selector_for_nova_cyclefold_verifier(
-    mode: NovaVerificationMode,
-    state_len: usize,
-) -> [u8; 4] {
+fn get_function_selector(mode: NovaVerificationMode, state_len: usize) -> [u8; 4] {
     let fn_sig = match mode {
         NovaVerificationMode::Explicit =>
             format!(
diff --git a/solidity-verifiers/src/utils/eth.rs b/solidity-verifiers/src/utils/eth.rs
diff --git a/solidity-verifiers/src/utils/mod.rs b/solidity-verifiers/src/utils/mod.rs
@@ -2,6 +2,7 @@ use crate::{GPL3_SDPX_IDENTIFIER, PRAGMA_GROTH16_VERIFIER};
 use askama::Template;
 
 pub mod encoding;
+pub mod eth;
 
 #[derive(Template)]
 #[template(path = "header_template.askama.sol", ext = "sol")]
diff --git a/solidity-verifiers/src/verifiers/nova_cyclefold.rs b/solidity-verifiers/src/verifiers/nova_cyclefold.rs
