Change the nomenclature of "params" to "instance" to match the sigma_rs crate

sigma_compiler_core/Cargo.toml

@@ -9,7 +9,7 @@ quote = "1.0"
 proc-macro2 = "1.0"
 
 [features]
-# Dump (to stdout) the public params on both the prover's and verifier's
-# side.  They should match.
+# Dump (to stdout) the value of the instance on both the prover's and
+# verifier's side.  They should match.
 dump = []
 # default = ["dump"]

sigma_compiler_core/src/codegen.rs

@@ -34,15 +34,15 @@ pub struct CodeGen {
     /// be generated by the sigma_compiler itself) that the prover needs
     /// to send to the verifier along with the proof.  These could
     /// include commitments to bits in range proofs, for example.
-    sent_params: StructFieldList,
+    sent_instance: StructFieldList,
     /// Extra code that will be emitted in the `prove` function
     prove_code: TokenStream,
     /// Extra code that will be emitted in the `verify` function
     verify_code: TokenStream,
     /// Extra code that will be emitted in the `verify` function before
-    /// the `sent_params` are deserialized.  This is where the verifier
-    /// sets the lengths of vector variables in the `sent_params`.
-    verify_pre_params_code: TokenStream,
+    /// the `sent_instance` are deserialized.  This is where the verifier
+    /// sets the lengths of vector variables in the `sent_instance`.
+    verify_pre_instance_code: TokenStream,
 }
 
 impl CodeGen {
@@ -76,10 +76,10 @@ impl CodeGen {
             group_name: spec.group_name.clone(),
             vars: spec.vars.clone(),
             unique_prefix: Self::unique_prefix(&spec.vars),
-            sent_params: StructFieldList::default(),
+            sent_instance: StructFieldList::default(),
             prove_code: quote! {},
             verify_code: quote! {},
-            verify_pre_params_code: quote! {},
+            verify_pre_instance_code: quote! {},
         }
     }
 
@@ -91,10 +91,10 @@ impl CodeGen {
             group_name: parse_quote! { G },
             vars: TaggedVarDict::default(),
             unique_prefix: "gen__".into(),
-            sent_params: StructFieldList::default(),
+            sent_instance: StructFieldList::default(),
             prove_code: quote! {},
             verify_code: quote! {},
-            verify_pre_params_code: quote! {},
+            verify_pre_instance_code: quote! {},
         }
     }
 
@@ -125,7 +125,7 @@ impl CodeGen {
         id
     }
 
-    /// Create a new public Point variable to put in the Params,
+    /// Create a new public Point variable to put in the Instance,
     /// optionally marking it as needing to be sent from the prover to
     /// the verifier along with the proof.
     ///
