Resolve issue from merge: pass params to check()

Author: tideofwords

src/backends/plonky2/mock_main/mod.rs

@@ -507,7 +507,7 @@ pub mod tests {
             zu_kyc_pod_builder(&params, &gov_id_pod, &pay_stub_pod, &sanction_list_pod)?;
 
         let mut prover = MockProver {};
-        let kyc_pod = kyc_builder.prove(&mut prover)?;
+        let kyc_pod = kyc_builder.prove(&mut prover, &params)?;
         let pod = kyc_pod.pod.into_any().downcast::<MockMainPod>().unwrap();
 
         println!("{:#}", pod);
@@ -520,10 +520,11 @@ pub mod tests {
 
     #[test]
     fn test_mock_main_great_boy() -> Result<()> {
+        let params = middleware::Params::default();
         let great_boy_builder = great_boy_pod_full_flow()?;
 
         let mut prover = MockProver {};
-        let great_boy_pod = great_boy_builder.prove(&mut prover)?;
+        let great_boy_pod = great_boy_builder.prove(&mut prover, &params)?;
         let pod = great_boy_pod
             .pod
             .into_any()
@@ -539,9 +540,10 @@ pub mod tests {
 
     #[test]
     fn test_mock_main_tickets() -> Result<()> {
+        let params = middleware::Params::default();
         let tickets_builder = tickets_pod_full_flow()?;
         let mut prover = MockProver {};
-        let proof_pod = tickets_builder.prove(&mut prover)?;
+        let proof_pod = tickets_builder.prove(&mut prover, &params)?;
         let pod = proof_pod.pod.into_any().downcast::<MockMainPod>().unwrap();
 
         println!("{}", pod);

src/frontend/mod.rs

@@ -348,7 +348,7 @@ impl MainPodBuilder {
         self.public_statements.push(st.clone());
     }
 
-    pub fn prove<P: PodProver>(&self, prover: &mut P) -> Result<MainPod> {
+    pub fn prove<P: PodProver>(&self, prover: &mut P, params: &Params) -> Result<MainPod> {
         let compiler = MainPodCompiler::new(&self.params);
         let inputs = MainPodCompilerInputs {
             // signed_pods: &self.input_signed_pods,
@@ -357,7 +357,7 @@ impl MainPodBuilder {
             operations: &self.operations,
             public_statements: &self.public_statements,
         };
-        let (statements, operations, public_statements) = compiler.compile(inputs)?;
+        let (statements, operations, public_statements) = compiler.compile(inputs, params)?;
 
         let inputs = MainPodInputs {
             signed_pods: &self.input_signed_pods.iter().map(|p| &p.pod).collect_vec(),
@@ -462,10 +462,10 @@ impl MainPodCompiler {
         middleware::Operation::op(mop_code, &mop_args).unwrap()
     }
 
-    fn compile_st_op(&mut self, st: &Statement, op: &Operation) -> Result<()> {
+    fn compile_st_op(&mut self, st: &Statement, op: &Operation, params: &Params) -> Result<()> {
         let middle_st = self.compile_st(st);
         let middle_op = self.compile_op(op);
-        let is_correct = middle_op.check(&middle_st)?;
+        let is_correct = middle_op.check(params, &middle_st)?;
         if !is_correct {
             // todo: improve error handling
             Err(anyhow!(
@@ -482,6 +482,7 @@ impl MainPodCompiler {
     pub fn compile<'a>(
         mut self,
         inputs: MainPodCompilerInputs<'a>,
+        params: &Params,
     ) -> Result<(
         Vec<middleware::Statement>, // input statements
         Vec<middleware::Operation>,
@@ -495,7 +496,7 @@ impl MainPodCompiler {
             public_statements,
         } = inputs;
         for (st, op) in statements.iter().zip_eq(operations.iter()) {
-            self.compile_st_op(st, op)?;
+            self.compile_st_op(st, op, params)?;
             if self.statements.len() > self.params.max_statements {
                 panic!("too many statements");
             }
@@ -581,7 +582,7 @@ pub mod tests {
         println!("{}", kyc);
 
         let mut prover = MockProver {};
-        let kyc = kyc.prove(&mut prover)?;
+        let kyc = kyc.prove(&mut prover, &params)?;
 
         // TODO: prove kyc with MockProver and print it
         println!("{}", kyc);
@@ -627,7 +628,7 @@ pub mod tests {
         builder.pub_op(op!(gt, (&pod, "num"), 5));
 
         let mut prover = MockProver {};
-        let false_pod = builder.prove(&mut prover).unwrap();
+        let false_pod = builder.prove(&mut prover, &params).unwrap();
 
         println!("{}", builder);
         println!("{}", false_pod);