[ledger] Remove get_srs and type alias Verifier{Index,SRS}

Author: sebastiencs

cli/src/commands/node/mod.rs

@@ -152,7 +152,7 @@ impl Node {
 
         let work_dir = shellexpand::full(&self.work_dir).unwrap().into_owned();
         let rng_seed = rng.next_u64();
-        let srs: Arc<_> = get_srs().into();
+        let srs: Arc<_> = get_srs();
         let config = Config {
             ledger: LedgerConfig {},
             snark: SnarkConfig {

cli/src/commands/snark/precalculate_block_verifier_index_and_srs.rs

@@ -20,7 +20,11 @@ impl PrecalculateBlockVerifierIndexAndSrs {
         hasher.update(&verifier_index);
         let index_hash = hex::encode(hasher.finalize());
 
-        let srs = srs_to_bytes(&get_srs());
+        let srs = {
+            let srs = get_srs();
+            let srs = srs.lock().expect("Failed to lock SRS");
+            srs_to_bytes(&srs)
+        };
         let mut hasher = Sha256::new();
         hasher.update(&srs);
         let srs_hash = hex::encode(hasher.finalize());

ledger/src/proofs/accumulator_check.rs

@@ -1,7 +1,6 @@
 use std::array;
 
-use kimchi::curve::KimchiCurve;
-use mina_curves::pasta::{Fq, Pallas, Vesta};
+use mina_curves::pasta::{Fq, Vesta};
 use mina_hasher::Fp;
 use mina_p2p_messages::{bigint::BigInt, v2::PicklesProofProofsVerified2ReprStableV2};
 use poly_commitment::{commitment::CommitmentCurve, srs::SRS};
@@ -10,15 +9,8 @@ use super::public_input::scalar_challenge::ScalarChallenge;
 use super::transaction::endos;
 use super::urs_utils;
 
-const OTHER_URS_LENGTH: usize = 65536;
-
-pub fn get_srs() -> super::VerifierSRS {
-    // We need an URS with 65536 points (should be in the other verfifier index - step?)
-    SRS::<<Pallas as KimchiCurve>::OtherCurve>::create(OTHER_URS_LENGTH)
-}
-
 pub fn accumulator_check(
-    urs: &super::VerifierSRS,
+    urs: &SRS<Vesta>,
     proof: &PicklesProofProofsVerified2ReprStableV2,
 ) -> bool {
     // accumulator check

ledger/src/proofs/caching.rs

@@ -12,16 +12,14 @@ use kimchi::{
         wires::{COLUMNS, PERMUTS},
     },
     mina_curves::pasta::Pallas,
-    verifier_index::LookupVerifierIndex,
+    verifier_index::{LookupVerifierIndex, VerifierIndex},
 };
 use mina_curves::pasta::Fq;
 use mina_p2p_messages::bigint::BigInt;
 use once_cell::sync::OnceCell;
 use poly_commitment::{commitment::CommitmentCurve, srs::SRS, PolyComm};
 use serde::{Deserialize, Serialize};
 
-use super::VerifierIndex;
-
 fn into<'a, U, T>(slice: &'a [U]) -> Vec<T>
 where
     T: From<&'a U>,
@@ -275,8 +273,8 @@ where
     }
 }
 
-impl From<&VerifierIndex> for VerifierIndexCached {
-    fn from(v: &VerifierIndex) -> Self {
+impl From<&VerifierIndex<Pallas>> for VerifierIndexCached {
+    fn from(v: &VerifierIndex<Pallas>) -> Self {
         Self {
             domain: (&v.domain).into(),
             max_poly_size: v.max_poly_size,
@@ -303,7 +301,7 @@ impl From<&VerifierIndex> for VerifierIndexCached {
     }
 }
 
-impl From<&VerifierIndexCached> for VerifierIndex {
+impl From<&VerifierIndexCached> for VerifierIndex<Pallas> {
     fn from(v: &VerifierIndexCached) -> Self {
         Self {
             domain: (&v.domain).into(),
@@ -349,7 +347,7 @@ impl From<&VerifierIndexCached> for VerifierIndex {
     }
 }
 
-pub fn verifier_index_to_bytes(verifier: &VerifierIndex) -> Vec<u8> {
+pub fn verifier_index_to_bytes(verifier: &VerifierIndex<Pallas>) -> Vec<u8> {
     const NBYTES: usize = 5328359;
 
     let verifier: VerifierIndexCached = verifier.into();
@@ -359,7 +357,7 @@ pub fn verifier_index_to_bytes(verifier: &VerifierIndex) -> Vec<u8> {
     bytes
 }
 
-pub fn verifier_index_from_bytes(bytes: &[u8]) -> VerifierIndex {
+pub fn verifier_index_from_bytes(bytes: &[u8]) -> VerifierIndex<Pallas> {
     let verifier: VerifierIndexCached = bincode::deserialize(bytes).unwrap();
     (&verifier).into()
 }

ledger/src/proofs/mod.rs

@@ -1,5 +1,3 @@
-use kimchi::mina_curves::pasta::{Pallas, Vesta};
-
 pub mod accumulator_check;
 pub mod block;
 pub mod caching;
@@ -24,9 +22,5 @@ pub mod witness;
 pub mod wrap;
 pub mod zkapp;
 
-pub type VerifierIndex = kimchi::verifier_index::VerifierIndex<Pallas>;
-pub type ProverProof = kimchi::proof::ProverProof<Pallas>;
-pub type VerifierSRS = poly_commitment::srs::SRS<Vesta>;
-
 pub const BACKEND_TICK_ROUNDS_N: usize = 16;
 pub const BACKEND_TOCK_ROUNDS_N: usize = 15;

ledger/src/proofs/prover.rs

@@ -2,7 +2,9 @@ use std::{array, borrow::Cow, str::FromStr};
 
 use kimchi::{
     poly_commitment::PolyComm,
-    proof::{PointEvaluations, ProofEvaluations, ProverCommitments, RecursionChallenge},
+    proof::{
+        PointEvaluations, ProofEvaluations, ProverCommitments, ProverProof, RecursionChallenge,
+    },
 };
 use mina_curves::pasta::Pallas;
 use mina_hasher::Fp;
@@ -15,8 +17,6 @@ use super::util::extract_bulletproof;
 use mina_curves::pasta::Fq;
 use mina_p2p_messages::{bigint::BigInt, v2::PicklesProofProofsVerified2ReprStableV2};
 
-use super::ProverProof;
-
 fn get_challenge_polynomial_commitments_padding() -> (BigInt, BigInt) {
     static PADDING: Lazy<(BigInt, BigInt)> = Lazy::new(|| {
         let first = Fp::from_str(
@@ -40,7 +40,7 @@ pub fn make_padded_proof_from_p2p(
         prev_evals: _, // unused
         proof,
     }: &PicklesProofProofsVerified2ReprStableV2,
-) -> ProverProof {
+) -> ProverProof<Pallas> {
     let of_coord = |(a, b): &(BigInt, BigInt)| Pallas::of_coordinates(a.to_field(), b.to_field());
 
     let make_poly = |poly: &(BigInt, BigInt)| PolyComm {

ledger/src/proofs/public_input/messages.rs

@@ -3,17 +3,17 @@ use std::str::FromStr;
 use crate::proofs::to_field_elements::ToFieldElements;
 use crate::proofs::transaction::{checked_hash2, InnerCurve, PlonkVerificationKeyEvals};
 use crate::proofs::witness::Witness;
-use crate::proofs::VerifierIndex;
 use ark_ec::short_weierstrass_jacobian::GroupAffine;
 use ark_ff::{BigInteger256, PrimeField};
+use kimchi::verifier_index::VerifierIndex;
 use mina_curves::{pasta::Fq, pasta::Pallas};
 use mina_hasher::Fp;
 use poly_commitment::PolyComm;
 
 use crate::hash::hash_fields;
 
-impl<'a> From<&'a VerifierIndex> for PlonkVerificationKeyEvals<Fp> {
-    fn from(verifier_index: &'a VerifierIndex) -> Self {
+impl<'a> From<&'a VerifierIndex<Pallas>> for PlonkVerificationKeyEvals<Fp> {
+    fn from(verifier_index: &'a VerifierIndex<Pallas>) -> Self {
         let to_curve = |v: &PolyComm<Pallas>| InnerCurve::of_affine(v.unshifted[0]);
 
         Self {

ledger/src/proofs/verification.rs

@@ -1,6 +1,7 @@
 use std::{array, rc::Rc};
 
 use ark_poly::{EvaluationDomain, Radix2EvaluationDomain};
+use poly_commitment::srs::SRS;
 
 use crate::{
     proofs::{
@@ -27,15 +28,15 @@ use super::{
     to_field_elements::ToFieldElements,
     transaction::{InnerCurve, PlonkVerificationKeyEvals},
     util::{extract_bulletproof, extract_polynomial_commitment, u64_to_field},
-    VerifierSRS,
 };
 use kimchi::{
     circuits::{polynomials::permutation::eval_zk_polynomial, wires::PERMUTS},
     error::VerifyError,
     mina_curves::pasta::Pallas,
-    proof::{PointEvaluations, ProofEvaluations},
+    proof::{PointEvaluations, ProofEvaluations, ProverProof},
+    verifier_index::VerifierIndex,
 };
-use mina_curves::pasta::Fq;
+use mina_curves::pasta::{Fq, Vesta};
 use mina_hasher::Fp;
 use mina_p2p_messages::{
     bigint::BigInt,
@@ -50,7 +51,7 @@ use mina_p2p_messages::{
     },
 };
 
-use super::{prover::make_padded_proof_from_p2p, ProverProof, VerifierIndex};
+use super::prover::make_padded_proof_from_p2p;
 
 use super::public_input::{
     messages::{MessagesForNextStepProof, MessagesForNextWrapProof},
@@ -409,8 +410,8 @@ where
 }
 
 fn verify_with(
-    verifier_index: &VerifierIndex,
-    proof: &ProverProof,
+    verifier_index: &VerifierIndex<Pallas>,
+    proof: &ProverProof<Pallas>,
     public_input: &[Fq],
 ) -> Result<(), VerifyError> {
     use kimchi::groupmap::GroupMap;
@@ -433,7 +434,7 @@ fn verify_with(
 
 fn run_checks(
     proof: &PicklesProofProofsVerified2ReprStableV2,
-    verifier_index: &VerifierIndex,
+    verifier_index: &VerifierIndex<Pallas>,
 ) -> bool {
     let mut errors: Vec<String> = vec![];
     let mut checks = |condition: bool, s: &str| {
@@ -594,14 +595,14 @@ fn compute_deferred_values(proof: &PicklesProofProofsVerified2ReprStableV2) -> D
 /// https://github.com/MinaProtocol/mina/blob/4e0b324912017c3ff576704ee397ade3d9bda412/src/lib/pickles/verification_key.mli#L30
 pub struct VK<'a> {
     pub commitments: PlonkVerificationKeyEvals<Fp>,
-    pub index: &'a VerifierIndex,
+    pub index: &'a VerifierIndex<Pallas>,
     pub data: (), // Unused in proof verification
 }
 
 pub fn verify_block(
     header: &MinaBlockHeaderStableV2,
-    verifier_index: &VerifierIndex,
-    srs: &VerifierSRS,
+    verifier_index: &VerifierIndex<Pallas>,
+    srs: &SRS<Vesta>,
 ) -> bool {
     let MinaBlockHeaderStableV2 {
         protocol_state,
@@ -622,8 +623,8 @@ pub fn verify_block(
 
 pub fn verify_transaction<'a>(
     proofs: impl IntoIterator<Item = (&'a Statement<SokDigest>, &'a TransactionSnarkProofStableV2)>,
-    verifier_index: &VerifierIndex,
-    srs: &VerifierSRS,
+    verifier_index: &VerifierIndex<Pallas>,
+    srs: &SRS<Vesta>,
 ) -> bool {
     let vk = VK {
         commitments: PlonkVerificationKeyEvals::from(verifier_index),
@@ -643,7 +644,7 @@ pub fn verify_zkapp(
     verification_key: &VerificationKey,
     zkapp_statement: ZkappStatement,
     sideloaded_proof: &PicklesProofProofsVerified2ReprStableV2,
-    srs: &VerifierSRS,
+    srs: &SRS<Vesta>,
 ) -> bool {
     let verifier_index = make_zkapp_verifier_index(verification_key);
     // https://github.com/MinaProtocol/mina/blob/4e0b324912017c3ff576704ee397ade3d9bda412/src/lib/pickles/pickles.ml#LL260C1-L274C18

ledger/src/proofs/verifier_index.rs

@@ -12,6 +12,8 @@ use kimchi::{
     },
     curve::KimchiCurve,
     linearization::expr_linearization,
+    mina_curves::pasta::Pallas,
+    verifier_index::VerifierIndex,
 };
 use mina_curves::pasta::Fq;
 
@@ -24,11 +26,11 @@ use crate::{
     VerificationKey,
 };
 
+use super::transaction::InnerCurve;
 use super::{
     transaction::endos,
     wrap::{Domain, Domains},
 };
-use super::{transaction::InnerCurve, VerifierIndex};
 
 const PERMUTS: usize = 7;
 const COLUMNS: usize = 15;
@@ -38,7 +40,7 @@ pub enum VerifierKind {
     Transaction,
 }
 
-pub fn get_verifier_index(kind: VerifierKind) -> VerifierIndex {
+pub fn get_verifier_index(kind: VerifierKind) -> VerifierIndex<Pallas> {
     let make = |data: &str| {
         let verifier_index: kimchi::verifier_index::VerifierIndex<GroupAffine<Fp>> =
             serde_json::from_str(data).unwrap();
@@ -47,12 +49,12 @@ pub fn get_verifier_index(kind: VerifierKind) -> VerifierIndex {
 
     match kind {
         VerifierKind::Blockchain => {
-            cache_one!(VerifierIndex, {
+            cache_one!(VerifierIndex<Pallas>, {
                 make(include_str!("data/blockchain_verifier_index.json"))
             })
         }
         VerifierKind::Transaction => {
-            cache_one!(VerifierIndex, {
+            cache_one!(VerifierIndex<Pallas>, {
                 make(include_str!("data/transaction_verifier_index.json"))
             })
         }
@@ -61,7 +63,7 @@ pub fn get_verifier_index(kind: VerifierKind) -> VerifierIndex {
 
 fn make_verifier_index(
     index: kimchi::verifier_index::VerifierIndex<GroupAffine<Fp>>,
-) -> VerifierIndex {
+) -> VerifierIndex<Pallas> {
     let domain = index.domain;
     let max_poly_size: usize = index.max_poly_size;
     let (endo, _) = endos::<Fq>();
@@ -147,7 +149,7 @@ pub fn wrap_domains(proofs_verified: usize) -> Domains {
 }
 
 /// https://github.com/MinaProtocol/mina/blob/bfd1009abdbee78979ff0343cc73a3480e862f58/src/lib/pickles/side_loaded_verification_key.ml#L206
-pub fn make_zkapp_verifier_index(vk: &VerificationKey) -> VerifierIndex {
+pub fn make_zkapp_verifier_index(vk: &VerificationKey) -> VerifierIndex<Pallas> {
     let d = wrap_domains(vk.actual_wrap_domain_size.to_int());
     let log2_size = d.h.log2_size();
 

ledger/src/verifier/mod.rs

@@ -1,9 +1,7 @@
 use std::sync::{Arc, Mutex};
 
 use crate::{
-    proofs::{
-        field::FieldWitness, verification, verifier_index::get_verifier_index, VerifierIndex,
-    },
+    proofs::{field::FieldWitness, verification, verifier_index::get_verifier_index},
     scan_state::{
         scan_state::transaction_snark::{
             LedgerProof, LedgerProofWithSokMessage, SokMessage, TransactionSnark,
@@ -19,6 +17,7 @@ use self::common::CheckResult;
 #[derive(Debug, Clone)]
 pub struct Verifier;
 
+use kimchi::{mina_curves::pasta::Pallas, verifier_index::VerifierIndex};
 use mina_hasher::Fp;
 use mina_p2p_messages::v2::{
     PicklesProofProofsVerified2ReprStableV2, PicklesProofProofsVerifiedMaxStableV2,
@@ -28,7 +27,7 @@ use once_cell::sync::Lazy;
 use poly_commitment::srs::SRS;
 
 // TODO: Move this into `Verifier` struct above
-pub static VERIFIER_INDEX: Lazy<Arc<VerifierIndex>> = Lazy::new(|| {
+pub static VERIFIER_INDEX: Lazy<Arc<VerifierIndex<Pallas>>> = Lazy::new(|| {
     use crate::proofs::verifier_index::VerifierKind;
     Arc::new(get_verifier_index(VerifierKind::Transaction))
 });