@@ -133,7 +133,7 @@ impl CodeGen {
     /// [`prove_append`](Self::prove_append) with code like `quote!{ let
     /// #id = ... }` where `id` is the [`struct@Ident`] returned from
     /// this function.  If `is_vec` is `true`, then you should also call
-    /// [`verify_pre_params_append`](Self::verify_pre_params_append)
+    /// [`verify_pre_instance_append`](Self::verify_pre_instance_append)
     /// with code like `quote!{ let mut #id = Vec::<Point>::new();
     /// #id.resize(#len, Point::default()); }` where `len` is the number
     /// of elements you expect to have in the vector (computed at
@@ -157,9 +157,9 @@ impl CodeGen {
         );
         if send_to_verifier {
             if is_vec {
-                self.sent_params.push_vecpoint(&id);
+                self.sent_instance.push_vecpoint(&id);
             } else {
-                self.sent_params.push_point(&id);
+                self.sent_instance.push_point(&id);
             }
         }
         id
@@ -189,27 +189,27 @@ impl CodeGen {
     }
 
     /// Append some code to the generated `verify` function to be run
-    /// before the `sent_params` are deserialized
-    pub fn verify_pre_params_append(&mut self, code: TokenStream) {
-        let verify_pre_params_code = &self.verify_pre_params_code;
-        self.verify_pre_params_code = quote! {
-            #verify_pre_params_code
+    /// before the `sent_instance` are deserialized
+    pub fn verify_pre_instance_append(&mut self, code: TokenStream) {
+        let verify_pre_instance_code = &self.verify_pre_instance_code;
+        self.verify_pre_instance_code = quote! {
+            #verify_pre_instance_code
             #code
         };
     }
 
     /// Append some code to both the generated `prove` and `verify`
-    /// functions, the latter to be run before the `sent_params` are
+    /// functions, the latter to be run before the `sent_instance` are
     /// deserialized
-    pub fn prove_verify_pre_params_append(&mut self, code: TokenStream) {
+    pub fn prove_verify_pre_instance_append(&mut self, code: TokenStream) {
         let prove_code = &self.prove_code;
         self.prove_code = quote! {
             #prove_code
             #code
         };
-        let verify_pre_params_code = &self.verify_pre_params_code;
-        self.verify_pre_params_code = quote! {
-            #verify_pre_params_code
+        let verify_pre_instance_code = &self.verify_pre_instance_code;
+        self.verify_pre_instance_code = quote! {
+            #verify_pre_instance_code
             #code
         };
     }
@@ -251,24 +251,24 @@ impl CodeGen {
         );
         let sigma_rs_code = sigma_rs_codegen.generate(emit_prover, emit_verifier);
 
-        let mut pub_params_fields = StructFieldList::default();
-        pub_params_fields.push_vars(&vardict, true);
+        let mut pub_instance_fields = StructFieldList::default();
+        pub_instance_fields.push_vars(&vardict, true);
         let mut witness_fields = StructFieldList::default();
         witness_fields.push_vars(&vardict, false);
 
-        let mut sigma_rs_params_fields = StructFieldList::default();
-        sigma_rs_params_fields.push_vars(&sigma_rs_vardict, true);
+        let mut sigma_rs_instance_fields = StructFieldList::default();
+        sigma_rs_instance_fields.push_vars(&sigma_rs_vardict, true);
         let mut sigma_rs_witness_fields = StructFieldList::default();
         sigma_rs_witness_fields.push_vars(&sigma_rs_vardict, false);
 
-        // Generate the public params struct definition
-        let params_def = {
-            let decls = pub_params_fields.field_decls();
+        // Generate the public instance struct definition
+        let instance_def = {
+            let decls = pub_instance_fields.field_decls();
             #[cfg(feature = "dump")]
             let dump_impl = {
-                let dump_chunks = pub_params_fields.dump();
+                let dump_chunks = pub_instance_fields.dump();
                 quote! {
-                    impl Params {
+                    impl Instance {
                         fn dump_scalar(s: &Scalar) {
                             let bytes: &[u8] = &s.to_repr();
                             print!("{:02x?}", bytes);
@@ -291,7 +291,7 @@ impl CodeGen {
             };
             quote! {
                 #[derive(Clone)]
-                pub struct Params {
+                pub struct Instance {
                     #decls
                 }
 
@@ -314,28 +314,28 @@ impl CodeGen {
 
         // Generate the prove function
         let prove_func = if emit_prover {
-            let params_ids = pub_params_fields.field_list();
+            let instance_ids = pub_instance_fields.field_list();
             let witness_ids = witness_fields.field_list();
-            let sigma_rs_params_ids = sigma_rs_params_fields.field_list();
+            let sigma_rs_instance_ids = sigma_rs_instance_fields.field_list();
             let sigma_rs_witness_ids = sigma_rs_witness_fields.field_list();
             let prove_code = &self.prove_code;
-            let codegen_params_var = format_ident!("{}sigma_params", self.unique_prefix);
+            let codegen_instance_var = format_ident!("{}sigma_instance", self.unique_prefix);
             let codegen_witness_var = format_ident!("{}sigma_witness", self.unique_prefix);
-            let params_var = format_ident!("{}params", self.unique_prefix);
+            let instance_var = format_ident!("{}instance", self.unique_prefix);
             let witness_var = format_ident!("{}witness", self.unique_prefix);
             let rng_var = format_ident!("{}rng", self.unique_prefix);
             let proof_var = format_ident!("{}proof", self.unique_prefix);
             let sid_var = format_ident!("{}session_id", self.unique_prefix);
-            let sent_params_code = {
-                let chunks = self.sent_params.fields.iter().map(|sf| match sf {
+            let sent_instance_code = {
+                let chunks = self.sent_instance.fields.iter().map(|sf| match sf {
                     StructField::Point(id) => quote! {
                         #proof_var.extend(sigma_rs::serialization::serialize_elements(
-                            std::slice::from_ref(&#codegen_params_var.#id)
+                            std::slice::from_ref(&#codegen_instance_var.#id)
                         ));
                     },
                     StructField::VecPoint(id) => quote! {
                         #proof_var.extend(sigma_rs::serialization::serialize_elements(
-                            &#codegen_params_var.#id
+                            &#codegen_instance_var.#id
                         ));
                     },
                     _ => quote! {},
@@ -345,8 +345,8 @@ impl CodeGen {
 
             let dumper = if cfg!(feature = "dump") {
                 quote! {
-                    println!("prover params = {{");
-                    #params_var.dump();
+                    println!("prover instance = {{");
+                    #instance_var.dump();
                     println!("}}");
                 }
             } else {
@@ -355,26 +355,26 @@ impl CodeGen {
 
             quote! {
                 pub fn prove(
-                    #params_var: &Params,
+                    #instance_var: &Instance,
                     #witness_var: &Witness,
                     #sid_var: &[u8],
                     #rng_var: &mut (impl CryptoRng + RngCore),
                 ) -> Result<Vec<u8>, SigmaError> {
                     #dumper
-                    let Params { #params_ids } = #params_var.clone();
+                    let Instance { #instance_ids } = #instance_var.clone();
                     let Witness { #witness_ids } = #witness_var.clone();
                     #prove_code
                     let mut #proof_var = Vec::<u8>::new();
-                    let #codegen_params_var = sigma::Params {
-                        #sigma_rs_params_ids
+                    let #codegen_instance_var = sigma::Instance {
+                        #sigma_rs_instance_ids
                     };
                     let #codegen_witness_var = sigma::Witness {
                         #sigma_rs_witness_ids
                     };
-                    #sent_params_code
+                    #sent_instance_code
                     #proof_var.extend(
                         sigma::prove(
-                            &#codegen_params_var,
+                            &#codegen_instance_var,
                             &#codegen_witness_var,
                             #sid_var,
                             #rng_var,
@@ -389,18 +389,18 @@ impl CodeGen {
 
         // Generate the verify function
         let verify_func = if emit_verifier {
-            let params_ids = pub_params_fields.field_list();
-            let sigma_rs_params_ids = sigma_rs_params_fields.field_list();
-            let verify_pre_params_code = &self.verify_pre_params_code;
+            let instance_ids = pub_instance_fields.field_list();
+            let sigma_rs_instance_ids = sigma_rs_instance_fields.field_list();
+            let verify_pre_instance_code = &self.verify_pre_instance_code;
             let verify_code = &self.verify_code;
-            let codegen_params_var = format_ident!("{}sigma_params", self.unique_prefix);
+            let codegen_instance_var = format_ident!("{}sigma_instance", self.unique_prefix);
             let element_len_var = format_ident!("{}element_len", self.unique_prefix);
             let offset_var = format_ident!("{}proof_offset", self.unique_prefix);
-            let params_var = format_ident!("{}params", self.unique_prefix);
+            let instance_var = format_ident!("{}instance", self.unique_prefix);
             let proof_var = format_ident!("{}proof", self.unique_prefix);
             let sid_var = format_ident!("{}session_id", self.unique_prefix);
-            let sent_params_code = {
-                let element_len_code = if self.sent_params.fields.is_empty() {
+            let sent_instance_code = {
+                let element_len_code = if self.sent_instance.fields.is_empty() {
                     quote! {}
                 } else {
                     quote! {
@@ -409,7 +409,7 @@ impl CodeGen {
                     }
                 };
 
-                let chunks = self.sent_params.fields.iter().map(|sf| match sf {
+                let chunks = self.sent_instance.fields.iter().map(|sf| match sf {
                     StructField::Point(id) => quote! {
                         let #id: Point = sigma_rs::serialization::deserialize_elements(
                                 &#proof_var[#offset_var..],
@@ -436,8 +436,8 @@ impl CodeGen {
 
             let dumper = if cfg!(feature = "dump") {
                 quote! {
-                    println!("verifier params = {{");
-                    #params_var.dump();
+                    println!("verifier instance = {{");
+                    #instance_var.dump();
                     println!("}}");
                 }
             } else {
@@ -446,20 +446,20 @@ impl CodeGen {
 
             quote! {
                 pub fn verify(
-                    #params_var: &Params,
+                    #instance_var: &Instance,
                     #proof_var: &[u8],
                     #sid_var: &[u8],
                 ) -> Result<(), SigmaError> {
                     #dumper
-                    let Params { #params_ids } = #params_var.clone();
-                    #verify_pre_params_code
-                    #sent_params_code
+                    let Instance { #instance_ids } = #instance_var.clone();
+                    #verify_pre_instance_code
+                    #sent_instance_code
                     #verify_code
-                    let #codegen_params_var = sigma::Params {
-                        #sigma_rs_params_ids
+                    let #codegen_instance_var = sigma::Instance {
+                        #sigma_rs_instance_ids
                     };
                     sigma::verify(
-                        &#codegen_params_var,
+                        &#codegen_instance_var,
                         &#proof_var[#offset_var..],
                         #sid_var,
                     )
@@ -493,7 +493,7 @@ impl CodeGen {
 
                 #sigma_rs_code
 
-                #params_def
+                #instance_def
                 #witness_def
                 #prove_func
                 #verify_func

sigma_compiler_core/src/rangeproof.rs

@@ -481,7 +481,7 @@ pub fn transform(
             range_id
         ));
 
-        codegen.prove_verify_pre_params_append(quote! {
+        codegen.prove_verify_pre_instance_append(quote! {
             let #upper_var = #upper_code;
             let #bitrep_scalars_var =
                 sigma_compiler::rangeutils::bitrep_scalars_vartime(#upper_var)?;
@@ -575,7 +575,7 @@ pub fn transform(
         let commit_generator = &ped_assign.pedersen.var_term.id;
         let rand_generator = &ped_assign.pedersen.rand_term.id;
 
-        codegen.verify_pre_params_append(quote! {
+        codegen.verify_pre_instance_append(quote! {
             let mut #bitcomm_var = Vec::<Point>::new();
             #bitcomm_var.resize(#nbits_var - 1, Point::default());
         });

sigma_compiler_core/src/sigma/codegen.rs

@@ -37,11 +37,11 @@ impl StructFieldList {
     pub fn push_vecpoint(&mut self, s: &Ident) {
         self.fields.push(StructField::VecPoint(s.clone()));
     }
-    pub fn push_vars(&mut self, vars: &VarDict, for_params: bool) {
+    pub fn push_vars(&mut self, vars: &VarDict, for_instance: bool) {
         for (id, ti) in vars.iter() {
             match ti {
                 AExprType::Scalar { is_pub, is_vec, .. } => {
-                    if *is_pub == for_params {
+                    if *is_pub == for_instance {
                         if *is_vec {
                             self.push_vecscalar(&format_ident!("{}", id))
                         } else {
@@ -50,7 +50,7 @@ impl StructFieldList {
                     }
                 }
                 AExprType::Point { is_vec, .. } => {
-                    if for_params {
+                    if for_instance {
                         if *is_vec {
                             self.push_vecpoint(&format_ident!("{}", id))
                         } else {
@@ -67,28 +67,28 @@ impl StructFieldList {
         let dump_chunks = self.fields.iter().map(|f| match f {
             StructField::Scalar(id) => quote! {
                 print!("  {}: ", stringify!(#id));
-                Params::dump_scalar(&self.#id);
+                Instance::dump_scalar(&self.#id);
                 println!("");
             },
             StructField::VecScalar(id) => quote! {
                 print!("  {}: [", stringify!(#id));
                 for s in self.#id.iter() {
                     print!("    ");
-                    Params::dump_scalar(s);
+                    Instance::dump_scalar(s);
                     println!(",");
                 }
                 println!("  ]");
             },
             StructField::Point(id) => quote! {
                 print!("  {}: ", stringify!(#id));
-                Params::dump_point(&self.#id);
+                Instance::dump_point(&self.#id);
                 println!("");
             },
             StructField::VecPoint(id) => quote! {
                 print!("  {}: [", stringify!(#id));
                 for p in self.#id.iter() {
                     print!("    ");
-                    Params::dump_point(p);
+                    Instance::dump_point(p);
                     println!(",");
                 }
                 println!("  ]");
@@ -189,7 +189,7 @@ impl<'a> CodeGen<'a> {
     /// must evaluate to a `Result<Protocol>` and the `protocol_witness`
     /// code must evaluate to a `Result<ProtocolWitness>`.
     fn linear_relation_codegen(&self, exprs: &[&Expr]) -> (TokenStream, TokenStream) {
-        let params_var = format_ident!("{}params", self.unique_prefix);
+        let instance_var = format_ident!("{}instance", self.unique_prefix);
         let lr_var = format_ident!("{}lr", self.unique_prefix);
         let mut allocated_vars: HashSet<Ident> = HashSet::new();
         let mut param_vec_code = quote! {};
@@ -260,7 +260,7 @@ impl<'a> CodeGen<'a> {
                         is_vec: false,
                         is_pub: true,
                         ..
-                    } => Ok(quote! {#params_var.#id}),
+                    } => Ok(quote! {#instance_var.#id}),
                     AExprType::Scalar {
                         is_vec: true,
                         is_pub: false,
@@ -287,7 +287,7 @@ impl<'a> CodeGen<'a> {
                         ..
                     } => {
                         vec_param_vars.insert(id.clone());
-                        Ok(quote! {#params_var.#id[#vec_index_var]})
+                        Ok(quote! {#instance_var.#id[#vec_index_var]})
                     }
                     AExprType::Point { is_vec: false, .. } => {
                         if allocated_vars.insert(id.clone()) {
@@ -297,7 +297,7 @@ impl<'a> CodeGen<'a> {
                             };
                             element_assigns = quote! {
                                 #element_assigns
-                                #lr_var.set_element(#id, #params_var.#id);
+                                #lr_var.set_element(#id, #instance_var.#id);
                             };
                         }
                         Ok(quote! {#id})
@@ -316,7 +316,7 @@ impl<'a> CodeGen<'a> {
                                 for #vec_index_var in 0..#vec_len_var {
                                     #lr_var.set_element(
                                         #id[#vec_index_var],
-                                        #params_var.#id[#vec_index_var],
+                                        #instance_var.#id[#vec_index_var],
                                     );
                                 }
                             };
@@ -347,14 +347,14 @@ impl<'a> CodeGen<'a> {
                 let firstvar = &vec_param_varvec[0];
                 param_vec_code = quote! {
                     #param_vec_code
-                    let #vec_len_var = #params_var.#firstvar.len();
+                    let #vec_len_var = #instance_var.#firstvar.len();
                 };
                 for thisvar in vec_param_varvec.iter().skip(1) {
                     param_vec_code = quote! {
                         #param_vec_code
-                        if #vec_len_var != #params_var.#thisvar.len() {
+                        if #vec_len_var != #instance_var.#thisvar.len() {
                             eprintln!(
-                                "Params {} and {} must have the same length",
+                                "Instance variables {} and {} must have the same length",
                                 stringify!(#firstvar),
                                 stringify!(#thisvar),
                             );
@@ -365,7 +365,7 @@ impl<'a> CodeGen<'a> {
                 if !vec_witness_varvec.is_empty() {
                     witness_vec_code = quote! {
                         #witness_vec_code
-                        let #vec_len_var = params.#firstvar.len();
+                        let #vec_len_var = instance.#firstvar.len();
                     };
                 }
                 for witvar in vec_witness_varvec {
@@ -373,7 +373,7 @@ impl<'a> CodeGen<'a> {
                         #witness_vec_code
                         if #vec_len_var != witness.#witvar.len() {
                             eprintln!(
-                                "Params {} and {} must have the same length",
+                                "Instance variables {} and {} must have the same length",
                                 stringify!(#firstvar),
                                 stringify!(#witvar),
                             );
@@ -394,7 +394,7 @@ impl<'a> CodeGen<'a> {
                     for #vec_index_var in 0..#vec_len_var {
                         #lr_var.set_element(
                             #eq_id[#vec_index_var],
-                            #params_var.#left_id[#vec_index_var],
+                            #instance_var.#left_id[#vec_index_var],
                         );
                     }
                 };
@@ -405,7 +405,7 @@ impl<'a> CodeGen<'a> {
                 };
                 element_assigns = quote! {
                     #element_assigns
-                    #lr_var.set_element(#eq_id, #params_var.#left_id);
+                    #lr_var.set_element(#eq_id, #instance_var.#left_id);
                 }
             }
         }
@@ -545,17 +545,17 @@ impl<'a> CodeGen<'a> {
         self.statements.dump();
         println!("}}");
 
-        let mut pub_params_fields = StructFieldList::default();
-        pub_params_fields.push_vars(self.vars, true);
+        let mut pub_instance_fields = StructFieldList::default();
+        pub_instance_fields.push_vars(self.vars, true);
 
-        // Generate the public params struct definition
-        let params_def = {
-            let decls = pub_params_fields.field_decls();
+        // Generate the public instance struct definition
+        let instance_def = {
+            let decls = pub_instance_fields.field_decls();
             #[cfg(feature = "dump")]
             let dump_impl = {
-                let dump_chunks = pub_params_fields.dump();
+                let dump_chunks = pub_instance_fields.dump();
                 quote! {
-                    impl Params {
+                    impl Instance {
                         fn dump_scalar(s: &Scalar) {
                             let bytes: &[u8] = &s.to_repr();
                             print!("{:02x?}", bytes);
@@ -578,7 +578,7 @@ impl<'a> CodeGen<'a> {
             };
             quote! {
                 #[derive(Clone)]
-                pub struct Params {
+                pub struct Instance {
                     #decls
                 }
 
@@ -606,11 +606,11 @@ impl<'a> CodeGen<'a> {
 
         // Generate the function that creates the sigma-rs Protocol
         let protocol_func = {
-            let params_var = format_ident!("{}params", self.unique_prefix);
+            let instance_var = format_ident!("{}instance", self.unique_prefix);
 
             quote! {
                 fn protocol(
-                    #params_var: &Params,
+                    #instance_var: &Instance,
                 ) -> Result<Protocol<Point>, SigmaError> {
                     #protocol_code
                 }
@@ -621,7 +621,7 @@ impl<'a> CodeGen<'a> {
         let witness_func = if emit_prover {
             quote! {
                 fn protocol_witness(
-                    params: &Params,
+                    instance: &Instance,
                     witness: &Witness,
                 ) -> Result<ProtocolWitness<Point>, SigmaError> {
                     #witness_code
@@ -633,7 +633,7 @@ impl<'a> CodeGen<'a> {
 
         // Generate the prove function
         let prove_func = if emit_prover {
-            let params_var = format_ident!("{}params", self.unique_prefix);
+            let instance_var = format_ident!("{}instance", self.unique_prefix);
             let witness_var = format_ident!("{}witness", self.unique_prefix);
             let session_id_var = format_ident!("{}session_id", self.unique_prefix);
             let rng_var = format_ident!("{}rng", self.unique_prefix);
@@ -643,8 +643,8 @@ impl<'a> CodeGen<'a> {
 
             let dumper = if cfg!(feature = "dump") {
                 quote! {
-                    println!("prover params = {{");
-                    #params_var.dump();
+                    println!("prover instance = {{");
+                    #instance_var.dump();
                     println!("}}");
                 }
             } else {
@@ -653,14 +653,14 @@ impl<'a> CodeGen<'a> {
 
             quote! {
                 pub fn prove(
-                    #params_var: &Params,
+                    #instance_var: &Instance,
                     #witness_var: &Witness,
                     #session_id_var: &[u8],
                     #rng_var: &mut (impl CryptoRng + RngCore),
                 ) -> Result<Vec<u8>, SigmaError> {
                     #dumper
-                    let #proto_var = protocol(#params_var)?;
-                    let #proto_witness_var = protocol_witness(#params_var, #witness_var)?;
+                    let #proto_var = protocol(#instance_var)?;
+                    let #proto_witness_var = protocol_witness(#instance_var, #witness_var)?;
                     let #nizk_var =
                         NISigmaProtocol::<_, ShakeCodec<Point>>::new(
                             #session_id_var,
@@ -676,7 +676,7 @@ impl<'a> CodeGen<'a> {
 
         // Generate the verify function
         let verify_func = if emit_verifier {
-            let params_var = format_ident!("{}params", self.unique_prefix);
+            let instance_var = format_ident!("{}instance", self.unique_prefix);
             let proof_var = format_ident!("{}proof", self.unique_prefix);
             let session_id_var = format_ident!("{}session_id", self.unique_prefix);
             let proto_var = format_ident!("{}proto", self.unique_prefix);
@@ -684,8 +684,8 @@ impl<'a> CodeGen<'a> {
 
             let dumper = if cfg!(feature = "dump") {
                 quote! {
-                    println!("verifier params = {{");
-                    #params_var.dump();
+                    println!("verifier instance = {{");
+                    #instance_var.dump();
                     println!("}}");
                 }
             } else {
@@ -694,12 +694,12 @@ impl<'a> CodeGen<'a> {
 
             quote! {
                 pub fn verify(
-                    #params_var: &Params,
+                    #instance_var: &Instance,
                     #proof_var: &[u8],
                     #session_id_var: &[u8],
                 ) -> Result<(), SigmaError> {
                     #dumper
-                    let #proto_var = protocol(#params_var)?;
+                    let #proto_var = protocol(#instance_var)?;
                     let #nizk_var =
                         NISigmaProtocol::<_, ShakeCodec<Point>>::new(
                             #session_id_var,
@@ -736,7 +736,7 @@ impl<'a> CodeGen<'a> {
                 #dump_use
 
                 #group_types
-                #params_def
+                #instance_def
                 #witness_def
 
                 #protocol_func

sigma_compiler_core/src/substitution.rs

@@ -23,7 +23,7 @@
 //! containing the substitution statements themselves will be turned
 //! into the constant `true` and then pruned using
 //! [`prune_statement_tree`].  The [`CodeGen`] will be used to generate
-//! tests in the generated `prove` function that the `Params` and
+//! tests in the generated `prove` function that the `Instance` and
 //! `Witness` supplied to it do in fact satisfy the statements being
 //! substituted.
 //!

tests/basic.rs

@@ -26,9 +26,9 @@ fn basic_test() -> Result<(), sigma_rs::errors::Error> {
     let C = x * A + r * B;
     let D = z * A + s * B;
 
-    let params = proof::Params { C, D, A, B };
+    let instance = proof::Instance { C, D, A, B };
     let witness = proof::Witness { x, z, r, s };
 
-    let proof = proof::prove(&params, &witness, b"basic_test", &mut rng)?;
-    proof::verify(&params, &proof, b"basic_test")
+    let proof = proof::prove(&instance, &witness, b"basic_test", &mut rng)?;
+    proof::verify(&instance, &proof, b"basic_test")
 }

tests/dl.rs

@@ -17,11 +17,11 @@ fn dl_zero_test() -> Result<(), sigma_rs::errors::Error> {
     let x = Scalar::random(&mut rng);
     let C = (x + Scalar::ZERO) * B;
 
-    let params = proof::Params { C, B };
+    let instance = proof::Instance { C, B };
     let witness = proof::Witness { x };
 
-    let proof = proof::prove(&params, &witness, b"dl_test", &mut rng)?;
-    proof::verify(&params, &proof, b"dl_test")
+    let proof = proof::prove(&instance, &witness, b"dl_test", &mut rng)?;
+    proof::verify(&instance, &proof, b"dl_test")
 }
 
 #[test]
@@ -38,9 +38,9 @@ fn dl_one_test() -> Result<(), sigma_rs::errors::Error> {
     let x = Scalar::random(&mut rng);
     let C = (x + Scalar::ONE) * B;
 
-    let params = proof::Params { C, B };
+    let instance = proof::Instance { C, B };
     let witness = proof::Witness { x };
 
-    let proof = proof::prove(&params, &witness, b"dl_test", &mut rng)?;
-    proof::verify(&params, &proof, b"dl_test")
+    let proof = proof::prove(&instance, &witness, b"dl_test", &mut rng)?;
+    proof::verify(&instance, &proof, b"dl_test")
 }

tests/pubscalars.rs

@@ -29,9 +29,9 @@ fn pubscalars_test() -> Result<(), sigma_rs::errors::Error> {
     let C = x * A + r * B;
     let D = z * A + s * B;
 
-    let params = proof::Params { C, D, A, B, a, b };
+    let instance = proof::Instance { C, D, A, B, a, b };
     let witness = proof::Witness { x, z, r, s };
 
-    let proof = proof::prove(&params, &witness, b"pubscalars_test", &mut rng)?;
-    proof::verify(&params, &proof, b"pubscalars_test")
+    let proof = proof::prove(&instance, &witness, b"pubscalars_test", &mut rng)?;
+    proof::verify(&instance, &proof, b"pubscalars_test")
 }

tests/range.rs

@@ -27,9 +27,9 @@ fn range_test() -> Result<(), sigma_rs::errors::Error> {
     let C = (x + x + x + Scalar::ONE) * A + (r + r + Scalar::from_u128(3)) * B;
     let D = x * A + y * B;
 
-    let params = proof::Params { C, D, a, A, B };
+    let instance = proof::Instance { C, D, a, A, B };
     let witness = proof::Witness { x, y, r };
 
-    let proof = proof::prove(&params, &witness, b"range_test", &mut rng)?;
-    proof::verify(&params, &proof, b"range_test")
+    let proof = proof::prove(&instance, &witness, b"range_test", &mut rng)?;
+    proof::verify(&instance, &proof, b"range_test")
 }