Use latest proof-systems/master in Mina

.gitmodules

@@ -3,7 +3,4 @@
 	url = https://github.com/o1-labs/snarky
 [submodule "src/lib/crypto/proof-systems"]
 	path = src/lib/crypto/proof-systems
-	url = https://github.com/o1-labs/proof-systems.git
-[submodule "src/lib/crypto/kimchi_bindings/stubs/kimchi-stubs-vendors"]
-	path = src/lib/crypto/kimchi_bindings/stubs/kimchi-stubs-vendors
-	url = https://github.com/MinaProtocol/kimchi-stubs-vendors.git
+	url = https://github.com/o1-labs/proof-systems.git

src/lib/crypto/kimchi_bindings/stubs/.cargo/config

@@ -1,8 +1,2 @@
 [build]
-rustflags = ["-C", "link-args=-Wl,-undefined,dynamic_lookup"]
-
-[source.crates-io]
-replace-with = "vendored-sources"
-
-[source.vendored-sources]
-directory = "kimchi-stubs-vendors"
+rustflags = ["-C", "link-args=-Wl,-undefined,dynamic_lookup"]

src/lib/crypto/kimchi_bindings/stubs/Cargo.toml

@@ -13,31 +13,31 @@ crate-type = ["lib", "staticlib"]
 
 [dependencies]
 array-init = "2.0.0"
-rmp-serde = "1.1.2"
 libc = "0.2.62"
 num-bigint = { version = "0.4.4", features = [ "rand", "serde" ] }
+# ocaml-specific
+ocaml = { version = "0.22.2", features = ["no-caml-startup"] }
+ocaml-gen = "0.1.5"
+once_cell = "1.10.0"
 paste = "1.0.5"
 rand = "0.8.5"
 rayon = "1.5.0"
+rmp-serde = "1.1.2"
 serde = "1.0.130"
 serde_json = "1.0.103"
 sprs = { version = "0.11.0", features = ["multi_thread"] }
-once_cell = "1.10.0"
 
 # arkworks
-ark-ff = { version = "0.4.2", features = ["parallel", "asm"] }
-ark-serialize = "0.4.2"
 ark-ec = { version = "0.4.2", features = ["parallel"] }
+ark-ff = { version = "0.4.2", features = ["parallel", "asm"] }
 ark-poly = { version = "0.4.2", features = ["parallel"] }
+ark-serialize = "0.4.2"
 
 # proof-systems
-poly-commitment = { path = "../../proof-systems/poly-commitment", features = ["ocaml_types"] }
 groupmap = { path = "../../proof-systems/groupmap" }
+kimchi = { path = "../../proof-systems/kimchi", features = ["ocaml_types"] }
 mina-curves = { path = "../../proof-systems/curves" }
-o1-utils = { path = "../../proof-systems/utils" }
 mina-poseidon = { path = "../../proof-systems/poseidon" }
-kimchi = { path = "../../proof-systems/kimchi", features = ["ocaml_types"] }
+o1-utils = { path = "../../proof-systems/utils" }
+poly-commitment = { path = "../../proof-systems/poly-commitment", features = ["ocaml_types"] }
 
-# ocaml-specific
-ocaml = { version = "0.22.2", features = ["no-caml-startup"] }
-ocaml-gen = "0.1.5"

src/lib/crypto/kimchi_bindings/stubs/dune

@@ -59,7 +59,7 @@
     (setenv
      RUSTFLAGS
      %{read:rustflags.sexp}
-     (run cargo build --release --offline)))
+     (run cargo build --release)))
    (run
     cp
     %{read:../dune-build-root}/cargo_kimchi_stubs/release/libwires_15_stubs.a
@@ -161,7 +161,7 @@
    (setenv
     CARGO_TARGET_DIR
     "%{read:../dune-build-root}/cargo_kimchi_bindgen"
-    (run cargo run %{targets} --offline))
+    (run cargo run %{targets}))
    (run ocamlformat -i %{targets}))))
 
 ;; this is used by nix

src/lib/crypto/kimchi_bindings/stubs/src/arkworks/pasta_fp.rs

@@ -2,8 +2,11 @@ use crate::arkworks::CamlBigInteger256;
 use crate::caml::caml_bytes_string::CamlBytesString;
 use ark_ff::{FftField, Field, One, PrimeField, UniformRand, Zero};
 use ark_poly::{EvaluationDomain, Radix2EvaluationDomain as Domain};
