support for stable Rust (microsoft#51)

* support for stable Rust

* add no default to stable

* add no default to stable

* update CI

Author: srinathsetty

.github/workflows/rust.yml

@@ -7,7 +7,7 @@ on:
     branches: [ master ]
 
 jobs:
-  build:
+  build_nightly:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2

Cargo.toml

@@ -2,7 +2,7 @@
 name = "spartan"
 version = "0.6.0"
 authors = ["Srinath Setty <[email protected]>"]
-edition = "2018"
+edition = "2021"
 description = "High-speed zkSNARKs without trusted setup"
 documentation = "https://docs.rs/spartan/"
 readme = "README.md"

src/dense_mlpoly.rs

@@ -118,7 +118,7 @@ impl IdentityPolynomial {
 impl DensePolynomial {
   pub fn new(Z: Vec<Scalar>) -> Self {
     DensePolynomial {
-      num_vars: Z.len().log2() as usize,
+      num_vars: Z.len().log_2() as usize,
       len: Z.len(),
       Z,
     }

src/lib.rs

@@ -1,6 +1,4 @@
 #![allow(non_snake_case)]
-#![feature(test)]
-#![feature(int_log)]
 #![doc = include_str!("../README.md")]
 #![deny(missing_docs)]
 #![allow(clippy::assertions_on_result_states)]
@@ -12,7 +10,6 @@ extern crate digest;
 extern crate merlin;
 extern crate rand;
 extern crate sha3;
-extern crate test;
 
 #[cfg(feature = "multicore")]
 extern crate rayon;

src/math.rs

@@ -2,6 +2,7 @@ pub trait Math {
   fn square_root(self) -> usize;
   fn pow2(self) -> usize;
   fn get_bits(self, num_bits: usize) -> Vec<bool>;
+  fn log_2(self) -> usize;
 }
 
 impl Math for usize {
@@ -22,4 +23,14 @@ impl Math for usize {
       .map(|shift_amount| ((self & (1 << (num_bits - shift_amount - 1))) > 0))
       .collect::<Vec<bool>>()
   }
+
+  fn log_2(self) -> usize {
+    assert_ne!(self, 0);
+
+    if self.is_power_of_two() {
+      (1usize.leading_zeros() - self.leading_zeros()) as usize
+    } else {
+      (0usize.leading_zeros() - self.leading_zeros()) as usize
+    }
+  }
 }

src/nizk/bullet.rs

@@ -5,6 +5,7 @@
 #![allow(clippy::too_many_arguments)]
 use super::super::errors::ProofVerifyError;
 use super::super::group::{CompressedGroup, GroupElement, VartimeMultiscalarMul};
+use super::super::math::Math;
 use super::super::scalar::Scalar;
 use super::super::transcript::ProofTranscript;
 use core::iter;
@@ -55,7 +56,7 @@ impl BulletReductionProof {
     // All of the input vectors must have a length that is a power of two.
     let mut n = G.len();
     assert!(n.is_power_of_two());
-    let lg_n = n.log2() as usize;
+    let lg_n = n.log_2() as usize;
 
     // All of the input vectors must have the same length.
     assert_eq!(G.len(), n);

src/nizk/mod.rs

@@ -2,6 +2,7 @@
 use super::commitments::{Commitments, MultiCommitGens};
 use super::errors::ProofVerifyError;
 use super::group::{CompressedGroup, CompressedGroupExt};
+use super::math::Math;
 use super::random::RandomTape;
 use super::scalar::Scalar;
 use super::transcript::{AppendToTranscript, ProofTranscript};
@@ -456,8 +457,8 @@ impl DotProductProofLog {
     let r_delta = random_tape.random_scalar(b"r_delta");
     let r_beta = random_tape.random_scalar(b"r_delta");
     let blinds_vec = {
-      let v1 = random_tape.random_vector(b"blinds_vec_1", 2 * n.log2() as usize);
-      let v2 = random_tape.random_vector(b"blinds_vec_2", 2 * n.log2() as usize);
+      let v1 = random_tape.random_vector(b"blinds_vec_1", 2 * n.log_2());
+      let v2 = random_tape.random_vector(b"blinds_vec_2", 2 * n.log_2());
       (0..v1.len())
         .map(|i| (v1[i], v2[i]))
         .collect::<Vec<(Scalar, Scalar)>>()

src/product_tree.rs

@@ -1,6 +1,7 @@
 #![allow(dead_code)]
 use super::dense_mlpoly::DensePolynomial;
 use super::dense_mlpoly::EqPolynomial;
+use super::math::Math;
 use super::scalar::Scalar;
 use super::sumcheck::SumcheckInstanceProof;
 use super::transcript::ProofTranscript;
@@ -36,7 +37,7 @@ impl ProductCircuit {
     let mut left_vec: Vec<DensePolynomial> = Vec::new();
     let mut right_vec: Vec<DensePolynomial> = Vec::new();
 
-    let num_layers = poly.len().log2() as usize;
+    let num_layers = poly.len().log_2() as usize;
     let (outp_left, outp_right) = poly.split(poly.len() / 2);
 
     left_vec.push(outp_left);
@@ -181,7 +182,7 @@ impl ProductCircuitEvalProof {
       let mut poly_C = DensePolynomial::new(EqPolynomial::new(rand.clone()).evals());
       assert_eq!(poly_C.len(), len / 2);
 
-      let num_rounds_prod = poly_C.len().log2() as usize;
+      let num_rounds_prod = poly_C.len().log_2() as usize;
       let comb_func_prod = |poly_A_comp: &Scalar,
                             poly_B_comp: &Scalar,
                             poly_C_comp: &Scalar|
@@ -222,7 +223,7 @@ impl ProductCircuitEvalProof {
     len: usize,
     transcript: &mut Transcript,
   ) -> (Scalar, Vec<Scalar>) {
-    let num_layers = len.log2() as usize;
+    let num_layers = len.log_2() as usize;
     let mut claim = eval;
     let mut rand: Vec<Scalar> = Vec::new();
     //let mut num_rounds = 0;
@@ -278,7 +279,7 @@ impl ProductCircuitEvalProofBatched {
       let mut poly_C_par = DensePolynomial::new(EqPolynomial::new(rand.clone()).evals());
       assert_eq!(poly_C_par.len(), len / 2);
 
-      let num_rounds_prod = poly_C_par.len().log2() as usize;
+      let num_rounds_prod = poly_C_par.len().log_2() as usize;
       let comb_func_prod = |poly_A_comp: &Scalar,
                             poly_B_comp: &Scalar,
                             poly_C_comp: &Scalar|
@@ -388,7 +389,7 @@ impl ProductCircuitEvalProofBatched {
     len: usize,
     transcript: &mut Transcript,
   ) -> (Vec<Scalar>, Vec<Scalar>, Vec<Scalar>) {
-    let num_layers = len.log2() as usize;
+    let num_layers = len.log_2() as usize;
     let mut rand: Vec<Scalar> = Vec::new();
     //let mut num_rounds = 0;
     assert_eq!(self.proof.len(), num_layers);

src/r1csinstance.rs

@@ -47,8 +47,8 @@ impl R1CSCommitmentGens {
     num_nz_entries: usize,
   ) -> R1CSCommitmentGens {
     assert!(num_inputs < num_vars);
-    let num_poly_vars_x = num_cons.log2() as usize;
-    let num_poly_vars_y = (2 * num_vars).log2() as usize;
+    let num_poly_vars_x = num_cons.log_2() as usize;
+    let num_poly_vars_y = (2 * num_vars).log_2() as usize;
     let gens =
       SparseMatPolyCommitmentGens::new(label, num_poly_vars_x, num_poly_vars_y, num_nz_entries, 3);
     R1CSCommitmentGens { gens }
@@ -116,8 +116,8 @@ impl R1CSInstance {
     assert!(num_inputs < num_vars);
 
     // no errors, so create polynomials
-    let num_poly_vars_x = num_cons.log2() as usize;
-    let num_poly_vars_y = (2 * num_vars).log2() as usize;
+    let num_poly_vars_x = num_cons.log_2() as usize;
+    let num_poly_vars_y = (2 * num_vars).log_2() as usize;
 
     let mat_A = (0..A.len())
       .map(|i| SparseMatEntry::new(A[i].0, A[i].1, A[i].2))
@@ -167,8 +167,8 @@ impl R1CSInstance {
     let mut csprng: OsRng = OsRng;
 
     // assert num_cons and num_vars are power of 2
-    assert_eq!((num_cons.log2() as usize).pow2(), num_cons);
-    assert_eq!((num_vars.log2() as usize).pow2(), num_vars);
+    assert_eq!((num_cons.log_2() as usize).pow2(), num_cons);
+    assert_eq!((num_vars.log_2() as usize).pow2(), num_vars);
 
     // num_inputs + 1 <= num_vars
     assert!(num_inputs < num_vars);
@@ -215,8 +215,8 @@ impl R1CSInstance {
     Timer::print(&format!("number_non-zero_entries_B {}", B.len()));
     Timer::print(&format!("number_non-zero_entries_C {}", C.len()));
 
-    let num_poly_vars_x = num_cons.log2() as usize;
-    let num_poly_vars_y = (2 * num_vars).log2() as usize;
+    let num_poly_vars_x = num_cons.log_2() as usize;
+    let num_poly_vars_y = (2 * num_vars).log_2() as usize;
     let poly_A = SparseMatPolynomial::new(num_poly_vars_x, num_poly_vars_y, A);
     let poly_B = SparseMatPolynomial::new(num_poly_vars_x, num_poly_vars_y, B);
     let poly_C = SparseMatPolynomial::new(num_poly_vars_x, num_poly_vars_y, C);

src/r1csproof.rs

@@ -5,6 +5,7 @@ use super::dense_mlpoly::{
 };
 use super::errors::ProofVerifyError;
 use super::group::{CompressedGroup, GroupElement, VartimeMultiscalarMul};
+use super::math::Math;
 use super::nizk::{EqualityProof, KnowledgeProof, ProductProof};
 use super::r1csinstance::R1CSInstance;
 use super::random::RandomTape;
@@ -63,7 +64,7 @@ pub struct R1CSGens {
 
 impl R1CSGens {
   pub fn new(label: &'static [u8], _num_cons: usize, num_vars: usize) -> Self {
-    let num_poly_vars = num_vars.log2() as usize;
+    let num_poly_vars = num_vars.log_2() as usize;
     let gens_pc = PolyCommitmentGens::new(num_poly_vars, label);
     let gens_sc = R1CSSumcheckGens::new(label, &gens_pc.gens.gens_1);
     R1CSGens { gens_sc, gens_pc }
@@ -182,8 +183,10 @@ impl R1CSProof {
     };
 
     // derive the verifier's challenge tau
-    let (num_rounds_x, num_rounds_y) =
-      (inst.get_num_cons().log2() as usize, z.len().log2() as usize);
+    let (num_rounds_x, num_rounds_y) = (
+      inst.get_num_cons().log_2() as usize,
+      z.len().log_2() as usize,
+    );
     let tau = transcript.challenge_vector(b"challenge_tau", num_rounds_x);
     // compute the initial evaluation table for R(\tau, x)
     let mut poly_tau = DensePolynomial::new(EqPolynomial::new(tau).evals());
@@ -365,7 +368,7 @@ impl R1CSProof {
       .comm_vars
       .append_to_transcript(b"poly_commitment", transcript);
 
-    let (num_rounds_x, num_rounds_y) = (num_cons.log2() as usize, (2 * num_vars).log2() as usize);
+    let (num_rounds_x, num_rounds_y) = (num_cons.log_2() as usize, (2 * num_vars).log_2() as usize);
 
     // derive the verifier's challenge tau
     let tau = transcript.challenge_vector(b"challenge_tau", num_rounds_x);
@@ -461,7 +464,7 @@ impl R1CSProof {
           .map(|i| SparsePolyEntry::new(i + 1, input[i]))
           .collect::<Vec<SparsePolyEntry>>(),
       );
-      SparsePolynomial::new(n.log2() as usize, input_as_sparse_poly_entries).evaluate(&ry[1..])
+      SparsePolynomial::new(n.log_2() as usize, input_as_sparse_poly_entries).evaluate(&ry[1..])
     };
 
     // compute commitment to eval_Z_at_ry = (Scalar::one() - ry[0]) * self.eval_vars_at_ry + ry[0] * poly_input_eval

src/sparse_mlpoly.rs

@@ -91,7 +91,7 @@ impl DerefsEvalProof {
   ) -> PolyEvalProof {
     assert_eq!(
       joint_poly.get_num_vars(),
-      r.len() + evals.len().log2() as usize
+      r.len() + evals.len().log_2() as usize
     );
 
     // append the claimed evaluations to transcript
@@ -100,7 +100,7 @@ impl DerefsEvalProof {
     // n-to-1 reduction
     let (r_joint, eval_joint) = {
       let challenges =
-        transcript.challenge_vector(b"challenge_combine_n_to_one", evals.len().log2() as usize);
+        transcript.challenge_vector(b"challenge_combine_n_to_one", evals.len().log_2() as usize);
       let mut poly_evals = DensePolynomial::new(evals);
       for i in (0..challenges.len()).rev() {
         poly_evals.bound_poly_var_bot(&challenges[i]);
@@ -166,7 +166,7 @@ impl DerefsEvalProof {
 
     // n-to-1 reduction
     let challenges =
-      transcript.challenge_vector(b"challenge_combine_n_to_one", evals.len().log2() as usize);
+      transcript.challenge_vector(b"challenge_combine_n_to_one", evals.len().log_2() as usize);
     let mut poly_evals = DensePolynomial::new(evals);
     for i in (0..challenges.len()).rev() {
       poly_evals.bound_poly_var_bot(&challenges[i]);
@@ -300,15 +300,15 @@ impl SparseMatPolyCommitmentGens {
     num_nz_entries: usize,
     batch_size: usize,
   ) -> SparseMatPolyCommitmentGens {
-    let num_vars_ops = num_nz_entries.next_power_of_two().log2() as usize
-      + (batch_size * 5).next_power_of_two().log2() as usize;
+    let num_vars_ops = num_nz_entries.next_power_of_two().log_2() as usize
+      + (batch_size * 5).next_power_of_two().log_2() as usize;
     let num_vars_mem = if num_vars_x > num_vars_y {
       num_vars_x
     } else {
       num_vars_y
     } + 1;
-    let num_vars_derefs = num_nz_entries.next_power_of_two().log2() as usize
-      + (batch_size * 2).next_power_of_two().log2() as usize;
+    let num_vars_derefs = num_nz_entries.next_power_of_two().log_2() as usize
+      + (batch_size * 2).next_power_of_two().log_2() as usize;
 
     let gens_ops = PolyCommitmentGens::new(num_vars_ops, label);
     let gens_mem = PolyCommitmentGens::new(num_vars_mem, label);
@@ -780,7 +780,7 @@ impl HashLayerProof {
     evals_ops.append_to_transcript(b"claim_evals_ops", transcript);
     let challenges_ops = transcript.challenge_vector(
       b"challenge_combine_n_to_one",
-      evals_ops.len().log2() as usize,
+      evals_ops.len().log_2() as usize,
     );
 
     let mut poly_evals_ops = DensePolynomial::new(evals_ops);
@@ -809,7 +809,7 @@ impl HashLayerProof {
     evals_mem.append_to_transcript(b"claim_evals_mem", transcript);
     let challenges_mem = transcript.challenge_vector(
       b"challenge_combine_two_to_one",
-      evals_mem.len().log2() as usize,
+      evals_mem.len().log_2() as usize,
     );
 
     let mut poly_evals_mem = DensePolynomial::new(evals_mem);
@@ -954,7 +954,7 @@ impl HashLayerProof {
     evals_ops.append_to_transcript(b"claim_evals_ops", transcript);
     let challenges_ops = transcript.challenge_vector(
       b"challenge_combine_n_to_one",
-      evals_ops.len().log2() as usize,
+      evals_ops.len().log_2() as usize,
     );
 
     let mut poly_evals_ops = DensePolynomial::new(evals_ops);
@@ -980,7 +980,7 @@ impl HashLayerProof {
     evals_mem.append_to_transcript(b"claim_evals_mem", transcript);
     let challenges_mem = transcript.challenge_vector(
       b"challenge_combine_two_to_one",
-      evals_mem.len().log2() as usize,
+      evals_mem.len().log_2() as usize,
     );
 
     let mut poly_evals_mem = DensePolynomial::new(evals_mem);
@@ -1629,8 +1629,8 @@ mod tests {
     let num_nz_entries: usize = 256;
     let num_rows: usize = 256;
     let num_cols: usize = 256;
-    let num_vars_x: usize = num_rows.log2() as usize;
-    let num_vars_y: usize = num_cols.log2() as usize;
+    let num_vars_x: usize = num_rows.log_2() as usize;
+    let num_vars_y: usize = num_cols.log_2() as usize;
 
     let mut M: Vec<SparseMatEntry> = Vec::new();