Merge pull request #1 from lambdaclass/pickles

Start implementing pickles preproc

Author: xqft

batcher/aligned/test_files/mina/mina_state_proof_vk_query.json

@@ -13,6 +13,8 @@ use kimchi::{
     verifier_index::VerifierIndex,
 };
 
+mod pickles_preproc;
+
 const MAX_PROOF_SIZE: usize = 10 * 1024;
 const MAX_PUB_INPUT_SIZE: usize = 50 * 1024;
 

operator/mina/lib/src/lib.rs

@@ -0,0 +1,4 @@
+target/
+
+protocolStateProof.json
+blockchainVerificationKey.json

operator/mina/lib/src/pickles_preproc/.gitignore

@@ -0,0 +1,26 @@
+use std::fs;
+
+use state_proof::parse;
+// use verifier::verify;
+
+pub mod preprocess;
+pub mod state_proof;
+pub mod type_aliases;
+pub mod verifier;
+
+pub fn parse_and_verify(proof_file_path: &str) -> Result<(), String> {
+    let proof_query_str = fs::read_to_string(proof_file_path)
+        .map_err(|err| format!("Could not read proof file: {err}"))?;
+    let proof_query: serde_json::Map<String, serde_json::Value> =
+        serde_json::from_str(&proof_query_str)
+            .map_err(|err| format!("Could not parse proof file as JSON: {err}"))?;
+    let protocol_state_proof_json = proof_query
+        .get("data")
+        .and_then(|d| d.get("bestChain"))
+        .and_then(|d| d.get(0))
+        .and_then(|d| d.get("protocolStateProof"))
+        .and_then(|d| d.get("json")).ok_or("Could not parse protocol state proof: JSON structure upto protocolStateProof is unexpected")?;
+    let _protocol_state_proof = parse(protocol_state_proof_json)?;
+
+    Ok(())
+}

operator/mina/lib/src/pickles_preproc/lib.rs

@@ -0,0 +1,8 @@
+use pickles::parse_and_verify;
+
+fn main() -> Result<(), String> {
+    let args: Vec<String> = std::env::args().collect();
+    let proof_file_path = args.get(1).ok_or("Error: No proof file path provided")?;
+
+    parse_and_verify(proof_file_path)
+}

operator/mina/lib/src/pickles_preproc/main.rs

@@ -0,0 +1,4 @@
+pub mod preprocess;
+pub mod state_proof;
+pub mod type_aliases;
+pub mod verifier;

operator/mina/lib/src/pickles_preproc/mod.rs

@@ -0,0 +1,23 @@
+use crate::{
+    state_proof::StateProof,
+    type_aliases::{WrapProverCommitments, WrapProverProof, WrapVerifierIndex},
+};
+
+pub fn preprocess_state_proof(
+    state_proof_json: StateProof,
+) -> (WrapVerifierIndex, WrapProverProof) {
+    let commitments = WrapProverCommitments {};
+
+    let prover_proof = WrapProverProof {
+        commitments,
+        proof,
+        evals,
+        ft_eval1,
+        prev_challenges,
+    };
+    todo!()
+}
+
+pub fn compute_prev_challenges() {
+    todo!()
+}

operator/mina/lib/src/pickles_preproc/preprocess.rs