-use ark_serialize::{CanonicalSerialize, CanonicalDeserialize};
-use mina_curves::pasta::fields::{fp::{Fp, FpParameters as Fp_params}, fft::FpParameters};
+use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
+use mina_curves::pasta::fields::{
+    fft::FpParameters,
+    fp::{Fp, FpParameters as Fp_params},
+};
 use num_bigint::BigUint;
 use rand::rngs::StdRng;
 use std::{

src/lib/crypto/kimchi_bindings/stubs/src/arkworks/pasta_fq.rs

@@ -2,8 +2,11 @@ use crate::arkworks::CamlBigInteger256;
 use crate::caml::caml_bytes_string::CamlBytesString;
 use ark_ff::{FftField, Field, One, PrimeField, UniformRand, Zero};
 use ark_poly::{EvaluationDomain, Radix2EvaluationDomain as Domain};
-use ark_serialize::{CanonicalSerialize, CanonicalDeserialize};
-use mina_curves::pasta::{fields::{fq::FqParameters as Fq_params, fft::FpParameters}, Fq};
+use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
+use mina_curves::pasta::{
+    fields::{fft::FpParameters, fq::FqParameters as Fq_params},
+    Fq,
+};
 use num_bigint::BigUint;
 use rand::rngs::StdRng;
 use std::{

src/lib/crypto/kimchi_bindings/stubs/src/caml/caml_pointer.rs

@@ -12,8 +12,8 @@ macro_rules! impl_caml_pointer {
             }
 
             extern "C" fn caml_pointer_compare(_: ocaml::Raw, _: ocaml::Raw) -> i32 {
-                // Always return equal. We can use this for sanity checks, and anything else using this
-                // would be broken anyway.
+                // Always return equal. We can use this for sanity checks, and
+                // anything else using this would be broken anyway.
                 0
             }
         }
@@ -49,12 +49,14 @@ macro_rules! impl_caml_pointer {
                 unsafe {
                     // Wholely unsafe, Batman!
                     // We would use [`get_mut_unchecked`] here, but it is nightly-only.
-                    // Instead, we get coerce our constant pointer to a mutable pointer, in the knowledge
-                    // that
-                    // * all of our mutations called from OCaml are blocking, so we won't have multiple
-                    // live mutable references live simultaneously, and
-                    // * the underlying pointer is in the correct state to be mutable, since we can call
-                    //   [`get_mut_unchecked`] in nightly, or can call [`get_mut`] and unwrap if this is
+                    // Instead, we get coerce our constant pointer to a mutable
+                    // pointer, in the knowledge that
+                    // * all of our mutations called from OCaml are blocking, so
+                    // we won't have multiple live mutable references live
+                    // simultaneously, and
+                    // * the underlying pointer is in the correct state to be
+                    //   mutable, since we can call [`get_mut_unchecked`] in
+                    //   nightly, or can call [`get_mut`] and unwrap if this is
                     //   the only live reference.
                     &mut *(((&*self.0) as *const Self::Target) as *mut Self::Target)
                 }

src/lib/crypto/kimchi_bindings/stubs/src/field_vector.rs

@@ -1,4 +1,5 @@
-//! We implement a custom type for field vectors in order to quickly build field vectors from the OCaml side and avoid large vector clones.
+//! We implement a custom type for field vectors in order to quickly build field
+//! vectors from the OCaml side and avoid large vector clones.
 
 use paste::paste;
 

src/lib/crypto/kimchi_bindings/stubs/src/lagrange_basis.rs

@@ -2,7 +2,9 @@ use ark_ec::AffineRepr;
 use ark_poly::{EvaluationDomain, Radix2EvaluationDomain as D};
 use cache::LagrangeCache;
 use mina_curves::pasta::{Pallas, Vesta};
-use poly_commitment::{commitment::CommitmentCurve, srs::SRS};
+use poly_commitment::commitment::CommitmentCurve;
+use poly_commitment::ipa::SRS;
+use poly_commitment::SRS as _;
 use std::env;
 
 pub trait WithLagrangeBasis<G: AffineRepr> {
@@ -42,7 +44,6 @@ fn add_lagrange_basis_with_cache<G: CommitmentCurve, C: LagrangeCache<G>>(
     }
     if let Some(basis) = cache.load_lagrange_basis_from_cache(srs.g.len(), &domain) {
         srs.lagrange_bases.get_or_generate(n, || basis);
-        return;
     } else {
         let basis = srs.get_lagrange_basis(domain);
         cache.cache_lagrange_basis(srs.g.len(), &domain, basis);
@@ -81,7 +82,7 @@ mod cache {
             &self,
             srs_length: usize,
             domain: &D<G::ScalarField>,
-            basis: &Vec<PolyComm<G>>,
+            basis: &[PolyComm<G>],
         );
     }
 
@@ -100,10 +101,9 @@ mod cache {
         }
     }
 
-    /*
-    The FileCache implementation uses a directory as a cache for the Lagrange basis hash map --
-    i.e every file corresponds to a Lagrange basis for a given G-basis and domain size.
-    */
+    // The FileCache implementation uses a directory as a cache for the Lagrange
+    // basis hash map -- i.e every file corresponds to a Lagrange basis for a
+    // given G-basis and domain size.
     impl<G: AffineRepr> LagrangeCache<G> for FileCache<G> {
         type CacheKey = PathBuf;
 
@@ -115,7 +115,7 @@ mod cache {
             self.cache_dir.clone().join(format!(
                 "lagrange_basis_{:}-{:}",
                 srs_length,
-                domain.size().to_string()
+                domain.size()
             ))
         }
 
@@ -126,14 +126,13 @@ mod cache {
         ) -> Option<Vec<PolyComm<G>>> {
             let cache_key = self.lagrange_basis_cache_key(srs_length, domain);
             if Path::exists(&cache_key) {
-                let f = File::open(cache_key.clone()).expect(&format!(
-                    "Missing lagrange basis cache file {:?}",
-                    cache_key
-                ));
-                let basis: Vec<PolyComm<G>> = rmp_serde::decode::from_read(f).expect(&format!(
-                    "Error decoding lagrange cache file {:?}",
-                    cache_key
-                ));
+                let f = File::open(cache_key.clone()).unwrap_or_else(|_| {
+                    panic!("Missing lagrange basis cache file {:?}", cache_key)
+                });
+                let basis: Vec<PolyComm<G>> =
+                    rmp_serde::decode::from_read(f).unwrap_or_else(|_| {
+                        panic!("Error decoding lagrange cache file {:?}", cache_key)
+                    });
                 Some(basis)
             } else {
                 None
@@ -144,26 +143,22 @@ mod cache {
             &self,
             srs_length: usize,
             domain: &D<G::ScalarField>,
-            basis: &Vec<PolyComm<G>>,
+            basis: &[PolyComm<G>],
         ) {
             let cache_key = self.lagrange_basis_cache_key(srs_length, domain);
-            if Path::exists(&cache_key) {
-                return;
-            } else {
-                let mut f = File::create(cache_key.clone()).expect(&format!(
-                    "Error creating lagrabnge basis cache file {:?}",
-                    cache_key
-                ));
-                rmp_serde::encode::write(&mut f, basis).expect(&format!(
-                    "Error encoding lagrange basis to file {:?}",
-                    cache_key
-                ));
+            if !Path::exists(&cache_key) {
+                let mut f = File::create(cache_key.clone()).unwrap_or_else(|_| {
+                    panic!("Error creating lagrabnge basis cache file {:?}", cache_key)
+                });
+                rmp_serde::encode::write(&mut f, basis).unwrap_or_else(|_| {
+                    panic!("Error encoding lagrange basis to file {:?}", cache_key)
+                });
             }
         }
     }
 
-    // The following two caches are all that we need for mina tests. These will not be initialized unless they are
-    // explicitly called.
+    // The following two caches are all that we need for mina tests. These will
+    // not be initialized unless they are explicitly called.
     static VESTA_FILE_CACHE: Lazy<FileCache<Vesta>> = Lazy::new(|| {
         let cache_base_dir: String =
             env::var("LAGRANGE_CACHE_DIR").expect("LAGRANGE_CACHE_DIR missing in env");
@@ -175,7 +170,7 @@ mod cache {
     });
 
     pub fn get_vesta_file_cache() -> &'static FileCache<Vesta> {
-        &*VESTA_FILE_CACHE
+        &VESTA_FILE_CACHE
     }
 
     static PALLAS_FILE_CACHE: Lazy<FileCache<Pallas>> = Lazy::new(|| {
@@ -189,6 +184,6 @@ mod cache {
     });
 
     pub fn get_pallas_file_cache() -> &'static FileCache<Pallas> {
-        &*PALLAS_FILE_CACHE
+        &PALLAS_FILE_CACHE
     }
 }

src/lib/crypto/kimchi_bindings/stubs/src/lib.rs

@@ -68,5 +68,6 @@ pub use {
         CamlLookupCommitments, CamlProofWithPublic, CamlProverCommitments, CamlProverProof,
     },
     mina_poseidon::sponge::caml::CamlScalarChallenge,
-    poly_commitment::commitment::caml::{CamlOpeningProof, CamlPolyComm},
+    poly_commitment::commitment::caml::CamlPolyComm,
+    poly_commitment::ipa::caml::CamlOpeningProof,
 };

src/lib/crypto/kimchi_bindings/stubs/src/linearization.rs

@@ -7,12 +7,13 @@ use kimchi::{
     linearization::{constraints_expr, linearization_columns},
 };
 
-/// Converts the linearization of the kimchi circuit polynomial into a printable string.
+/// Converts the linearization of the kimchi circuit polynomial into a printable
+/// string.
 pub fn linearization_strings<F: ark_ff::PrimeField>(
     uses_custom_gates: bool,
 ) -> (String, Vec<(String, String)>)
-    where
-        num_bigint::BigUint: From<F::BigInt>,
+where
+    num_bigint::BigUint: From<F::BigInt>,
 {
     let features = if uses_custom_gates {
         None
@@ -44,8 +45,8 @@ pub fn linearization_strings<F: ark_ff::PrimeField>(
         mut index_terms,
     } = linearization.linearize(evaluated_cols).unwrap();
 
-    // HashMap deliberately uses an unstable order; here we sort to ensure that the output is
-    // consistent when printing.
+    // HashMap deliberately uses an unstable order; here we sort to ensure that
+    // the output is consistent when printing.
     index_terms.sort_by(|(x, _), (y, _)| x.cmp(y));
 
     let constant = constant_term.ocaml_str();