Deserialize evaluations

Author: xqft

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

@@ -1,8 +1,16 @@
-use kimchi::{circuits::wires::COLUMNS, mina_curves::pasta::Pallas, poly_commitment::PolyComm};
+use kimchi::{
+    circuits::wires::{COLUMNS, PERMUTS},
+    mina_curves::pasta::{Fq, Pallas},
+    poly_commitment::PolyComm,
+    proof::PointEvaluations,
+};
 
 use crate::pickles_preproc::{
-    state_proof::{Bulletproof, Commitments},
-    type_aliases::{WrapECPoint, WrapOpeningProof, WrapProverCommitments, WrapScalar},
+    state_proof::{Bulletproof, Commitments, Evaluations},
+    type_aliases::{
+        WrapECPoint, WrapOpeningProof, WrapPointEvaluations, WrapProofEvaluations,
+        WrapProverCommitments, WrapScalar,
+    },
 };
 
 use super::{
@@ -75,6 +83,85 @@ pub fn deserialize_state_proof(
         z2,
     };
 
+    let Evaluations {
+        coefficients: hex_coefficients,
+        complete_add_selector: hex_complete_add_selector,
+        emul_selector: hex_emul_selector,
+        endomul_scalar_selector: hex_endomul_scalar_selector,
+        generic_selector: hex_generic_selector,
+        mul_selector: hex_mul_selector,
+        poseidon_selector: hex_poseidon_selector,
+        s: hex_s,
+        w: hex_w,
+        z: hex_z,
+    } = state_proof.proof.evaluations;
+
+    let mut w: [PointEvaluations<Vec<Fq>>; COLUMNS] = std::array::from_fn(|_| PointEvaluations {
+        zeta: Vec::with_capacity(1),
+        zeta_omega: Vec::with_capacity(1),
+    });
+    for (hex_eval, eval) in hex_w.into_iter().zip(w.iter_mut()) {
+        *eval = WrapPointEvaluations::try_from(hex_eval)?.0;
+    }
+
+    let z = WrapPointEvaluations::try_from(hex_z)?.0;
+
+    let mut s: [PointEvaluations<Vec<Fq>>; PERMUTS - 1] =
+        std::array::from_fn(|_| PointEvaluations {
+            zeta: Vec::with_capacity(1),
+            zeta_omega: Vec::with_capacity(1),
+        });
+    for (hex_eval, eval) in hex_s.into_iter().zip(s.iter_mut()) {
+        *eval = WrapPointEvaluations::try_from(hex_eval)?.0;
+    }
+
+    let mut coefficients: [PointEvaluations<Vec<Fq>>; COLUMNS] =
+        std::array::from_fn(|_| PointEvaluations {
+            zeta: Vec::with_capacity(1),
+            zeta_omega: Vec::with_capacity(1),
+        });
+    for (hex_eval, eval) in hex_coefficients.into_iter().zip(coefficients.iter_mut()) {
+        *eval = WrapPointEvaluations::try_from(hex_eval)?.0;
+    }
+
+    let generic_selector = WrapPointEvaluations::try_from(hex_generic_selector)?.0;
+    let poseidon_selector = WrapPointEvaluations::try_from(hex_poseidon_selector)?.0;
+    let complete_add_selector = WrapPointEvaluations::try_from(hex_complete_add_selector)?.0;
+    let mul_selector = WrapPointEvaluations::try_from(hex_mul_selector)?.0;
+    let emul_selector = WrapPointEvaluations::try_from(hex_emul_selector)?.0;
+    let endomul_scalar_selector = WrapPointEvaluations::try_from(hex_endomul_scalar_selector)?.0;
+
+    let public = None; // TODO: Calculate public poly evaluations
+
+    let _evals = WrapProofEvaluations {
+        public,
+        w,
+        z,
+        s,
+        coefficients,
+        generic_selector,
+        poseidon_selector,
+        complete_add_selector,
+        mul_selector,
+        emul_selector,
+        endomul_scalar_selector,
+        range_check0_selector: None,
+        range_check1_selector: None,
+        foreign_field_add_selector: None,
+        foreign_field_mul_selector: None,
+        xor_selector: None,
+        rot_selector: None,
+        lookup_aggregation: None,
+        lookup_table: None,
+        lookup_sorted: std::array::from_fn(|_| None),
+        runtime_lookup_table: None,
+        runtime_lookup_table_selector: None,
+        xor_lookup_selector: None,
+        lookup_gate_lookup_selector: None,
+        range_check_lookup_selector: None,
+        foreign_field_mul_lookup_selector: None,
+    };
+
     /*
         let prover_proof = WrapProverProof {
             commitments,

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

@@ -1,12 +1,16 @@
-use kimchi::mina_curves::pasta::{Fp, Fq, Pallas};
+use kimchi::{
+    mina_curves::pasta::{Fp, Fq, Pallas},
+    proof::PointEvaluations,
+};
 use o1_utils::FieldHelpers;
 use serde::Deserialize;
 
-use super::type_aliases::{WrapECPoint, WrapScalar};
+use super::type_aliases::{WrapECPoint, WrapPointEvaluations, WrapScalar};
 
 type DecimalSigned = String;
-type HexPointCoordinates = [String; 2];
 type HexScalar = String;
+type HexPointCoordinates = [String; 2];
+type HexPointEvaluations = [String; 2];
 
 #[derive(Deserialize)]
 pub struct StateProof {
@@ -40,16 +44,16 @@ pub struct Commitments {
 
 #[derive(Deserialize)]
 pub struct Evaluations {
-    pub coefficients: [HexPointCoordinates; 15],
-    pub complete_add_selector: HexPointCoordinates,
-    pub emul_selector: HexPointCoordinates,
-    pub endomul_scalar_selector: HexPointCoordinates,
-    pub generic_selector: HexPointCoordinates,
-    pub mul_selector: HexPointCoordinates,
-    pub poseidon_selector: HexPointCoordinates,
-    pub s: [HexPointCoordinates; 6],
-    pub w: [HexPointCoordinates; 15],
-    pub z: HexPointCoordinates,
+    pub coefficients: [HexPointEvaluations; 15],
+    pub complete_add_selector: HexPointEvaluations,
+    pub emul_selector: HexPointEvaluations,
+    pub endomul_scalar_selector: HexPointEvaluations,
+    pub generic_selector: HexPointEvaluations,
+    pub mul_selector: HexPointEvaluations,
+    pub poseidon_selector: HexPointEvaluations,
+    pub s: [HexPointEvaluations; 6],
+    pub w: [HexPointEvaluations; 15],
+    pub z: HexPointEvaluations,
 }
 
 #[derive(Deserialize)]
@@ -143,6 +147,17 @@ impl TryFrom<HexScalar> for WrapScalar {
     }
 }
 
+impl TryFrom<HexPointEvaluations> for WrapPointEvaluations {
+    type Error = String;
+
+    fn try_from(value: HexPointEvaluations) -> Result<Self, Self::Error> {
+        let [hex_zeta, hex_zeta_omega] = value;
+        let zeta = vec![WrapScalar::try_from(hex_zeta)?.0];
+        let zeta_omega = vec![WrapScalar::try_from(hex_zeta_omega)?.0];
+        Ok(WrapPointEvaluations(PointEvaluations { zeta, zeta_omega }))
+    }
+}
+
 pub fn parse(mina_state_proof_vk_query_str: &str) -> Result<StateProof, String> {
     let mina_state_proof_vk_query: serde_json::Map<String, serde_json::Value> =
         serde_json::from_str(mina_state_proof_vk_query_str)

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

@@ -1,15 +1,19 @@
 use kimchi::{
     mina_curves::pasta::{Fq, Pallas},
-    poly_commitment::{evaluation_proof::OpeningProof, PolyComm},
-    proof::{ProverCommitments, ProverProof},
+    poly_commitment::evaluation_proof::OpeningProof,
+    proof::{PointEvaluations, ProofEvaluations, ProverCommitments, ProverProof},
     verifier_index::VerifierIndex,
 };
 
 // Wrap circuit specific types
+
 pub struct WrapECPoint(pub Pallas);
 pub struct WrapScalar(pub Fq);
-pub struct WrapPolyComm(pub PolyComm<Pallas>);
+pub struct WrapPointEvaluations(pub PointEvaluations<Vec<Fq>>);
+
 pub type WrapVerifierIndex = VerifierIndex<Pallas, WrapOpeningProof>;
+
 pub type WrapProverProof = ProverProof<Pallas, WrapOpeningProof>;
 pub type WrapProverCommitments = ProverCommitments<Pallas>;
 pub type WrapOpeningProof = OpeningProof<Pallas>;
+pub type WrapProofEvaluations = ProofEvaluations<PointEvaluations<Vec<Fq>>>;