The sigma-rs dependency has been renamed sigma-proofs

Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 sigma_compiler_derive = { path = "sigma_compiler_derive" }
 group = "0.13"
 rand = "0.8.5"
-sigma-rs = { path = "../sigma-rs" }
+sigma-proofs = { path = "dev/sigma-proofs" }
 subtle = "2.6"
 
 [dev-dependencies]

sigma_compiler_core/src/codegen.rs

@@ -263,30 +263,30 @@ impl CodeGen {
         // vardict contains the variables that were defined in the macro
         // call to [`sigma_compiler`]
         let vardict = taggedvardict_to_vardict(&self.vars);
-        // sigma_rs_vardict contains the variables that we are passing
-        // to sigma_rs.  We may have removed some via substitution, and
+        // sigma_proofs_vardict contains the variables that we are passing
+        // to sigma_proofs.  We may have removed some via substitution, and
         // we may have added some when compiling statements like range
         // assertions into underlying linear combination assertions.
-        let sigma_rs_vardict = taggedvardict_to_vardict(&spec.vars);
+        let sigma_proofs_vardict = taggedvardict_to_vardict(&spec.vars);
 
-        // Generate the code that uses the underlying sigma_rs API
-        let mut sigma_rs_codegen = super::sigma::codegen::CodeGen::new(
+        // Generate the code that uses the underlying sigma_proofs API
+        let mut sigma_proofs_codegen = super::sigma::codegen::CodeGen::new(
             format_ident!("sigma"),
             format_ident!("Point"),
-            &sigma_rs_vardict,
+            &sigma_proofs_vardict,
             &mut spec.statements,
         );
-        let sigma_rs_code = sigma_rs_codegen.generate(emit_prover, emit_verifier);
+        let sigma_proofs_code = sigma_proofs_codegen.generate(emit_prover, emit_verifier);
 
         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_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);
+        let mut sigma_proofs_instance_fields = StructFieldList::default();
+        sigma_proofs_instance_fields.push_vars(&sigma_proofs_vardict, true);
+        let mut sigma_proofs_witness_fields = StructFieldList::default();
+        sigma_proofs_witness_fields.push_vars(&sigma_proofs_vardict, false);
 
         // Generate the public instance struct definition
         let instance_def = {
@@ -343,8 +343,8 @@ impl CodeGen {
         let prove_func = if emit_prover {
             let instance_ids = pub_instance_fields.field_list();
             let witness_ids = witness_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 sigma_proofs_instance_ids = sigma_proofs_instance_fields.field_list();
+            let sigma_proofs_witness_ids = sigma_proofs_witness_fields.field_list();
             let prove_code = &self.prove_code;
             let codegen_instance_var = format_ident!("{}sigma_instance", self.unique_prefix);
             let codegen_witness_var = format_ident!("{}sigma_witness", self.unique_prefix);
@@ -356,12 +356,12 @@ impl CodeGen {
             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(
+                        #proof_var.extend(sigma_proofs::serialization::serialize_elements(
                             std::slice::from_ref(&#codegen_instance_var.#id)
                         ));
                     },
                     StructField::VecPoint(id) => quote! {
-                        #proof_var.extend(sigma_rs::serialization::serialize_elements(
+                        #proof_var.extend(sigma_proofs::serialization::serialize_elements(
                             &#codegen_instance_var.#id
                         ));
                     },
@@ -393,10 +393,10 @@ impl CodeGen {
                     #prove_code
                     let mut #proof_var = Vec::<u8>::new();
                     let #codegen_instance_var = sigma::Instance {
-                        #sigma_rs_instance_ids
+                        #sigma_proofs_instance_ids
                     };
                     let #codegen_witness_var = sigma::Witness {
-                        #sigma_rs_witness_ids
+                        #sigma_proofs_witness_ids
                     };
                     #sent_instance_code
                     #proof_var.extend(
@@ -417,7 +417,7 @@ impl CodeGen {
         // Generate the verify function
         let verify_func = if emit_verifier {
             let instance_ids = pub_instance_fields.field_list();
-            let sigma_rs_instance_ids = sigma_rs_instance_fields.field_list();
+            let sigma_proofs_instance_ids = sigma_proofs_instance_fields.field_list();
             let verify_pre_instance_code = &self.verify_pre_instance_code;
             let verify_code = &self.verify_code;
             let codegen_instance_var = format_ident!("{}sigma_instance", self.unique_prefix);
@@ -438,14 +438,14 @@ impl CodeGen {
 
                 let chunks = self.sent_instance.fields.iter().map(|sf| match sf {
                     StructField::Point(id) => quote! {
-                        let #id: Point = sigma_rs::serialization::deserialize_elements(
+                        let #id: Point = sigma_proofs::serialization::deserialize_elements(
                                 &#proof_var[#offset_var..],
                                 1,
                             ).ok_or(SigmaError::VerificationFailure)?[0];
                         #offset_var += #element_len_var;
                     },
                     StructField::VecPoint(id) => quote! {
-                        #id = sigma_rs::serialization::deserialize_elements(
+                        #id = sigma_proofs::serialization::deserialize_elements(
                                 &#proof_var[#offset_var..],
                                 #id.len(),
                             ).ok_or(SigmaError::VerificationFailure)?;
@@ -483,7 +483,7 @@ impl CodeGen {
                     #sent_instance_code
                     #verify_code
                     let #codegen_instance_var = sigma::Instance {
-                        #sigma_rs_instance_ids
+                        #sigma_proofs_instance_ids
                     };
                     sigma::verify(
                         &#codegen_instance_var,
@@ -511,15 +511,15 @@ impl CodeGen {
                 use sigma_compiler::group::ff::{Field, PrimeField};
                 use sigma_compiler::group::ff::derive::subtle::ConditionallySelectable;
                 use sigma_compiler::rand::{CryptoRng, RngCore};
-                use sigma_compiler::sigma_rs;
-                use sigma_compiler::sigma_rs::errors::Error as SigmaError;
+                use sigma_compiler::sigma_proofs;
+                use sigma_compiler::sigma_proofs::errors::Error as SigmaError;
                 use sigma_compiler::vecutils::*;
                 use std::ops::Neg;
                 #dump_use
 
                 #group_types
 
-                #sigma_rs_code
+                #sigma_proofs_code
 
                 #instance_def
                 #witness_def

sigma_compiler_core/src/lib.rs

@@ -1,7 +1,7 @@
 use proc_macro2::TokenStream;
 
 /// The submodules that would be useful to have in the lower-level
-/// `sigma-rs` crate are for now included as submodules of a local
+/// `sigma-proofs` crate are for now included as submodules of a local
 /// `sigma` module.
 pub mod sigma {
     pub mod codegen;

sigma_compiler_core/src/sigma/codegen.rs

@@ -724,12 +724,12 @@ impl<'a> CodeGen<'a> {
         quote! {
             #[allow(non_snake_case)]
             pub mod #proto_name {
-                use sigma_compiler::sigma_rs;
+                use sigma_compiler::sigma_proofs;
                 use sigma_compiler::group::ff::PrimeField;
                 use sigma_compiler::rand::{CryptoRng, RngCore};
                 use sigma_compiler::subtle::CtOption;
                 use sigma_compiler::vecutils::*;
-                use sigma_rs::{
+                use sigma_proofs::{
                     composition::{ComposedRelation, ComposedWitness},
                     errors::Error as SigmaError,
                     errors::Ok as SigmaOk,

src/lib.rs

@@ -1,7 +1,7 @@
 pub use group;
 pub use rand;
 pub use sigma_compiler_derive::{sigma_compiler, sigma_compiler_prover, sigma_compiler_verifier};
-pub use sigma_rs;
+pub use sigma_proofs;
 pub use subtle;
 
 pub mod rangeutils;

src/rangeutils.rs

@@ -2,7 +2,7 @@
 //! processing of range statements.
 
 use group::ff::PrimeField;
-use sigma_rs::errors::Error;
+use sigma_proofs::errors::Error;
 use subtle::Choice;
 
 /// Convert a [`Scalar`] to an [`u128`], assuming it fits in an [`i128`]

tests/basic.rs

@@ -6,7 +6,7 @@ use sha2::Sha512;
 use sigma_compiler::*;
 
 #[test]
-fn basic_test() -> Result<(), sigma_rs::errors::Error> {
+fn basic_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, z, rand r, rand s),
         (C, D, const cind A, const cind B),

tests/basic_sum.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sha2::Sha512;
 use sigma_compiler::*;
 
-fn basic_sum_test_vecsize(vecsize: usize) -> Result<(), sigma_rs::errors::Error> {
+fn basic_sum_test_vecsize(vecsize: usize) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x, y, rand vec r, rand s),
         (vec C, D, const cind A, const cind B),

tests/basic_vec.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sha2::Sha512;
 use sigma_compiler::*;
 
-fn basic_vec_test_vecsize(vecsize: usize) -> Result<(), sigma_rs::errors::Error> {
+fn basic_vec_test_vecsize(vecsize: usize) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x, rand vec r),
         (vec C, const cind A, const cind B),

tests/disj.rs

@@ -6,7 +6,7 @@ use sha2::Sha512;
 use sigma_compiler::*;
 
 #[test]
-fn disj_test() -> Result<(), sigma_rs::errors::Error> {
+fn disj_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, rand r),
         (C, const cind A, const cind B),

tests/disj_vec.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sha2::Sha512;
 use sigma_compiler::*;
 
-fn disj_vec_test_vecsize(vecsize: usize) -> Result<(), sigma_rs::errors::Error> {
+fn disj_vec_test_vecsize(vecsize: usize) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x, vec y, pub vec a, rand vec r, rand vec s),
         (vec C, vec D, const cind A, const cind B),

tests/dl.rs

@@ -4,7 +4,7 @@ use group::Group;
 use sigma_compiler::*;
 
 #[test]
-fn dl_zero_test() -> Result<(), sigma_rs::errors::Error> {
+fn dl_zero_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x),
         (C, const B),
@@ -25,7 +25,7 @@ fn dl_zero_test() -> Result<(), sigma_rs::errors::Error> {
 }
 
 #[test]
-fn dl_one_test() -> Result<(), sigma_rs::errors::Error> {
+fn dl_one_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x),
         (C, const B),

tests/dot_product.rs

@@ -3,7 +3,7 @@ use curve25519_dalek::ristretto::RistrettoPoint as G;
 use group::Group;
 use sigma_compiler::*;
 
-fn dot_product_test_vecsize(vecsize: usize) -> Result<(), sigma_rs::errors::Error> {
+fn dot_product_test_vecsize(vecsize: usize) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x, pub vec a),
         (C, D, E, F, vec A, B),

tests/emptystatement.rs

@@ -3,7 +3,7 @@ use curve25519_dalek::ristretto::RistrettoPoint as G;
 use sigma_compiler::*;
 
 #[test]
-fn emptystatement_test() -> Result<(), sigma_rs::errors::Error> {
+fn emptystatement_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (),
         (),

tests/left_expr.rs

@@ -6,7 +6,7 @@ use sha2::Sha512;
 use sigma_compiler::*;
 
 #[test]
-fn left_expr_test() -> Result<(), sigma_rs::errors::Error> {
+fn left_expr_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, y, pub a, rand r, rand s),
         (C, D, const cind A, const cind B),
@@ -34,7 +34,7 @@ fn left_expr_test() -> Result<(), sigma_rs::errors::Error> {
 }
 
 #[test]
-fn left_expr_vec_test() -> Result<(), sigma_rs::errors::Error> {
+fn left_expr_vec_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x, vec y, z, pub vec a, pub b, rand vec r, rand vec s, rand t),
         (vec C, vec D, E, const cind A, const cind B),

tests/notequals.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sha2::Sha512;
 use sigma_compiler::*;
 
-fn do_test(x_u128: u128) -> Result<(), sigma_rs::errors::Error> {
+fn do_test(x_u128: u128) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, rand r),
         (C, const cind A, const cind B),

tests/pubscalars.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sha2::Sha512;
 use sigma_compiler::*;
 
-fn pubscalars_test_val(b_val: u128) -> Result<(), sigma_rs::errors::Error> {
+fn pubscalars_test_val(b_val: u128) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, z, rand r, rand s, pub a, pub b),
         (C, D, const cind A, const cind B),

tests/pubscalars_or.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sha2::Sha512;
 use sigma_compiler::*;
 
-fn pubscalars_or_test_val(b_val: u128) -> Result<(), sigma_rs::errors::Error> {
+fn pubscalars_or_test_val(b_val: u128) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, rand r, pub a, pub b),
         (C, const cind A, const cind B),

tests/pubscalars_or_and.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sha2::Sha512;
 use sigma_compiler::*;
 
-fn pubscalars_or_and_test_val(x_val: u128, b_val: u128) -> Result<(), sigma_rs::errors::Error> {
+fn pubscalars_or_and_test_val(x_val: u128, b_val: u128) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, rand r, pub a, pub b),
         (C, const cind A, const cind B),

tests/pubscalars_or_and_vec.rs

@@ -9,7 +9,7 @@ fn pubscalars_or_vec_test_vecsize_val(
     vecsize: usize,
     b_val: u128,
     x_val: Option<u128>,
-) -> Result<(), sigma_rs::errors::Error> {
+) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x, vec y, pub vec a, pub vec b, rand vec r, rand vec s),
         (vec C, vec D, const cind A, const cind B),

tests/pubscalars_or_vec.rs

@@ -8,7 +8,7 @@ use sigma_compiler::*;
 fn pubscalars_or_vec_test_vecsize_val(
     vecsize: usize,
     b_val: u128,
-) -> Result<(), sigma_rs::errors::Error> {
+) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x, pub vec a, pub vec b, rand vec r),
         (vec C, const cind A, const cind B),

tests/pubscalars_vec.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sha2::Sha512;
 use sigma_compiler::*;
 
-fn pubscalars_vec_test_vecsize(vecsize: usize) -> Result<(), sigma_rs::errors::Error> {
+fn pubscalars_vec_test_vecsize(vecsize: usize) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x, vec y, pub vec a, pub vec b, rand vec r, rand vec s),
         (vec C, vec D, const cind A, const cind B),

tests/pubstatements.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sigma_compiler::*;
 
 #[test]
-fn pubstatements_test() -> Result<(), sigma_rs::errors::Error> {
+fn pubstatements_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, pub a),
         (C, D, const cind B),

tests/pubstatements_vec.rs

@@ -4,7 +4,7 @@ use group::ff::PrimeField;
 use group::Group;
 use sigma_compiler::*;
 
-fn pubstatements_vec_test_vecsize(vecsize: usize) -> Result<(), sigma_rs::errors::Error> {
+fn pubstatements_vec_test_vecsize(vecsize: usize) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x, pub vec a),
         (vec C, vec D, const cind B),

tests/range.rs

@@ -6,7 +6,7 @@ use sha2::Sha512;
 use sigma_compiler::*;
 
 #[test]
-fn range_test() -> Result<(), sigma_rs::errors::Error> {
+fn range_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, y, pub a, rand r),
         (C, D, const cind A, const cind B),

tests/simple_or.rs

@@ -5,7 +5,7 @@ use sha2::Sha512;
 use sigma_compiler::*;
 
 #[test]
-fn simple_or_test() -> Result<(), sigma_rs::errors::Error> {
+fn simple_or_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, y),
         (C, const cind A, const cind B),

tests/substitution_or.rs

@@ -6,7 +6,7 @@ use sha2::Sha512;
 use sigma_compiler::*;
 
 #[test]
-fn substitution_or_test() -> Result<(), sigma_rs::errors::Error> {
+fn substitution_or_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, z, rand r, rand s),
         (C, D, const cind A, const cind B),

tests/substitution_vec.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sha2::Sha512;
 use sigma_compiler::*;
 
-fn substitution_vec_test_vecsize(vecsize: usize) -> Result<(), sigma_rs::errors::Error> {
+fn substitution_vec_test_vecsize(vecsize: usize) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x, vec y, rand vec r, rand vec s),
         (vec C, vec D, const cind A, const cind B),

tests/subtract.rs

@@ -4,7 +4,7 @@ use group::Group;
 use sigma_compiler::*;
 
 #[test]
-fn subtract_test() -> Result<(), sigma_rs::errors::Error> {
+fn subtract_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x),
         (C, const cind B),

tests/subtract_vec.rs

@@ -5,7 +5,7 @@ use group::Group;
 use sha2::Sha512;
 use sigma_compiler::*;
 
-fn subtract_vec_test_vecsize(vecsize: usize) -> Result<(), sigma_rs::errors::Error> {
+fn subtract_vec_test_vecsize(vecsize: usize) -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (vec x),
         (vec C, vec D, vec E, const cind A, const cind B),

tests/two_true.rs

@@ -5,7 +5,7 @@ use sha2::Sha512;
 use sigma_compiler::*;
 
 #[test]
-fn two_true_test() -> Result<(), sigma_rs::errors::Error> {
+fn two_true_test() -> sigma_proofs::errors::Result<()> {
     sigma_compiler! { proof,
         (x, y),
         (C, D, const cind A, const cind B),