Started deserialization of state proof

Author: xqft

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

@@ -1,10 +1,53 @@
-use super::type_aliases::{WrapProverProof, WrapVerifierIndex};
+use kimchi::{circuits::wires::COLUMNS, mina_curves::pasta::Pallas, poly_commitment::PolyComm};
 
-pub fn preprocess_state_proof(//state_proof_json: StateProof,
-) -> (WrapVerifierIndex, WrapProverProof) {
-    /*
-        let commitments = WrapProverCommitments {};
+use crate::pickles_preproc::type_aliases::{WrapECPoint, WrapProverCommitments};
+
+use super::{
+    state_proof::StateProof,
+    type_aliases::{WrapProverProof, WrapVerifierIndex},
+};
+
+pub fn deserialize_state_proof(
+    state_proof: StateProof,
+) -> Result<(WrapVerifierIndex, WrapProverProof), String> {
+    // w_comm are single-point commitments
+    let mut w_comm: [PolyComm<Pallas>; COLUMNS] = std::array::from_fn(|_| PolyComm {
+        elems: Vec::with_capacity(1),
+    });
+    for (hex_comm, comm) in state_proof
+        .proof
+        .commitments
+        .w_comm
+        .into_iter()
+        .zip(w_comm.iter_mut())
+    {
+        comm.elems.push(WrapECPoint::try_from(hex_comm)?.0);
+    }
+
+    // z_comm is a single-point commitment
+    let z_comm = PolyComm {
+        elems: vec![WrapECPoint::try_from(state_proof.proof.commitments.z_comm)?.0],
+    };
+    // t_comm is a multi-point commitment
+    let t_comm = PolyComm {
+        elems: state_proof
+            .proof
+            .commitments
+            .t_comm
+            .into_iter()
+            .map(|hex_point| WrapECPoint::try_from(hex_point).map(|point| point.0))
+            .collect::<Result<_, _>>()?,
+    };
+    let lookup = None;
 
+    let _commitments = WrapProverCommitments {
+        w_comm,
+        z_comm,
+        t_comm,
+        lookup,
+    };
+
+    /*
         let prover_proof = WrapProverProof {
             commitments,
             proof,
@@ -13,6 +56,7 @@ pub fn preprocess_state_proof(//state_proof_json: StateProof,
             prev_challenges,
         };
     */
+
     todo!()
 }
 

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

@@ -1,11 +1,8 @@
-use kimchi::{
-    mina_curves::pasta::{Fp, Fq, Pallas},
-    poly_commitment::PolyComm,
-};
+use kimchi::mina_curves::pasta::{Fp, Fq, Pallas};
 use o1_utils::FieldHelpers;
 use serde::Deserialize;
 
-use super::type_aliases::{WrapPolyComm, WrapScalar};
+use super::type_aliases::{WrapECPoint, WrapScalar};
 
 type DecimalSigned = String;
 type HexPointCoordinates = [String; 2];
@@ -19,6 +16,9 @@ pub struct StateProof {
 
 #[derive(Deserialize)]
 pub struct Proof {
+    pub commitments: Commitments,
+    pub evaluations: Evaluations,
+    pub ft_eval1: HexScalar,
     pub bulletproof: Bulletproof,
 }
 
@@ -33,9 +33,9 @@ pub struct Bulletproof {
 
 #[derive(Deserialize)]
 pub struct Commitments {
-    pub t_comm: [HexPointCoordinates; 7],
     pub w_comm: [HexPointCoordinates; 15],
     pub z_comm: HexPointCoordinates,
+    pub t_comm: Vec<HexPointCoordinates>,
 }
 
 #[derive(Deserialize)]
@@ -50,7 +50,6 @@ pub struct Evaluations {
     pub s: [HexPointCoordinates; 6],
     pub w: [HexPointCoordinates; 15],
     pub z: HexPointCoordinates,
-    pub ft_eval1: HexScalar,
 }
 
 #[derive(Deserialize)]
@@ -124,14 +123,13 @@ pub struct MessagesForNextWrapProof {
     pub old_bulletproof_challenges: [[BulletproofChallenge; 16]; 2],
 }
 
-impl TryFrom<HexPointCoordinates> for WrapPolyComm {
+impl TryFrom<HexPointCoordinates> for WrapECPoint {
     type Error = String;
 
     fn try_from(value: HexPointCoordinates) -> Result<Self, Self::Error> {
         let x = Fp::from_hex(&value[0]).map_err(|err| err.to_string())?;
         let y = Fp::from_hex(&value[1]).map_err(|err| err.to_string())?;
-        let p = Pallas::new(x, y, false);
-        Ok(WrapPolyComm(PolyComm { elems: vec![p] }))
+        Ok(WrapECPoint(Pallas::new(x, y, false)))
     }
 }
 

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

@@ -6,8 +6,9 @@ use kimchi::{
 };
 
 // Wrap circuit specific types
-pub struct WrapPolyComm(pub PolyComm<Pallas>);
+pub struct WrapECPoint(pub Pallas);
 pub struct WrapScalar(pub Fq);
+pub struct WrapPolyComm(pub PolyComm<Pallas>);
 pub type WrapVerifierIndex = VerifierIndex<Pallas, WrapOpeningProof>;
 pub type WrapProverProof = ProverProof<Pallas, WrapOpeningProof>;
 pub type WrapProverCommitments = ProverCommitments<Pallas>;