Split Params into base and developer-defined (#458)

I thought it would be nice to have a Predicate for the typed value so that the developer can work with predicates as values comfortably.  Then I noticed that hashing a predicate required `Params` which would have been annoying for converting a `TypedValue::Predicate` to `RawValue` and this led to a small refactor over how `Params` work.

We already had some fields in the `Params` struct that determine compatibility between encoded data.  They can be seen as determining a kind of ABI compatibility.  In general it's better if those parameters don't change so that different circuit configurations can still verify proofs from each other.  So I decided to force those parameters to be constant in the code base and not allow the user of our library to change them.  Many field element serialization/deserialization functions in our code depended on those parameters, and since now they are constant many functions get rid of the `Params` argument, which simplifies the code.  This includes the serialization of a `Predicate` which was required to calculate its hash.

Author: ed255

src/backends/plonky2/circuits/common.rs

@@ -67,11 +67,9 @@ fn verify_empty_pod_circuit(
     builder: &mut CircuitBuilder,
     empty_pod: &EmptyPodVerifyTarget,
 ) {
-    let empty_statement = StatementTarget::from_flattened(
-        params,
-        &builder.constants(&empty_statement().to_fields(params)),
-    );
-    let sts_hash = calculate_statements_hash_circuit(params, builder, &[empty_statement]);
+    let empty_statement =
+        StatementTarget::from_flattened(params, &builder.constants(&empty_statement().to_fields()));
+    let sts_hash = calculate_statements_hash_circuit(builder, &[empty_statement]);
     builder.register_public_inputs(&sts_hash.elements);
     builder.register_public_inputs(&empty_pod.vds_root.elements);
 }
@@ -126,7 +124,7 @@ fn build() -> Result<(EmptyPodVerifyTarget, CircuitData)> {
 }
 
 impl EmptyPod {
-    fn new(params: &Params, vd_set: VDSet) -> Result<EmptyPod> {
+    fn new(vd_set: VDSet) -> Result<EmptyPod> {
         let (empty_pod_verify_target, data) = &*cache_get_standard_empty_pod_circuit_data();
 
         let mut pw = PartialWitness::<F>::new();
@@ -139,23 +137,18 @@ impl EmptyPod {
         };
         let common_hash = hash_common_data(&data.common).expect("hash ok");
         Ok(EmptyPod {
-            params: params.clone(),
+            params: Params::default(),
             verifier_only: VerifierOnlyCircuitDataSerializer(data.verifier_only.clone()),
             common_hash,
             sts_hash,
             vd_set,
             proof: proof.proof,
         })
     }
-    pub fn new_boxed(params: &Params, vd_set: VDSet) -> Box<dyn Pod> {
-        let default_params = Params::default();
-        assert_eq!(default_params.id_params(), params.id_params());
-
-        let empty_pod = cache::get(
-            "empty_pod",
-            &(default_params, vd_set),
-            |(params, vd_set)| Self::new(params, vd_set.clone()).expect("prove EmptyPod"),
-        )
+    pub fn new_boxed(vd_set: VDSet) -> Box<dyn Pod> {
+        let empty_pod = cache::get("empty_pod", &vd_set, |vd_set| {
+            Self::new(vd_set.clone()).expect("prove EmptyPod")
+        })
         .expect("cache ok");
         Box::new(empty_pod.clone())
     }
@@ -178,13 +171,13 @@ impl Pod for EmptyPod {
             .into_iter()
             .map(mainpod::Statement::from)
             .collect_vec();
-        let sts_hash = calculate_statements_hash(&statements, &self.params);
+        let sts_hash = calculate_statements_hash(&statements);
         if sts_hash != self.sts_hash {
             return Err(Error::statements_hash_not_equal(self.sts_hash, sts_hash));
         }
 
         let public_inputs = sts_hash
-            .to_fields(&self.params)
+            .to_fields()
             .iter()
             .chain(self.vd_set.root().0.iter())
             .cloned()
@@ -258,9 +251,7 @@ pub mod tests {
 
     #[test]
     fn test_empty_pod() {
-        let params = Params::default();
-
-        let empty_pod = EmptyPod::new_boxed(&params, VDSet::new(&[]));
+        let empty_pod = EmptyPod::new_boxed(VDSet::new(&[]));
         empty_pod.verify().unwrap();
     }
 }

src/backends/plonky2/circuits/mainpod.rs

@@ -50,21 +50,20 @@ use crate::{
 /// circuits with a small `max_public_statements` only pay for `max_public_statements` by starting
 /// the poseidon state with a precomputed constant corresponding to the front-padding part: `id =
 /// hash(serialize(reverse(statements || none-statements)))`
-pub fn calculate_statements_hash(statements: &[Statement], params: &Params) -> middleware::Hash {
-    assert!(statements.len() <= params.num_public_statements_hash);
-    assert!(params.max_public_statements <= params.num_public_statements_hash);
+pub fn calculate_statements_hash(statements: &[Statement]) -> middleware::Hash {
+    assert!(statements.len() <= Params::num_public_statements_hash());
 
     let mut none_st: Statement = middleware::Statement::None.into();
-    pad_statement(params, &mut none_st);
+    pad_statement(&mut none_st);
     let statements_back_padded = statements
         .iter()
         .chain(iter::repeat(&none_st))
-        .take(params.num_public_statements_hash)
+        .take(Params::num_public_statements_hash())
         .collect_vec();
     let field_elems = statements_back_padded
         .iter()
         .rev()
-        .flat_map(|statement| statement.to_fields(params))
+        .flat_map(|statement| statement.to_fields())
         .collect::<Vec<_>>();
     Hash(PoseidonHash::hash_no_pad(&field_elems).elements)
 }
@@ -115,7 +114,7 @@ pub(crate) fn extract_custom_predicate_verifications(
                     .find_map(|(i, cpb)| (cpb.id() == cpr.batch.id()).then_some(i))
                     .expect("find the custom predicate from the extracted unique list");
                 let custom_predicate_table_index =
-                    batch_index * params.max_custom_batch_size + cpr.index;
+                    batch_index * Params::max_custom_batch_size() + cpr.index;
                 aux_list[i] = OperationAux::CustomPredVerifyIndex(table.len());
                 table.push(CustomPredicateVerification {
                     custom_predicate_table_index,
@@ -326,8 +325,8 @@ fn fill_pad<T: Clone>(v: &mut Vec<T>, pad_value: T, len: usize) {
     }
 }
 
-pub fn pad_statement(params: &Params, s: &mut Statement) {
-    fill_pad(&mut s.1, StatementArg::None, params.max_statement_args)
+pub fn pad_statement(s: &mut Statement) {
+    fill_pad(&mut s.1, StatementArg::None, Params::max_statement_args())
 }
 
 fn pad_operation_args(params: &Params, args: &mut Vec<OperationArg>) {
@@ -353,7 +352,7 @@ pub(crate) fn layout_statements(
         // We mocking or we don't need padding so we skip creating an EmptyPod
         MockEmptyPod::new_boxed(params, inputs.vd_set.clone())
     } else {
-        EmptyPod::new_boxed(params, inputs.vd_set.clone())
+        EmptyPod::new_boxed(inputs.vd_set.clone())
     };
     let empty_pod = empty_pod_box.as_ref();
     assert!(inputs.pods.len() <= params.max_input_pods);
@@ -367,7 +366,7 @@ pub(crate) fn layout_statements(
                 .unwrap_or(&middleware::Statement::None)
                 .clone()
                 .into();
-            pad_statement(params, &mut st);
+            pad_statement(&mut st);
             statements.push(st);
         }
     }
@@ -386,7 +385,7 @@ pub(crate) fn layout_statements(
             .unwrap_or(&middleware::Statement::None)
             .clone()
             .into();
-        pad_statement(params, &mut st);
+        pad_statement(&mut st);
         statements.push(st);
     }
 
@@ -399,7 +398,7 @@ pub(crate) fn layout_statements(
             .unwrap_or(&middleware::Statement::None)
             .clone()
             .into();
-        pad_statement(params, &mut st);
+        pad_statement(&mut st);
         statements.push(st);
     }
 
@@ -475,7 +474,7 @@ impl MainPodProver for Prover {
             // We don't need padding so we skip creating an EmptyPod
             MockEmptyPod::new_boxed(params, inputs.vd_set.clone())
         } else {
-            EmptyPod::new_boxed(params, inputs.vd_set.clone())
+            EmptyPod::new_boxed(inputs.vd_set.clone())
         };
         let inputs = MainPodInputs {
             pods: &inputs
@@ -491,10 +490,7 @@ impl MainPodProver for Prover {
         let input_pods_pub_self_statements = inputs
             .pods
             .iter()
-            .map(|pod| {
-                assert_eq!(params.id_params(), pod.params().id_params());
-                pod.pub_self_statements()
-            })
+            .map(|pod| pod.pub_self_statements())
             .collect_vec();
 
         // Aux values for backend::Operation
@@ -527,7 +523,7 @@ impl MainPodProver for Prover {
         let operations = process_public_statements_operations(params, &statements, operations)?;
 
         // get the id out of the public statements
-        let sts_hash = calculate_statements_hash(&public_statements, params);
+        let sts_hash = calculate_statements_hash(&public_statements);
 
         let common_hash: String = cache_get_rec_main_pod_common_hash(params).clone();
         let proofs = inputs
@@ -718,7 +714,7 @@ impl Pod for MainPod {
             )));
         }
         // 2. get the id out of the public statements
-        let sts_hash = calculate_statements_hash(&self.public_statements, &self.params);
+        let sts_hash = calculate_statements_hash(&self.public_statements);
         if sts_hash != self.sts_hash {
             return Err(Error::statements_hash_not_equal(self.sts_hash, sts_hash));
         }
@@ -738,7 +734,7 @@ impl Pod for MainPod {
         let rec_main_pod_verifier_circuit_data =
             &*cache_get_rec_main_pod_verifier_circuit_data(&self.params);
         let public_inputs = sts_hash
-            .to_fields(&self.params)
+            .to_fields()
             .iter()
             .chain(self.vd_set.root().0.iter())
             .cloned()
@@ -998,14 +994,10 @@ pub mod tests {
             max_input_pods_public_statements: 2,
             max_statements: 5,
             max_public_statements: 2,
-            num_public_statements_hash: 4,
-            max_statement_args: 4,
-            max_operation_args: 4,
+            max_operation_args: 5,
             max_custom_predicate_batches: 2,
             max_custom_predicate_verifications: 2,
-            max_custom_predicate_arity: 2,
             max_custom_predicate_wildcards: 3,
-            max_custom_batch_size: 2,
             max_merkle_proofs_containers: 2,
             max_merkle_tree_state_transition_proofs_containers: 2,
             max_public_key_of: 2,
@@ -1067,10 +1059,7 @@ pub mod tests {
             max_input_pods: 0,
             max_statements: 9,
             max_public_statements: 4,
-            max_statement_args: 4,
-            max_operation_args: 4,
-            max_custom_predicate_arity: 3,
-            max_custom_batch_size: 3,
+            max_operation_args: 5,
             max_custom_predicate_wildcards: 4,
             max_custom_predicate_verifications: 2,
             max_merkle_proofs_containers: 3,

src/backends/plonky2/emptypod.rs

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     backends::plonky2::error::{Error, Result},
-    middleware::{self, NativePredicate, Params, Predicate, StatementArg, ToFields, Value},
+    middleware::{self, NativePredicate, Predicate, StatementArg, ToFields, Value, BASE_PARAMS},
 };
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -30,14 +30,14 @@ impl Statement {
 }
 
 impl ToFields for Statement {
-    fn to_fields(&self, params: &Params) -> Vec<middleware::F> {
-        let mut fields = self.0.hash(params).to_fields(params);
+    fn to_fields(&self) -> Vec<middleware::F> {
+        let mut fields = self.0.hash().to_fields();
         fields.extend(
             self.1
                 .iter()
                 .chain(iter::repeat(&StatementArg::None))
-                .take(params.max_statement_args)
-                .flat_map(|arg| arg.to_fields(params)),
+                .take(BASE_PARAMS.max_statement_args)
+                .flat_map(|arg| arg.to_fields()),
         );
         fields
     }

src/backends/plonky2/mainpod/mod.rs

@@ -30,7 +30,7 @@ fn empty_statement() -> Statement {
 impl MockEmptyPod {
     pub fn new_boxed(params: &Params, vd_set: VDSet) -> Box<dyn Pod> {
         let statements = [mainpod::Statement::from(empty_statement())];
-        let sts_hash = calculate_statements_hash(&statements, params);
+        let sts_hash = calculate_statements_hash(&statements);
         Box::new(Self {
             params: params.clone(),
             sts_hash,
@@ -49,7 +49,7 @@ impl Pod for MockEmptyPod {
             .into_iter()
             .map(mainpod::Statement::from)
             .collect_vec();
-        let sts_hash = calculate_statements_hash(&statements, &self.params);
+        let sts_hash = calculate_statements_hash(&statements);
         if sts_hash != self.sts_hash {
             return Err(Error::statements_hash_not_equal(self.sts_hash, sts_hash));
         }

src/backends/plonky2/mainpod/statement.rs

@@ -167,7 +167,7 @@ impl MockMainPod {
         let operations = process_public_statements_operations(params, &statements, operations)?;
 
         // get the id out of the public statements
-        let sts_hash = calculate_statements_hash(&public_statements, params);
+        let sts_hash = calculate_statements_hash(&public_statements);
 
         let pad_pod = MockEmptyPod::new_boxed(params, inputs.vd_set.clone());
         let input_pods: Vec<Box<dyn Pod>> = inputs

src/backends/plonky2/mock/emptypod.rs

@@ -258,21 +258,21 @@ pub fn great_boy_pod_builder(
 
     let mut great_boy = MainPodBuilder::new(params, vd_set);
     for good_boy_signed_dict in good_boy_signed_dicts {
-        great_boy.pub_op(Operation::dict_signed_by(good_boy_signed_dict))?;
+        great_boy.priv_op(Operation::dict_signed_by(good_boy_signed_dict))?;
     }
     for friend_signed_dict in friend_signed_dicts {
-        great_boy.pub_op(Operation::dict_signed_by(friend_signed_dict))?;
+        great_boy.priv_op(Operation::dict_signed_by(friend_signed_dict))?;
     }
 
     for good_boy_idx in 0..2 {
         for issuer_idx in 0..2 {
             // Each good boy POD comes from a valid issuer
-            great_boy.pub_op(Operation::set_contains(
+            great_boy.priv_op(Operation::set_contains(
                 good_boy_issuers,
                 good_boy_signed_dicts[good_boy_idx * 2 + issuer_idx].public_key,
             ))?;
             // Each good boy has 2 good boy pods
-            great_boy.pub_op(Operation::eq(
+            great_boy.priv_op(Operation::eq(
                 (good_boy_signed_dicts[good_boy_idx * 2 + issuer_idx], "user"),
                 friend_signed_dicts[good_boy_idx].public_key,
             ))?;
@@ -302,8 +302,6 @@ pub fn great_boy_pod_full_flow() -> Result<MainPodBuilder> {
         max_signed_by: 6,
         max_input_pods: 0,
         max_statements: 100,
-        max_public_statements: 50,
-        num_public_statements_hash: 50,
         ..Default::default()
     };
     let vd_set = &*MOCK_VD_SET;

src/backends/plonky2/mock/mainpod.rs

@@ -171,19 +171,19 @@ impl CustomPredicateBatchBuilder {
         priv_args: &[&str],
         sts: &[StatementTmplBuilder],
     ) -> Result<Predicate> {
-        if self.predicates.len() >= self.params.max_custom_batch_size {
+        if self.predicates.len() >= Params::max_custom_batch_size() {
             return Err(Error::max_length(
                 "self.predicates.len".to_string(),
                 self.predicates.len(),
-                self.params.max_custom_batch_size,
+                Params::max_custom_batch_size(),
             ));
         }
 
-        if args.len() > self.params.max_statement_args {
+        if args.len() > Params::max_statement_args() {
             return Err(Error::max_length(
                 "args.len".to_string(),
                 args.len(),
-                self.params.max_statement_args,
+                Params::max_statement_args(),
             ));
         }
         if (args.len() + priv_args.len()) > self.params.max_custom_predicate_wildcards {
@@ -278,7 +278,6 @@ mod tests {
         use StatementTmplBuilder as STB;
 
         let params = Params {
-            max_statement_args: 6,
             max_custom_predicate_wildcards: 12,
             ..Default::default()
         };
@@ -292,7 +291,7 @@ mod tests {
 
         let eth_dos_batch_mw: middleware::CustomPredicateBatch =
             Arc::unwrap_or_clone(eth_dos_batch);
-        let fields = eth_dos_batch_mw.to_fields(&params);
+        let fields = eth_dos_batch_mw.to_fields();
         println!("Batch b, serialized: {:?}", fields);
 
         Ok(())

src/examples/mod.rs

@@ -600,7 +600,7 @@ impl MainPodBuilder {
                     }
                     wildcard_map[index] = Some(value);
                 }
-                fill_wildcard_values(&self.params, pred, &args, &mut wildcard_map)?;
+                fill_wildcard_values(pred, &args, &mut wildcard_map)?;
                 let v_default = Value::from(0);
                 let st_args: Vec<_> = wildcard_map
                     .into_iter()