@@ -0,0 +1,134 @@
+use kimchi::mina_curves::pasta::Pallas;
+use serde::Deserialize;
+
+use crate::type_aliases::WrapPolyComm;
+
+#[derive(Deserialize)]
+pub struct StateProof {
+    pub proof: Proof,
+    pub statement: Statement,
+}
+
+#[derive(Deserialize)]
+pub struct Proof {
+    pub bulletproof: Bulletproof,
+}
+
+#[derive(Deserialize)]
+pub struct Bulletproof {
+    pub challenge_polynomial_commitment: Point,
+    pub delta: Point,
+    pub lr: [[Point; 2]; 15],
+    pub z_1: Scalar,
+    pub z_2: Scalar,
+}
+
+#[derive(Deserialize)]
+pub struct Commitments {
+    pub t_comm: [Point; 7],
+    pub w_comm: [Point; 15],
+    pub z_comm: Point,
+}
+
+#[derive(Deserialize)]
+pub struct Evaluations {
+    pub coefficients: [Point; 15],
+    pub complete_add_selector: Point,
+    pub emul_selector: Point,
+    pub endomul_scalar_selector: Point,
+    pub generic_selector: Point,
+    pub mul_selector: Point,
+    pub poseidon_selector: Point,
+    pub s: [Point; 6],
+    pub w: [Point; 15],
+    pub z: Point,
+    pub ft_eval1: Scalar,
+}
+
+#[derive(Deserialize)]
+pub struct Statement {
+    pub messages_for_next_step_proof: MessagesForNextStepProof,
+}
+
+#[derive(Deserialize)]
+pub struct MessagesForNextStepProof {
+    pub challenge_polynomial_commitments: [Point; 2],
+    pub old_bulletproof_challenges: [[BulletproofChallenge; 16]; 2],
+}
+
+#[derive(Deserialize)]
+pub struct BulletproofChallenge {
+    pub prechallenge: Prechallenge,
+}
+
+#[derive(Deserialize)]
+pub struct Prechallenge {
+    // OCaml doesn't support unsigned integers, these should
+    // be two u64 limbs but are encoded with a sign.
+    // We just need to do a cast to u64.
+    pub inner: [I64; 2],
+}
+
+#[derive(Deserialize)]
+pub struct ProofState {
+    pub deferred_values: DeferredValues,
+    pub messages_for_next_wrap_proof: MessagesForNextWrapProof,
+    pub sponge_digest_before_evaluations: [Scalar; 4],
+}
+
+#[derive(Deserialize)]
+pub struct DeferredValues {
+    pub branch_data: BranchData,
+    pub bulletproof_challenges: [BulletproofChallenge; 16],
+    pub plonk: Plonk,
+}
+
+#[derive(Deserialize)]
+pub struct BranchData {
+    pub domain_log2: String,
+    pub proofs_verified: [String; 1],
+}
+
+#[derive(Deserialize)]
+pub struct Plonk {
+    pub alpha: Prechallenge,
+    pub beta: Point,
+    pub feature_flags: FeatureFlags,
+    pub gamma: Point,
+    pub zeta: Prechallenge,
+}
+
+#[derive(Deserialize)]
+pub struct FeatureFlags {
+    pub foreign_field_add: bool,
+    pub foreign_field_mul: bool,
+    pub lookup: bool,
+    pub range_check0: bool,
+    pub range_check1: bool,
+    pub rot: bool,
+    pub runtime_tables: bool,
+    pub xor: bool,
+}
+
+#[derive(Deserialize)]
+pub struct MessagesForNextWrapProof {
+    pub challenge_polynomial_commitment: Point,
+    pub old_bulletproof_challenges: [[BulletproofChallenge; 16]; 2],
+}
+
+pub type Point = [String; 2]; // hex
+pub type Scalar = String; // hex
+pub type I64 = String; // decimal signed
+
+pub fn parse(proof_json: &serde_json::Value) -> Result<StateProof, String> {
+    serde_json::from_value(proof_json.to_owned())
+        .map_err(|err| format!("Could not parse proof: {err}"))
+}
+
+impl Into<WrapPolyComm> for Point {
+    fn into(self) -> WrapPolyComm {
+        from hex
+        basefield from big endian
+        Pallas
+    }
+}

operator/mina/lib/src/pickles_preproc/state_proof.rs

@@ -0,0 +1,13 @@
+use kimchi::{
+    mina_curves::pasta::Pallas,
+    poly_commitment::{evaluation_proof::OpeningProof, PolyComm},
+    proof::{ProverCommitments, ProverProof},
+    verifier_index::VerifierIndex,
+};
+
+// Wrap circuit specific types
+pub type WrapPolyComm = PolyComm<Pallas>;
+pub type WrapVerifierIndex = VerifierIndex<Pallas, WrapOpeningProof>;
+pub type WrapProverProof = ProverProof<Pallas, WrapOpeningProof>;
+pub type WrapProverCommitments = ProverCommitments<Pallas>;
+pub type WrapOpeningProof = OpeningProof<Pallas>;

operator/mina/lib/src/pickles_preproc/type_aliases.rs

@@ -0,0 +1,20 @@
+// use kimchi::{
+//     groupmap::GroupMap,
+//     mina_curves::pasta::{Fp, Fq, Pallas, PallasParameters},
+//     mina_poseidon::{
+//         constants::PlonkSpongeConstantsKimchi,
+//         sponge::{DefaultFqSponge, DefaultFrSponge},
+//     },
+//     verifier::batch_verify,
+// };
+
+// pub fn verify() -> Result<(), String> {
+//     let group_map = GroupMap::<Fp>::setup();
+
+//     batch_verify::<
+//         Pallas,
+//         DefaultFqSponge<PallasParameters, PlonkSpongeConstantsKimchi>,
+//         DefaultFrSponge<Fq, PlonkSpongeConstantsKimchi>,
+//     >(group_map, proofs)
+//     .map_err(|err| format!("Could not verify Kimchi proof: {err}"))
+// }