Working MainPod serialization (but might need a code re-org now)

Author: robknight

Cargo.toml

@@ -18,6 +18,7 @@ dyn-clone = "1.0.18"
 plonky2 = { git = "https://github.com/0xPolygonZero/plonky2", optional = true }
 serde = "1.0.219"
 serde_json = "1.0.140"
+base64 = "0.22.1"
 
 [features]
 default = ["backend_plonky2"]

src/backends/plonky2/basetypes.rs

@@ -2,6 +2,10 @@
 //! `backend_plonky2` feature is enabled.
 //! See src/middleware/basetypes.rs for more details.
 
+use crate::frontend::serialization::{
+    deserialize_hash_tuple, deserialize_value_tuple, serialize_hash_tuple, serialize_value_tuple,
+};
+use crate::middleware::{Params, ToFields};
 use anyhow::{anyhow, Error, Result};
 use hex::{FromHex, FromHexError};
 use plonky2::field::goldilocks_field::GoldilocksField;
@@ -10,11 +14,10 @@ use plonky2::hash::poseidon::PoseidonHash;
 use plonky2::plonk::config::Hasher;
 use plonky2::plonk::config::PoseidonGoldilocksConfig;
 use plonky2::plonk::proof::Proof as Plonky2Proof;
+use serde::{Deserialize, Serialize};
 use std::cmp::{Ord, Ordering};
 use std::fmt;
 
-use crate::middleware::{Params, ToFields};
-
 /// F is the native field we use everywhere.  Currently it's Goldilocks from plonky2
 pub type F = GoldilocksField;
 /// C is the Plonky2 config used in POD2 to work with Plonky2 recursion.
@@ -32,8 +35,14 @@ pub const EMPTY: Value = Value([F::ZERO, F::ZERO, F::ZERO, F::ZERO]);
 pub const SELF_ID_HASH: Hash = Hash([F::ONE, F::ZERO, F::ZERO, F::ZERO]);
 pub const NULL: Hash = Hash([F::ZERO, F::ZERO, F::ZERO, F::ZERO]);
 
-#[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq)]
-pub struct Value(pub [F; VALUE_SIZE]);
+#[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Value(
+    #[serde(
+        serialize_with = "serialize_value_tuple",
+        deserialize_with = "deserialize_value_tuple"
+    )]
+    pub [F; VALUE_SIZE],
+);
 
 impl ToFields for Value {
     fn to_fields(&self, _params: &Params) -> (Vec<F>, usize) {
@@ -115,8 +124,14 @@ impl fmt::Display for Value {
     }
 }
 
-#[derive(Clone, Copy, Debug, Default, Hash, Eq, PartialEq)]
-pub struct Hash(pub [F; HASH_SIZE]);
+#[derive(Clone, Copy, Debug, Default, Hash, Eq, PartialEq, Serialize, Deserialize)]
+pub struct Hash(
+    #[serde(
+        serialize_with = "serialize_hash_tuple",
+        deserialize_with = "deserialize_hash_tuple"
+    )]
+    pub [F; HASH_SIZE],
+);
 
 pub fn hash_value(input: &Value) -> Hash {
     Hash(PoseidonHash::hash_no_pad(&input.0).elements)

src/backends/plonky2/mock_main/mod.rs

@@ -4,6 +4,8 @@ use plonky2::hash::poseidon::PoseidonHash;
 use plonky2::plonk::config::Hasher;
 use std::any::Any;
 use std::fmt;
+use serde::{Deserialize, Serialize};
+use base64::prelude::*;
 
 use crate::middleware::{
     self, hash_str, AnchoredKey, Hash, MainPodInputs, NativeOperation, NativePredicate, NonePod,
@@ -26,14 +28,14 @@ impl PodProver for MockProver {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MockMainPod {
     params: Params,
     id: PodId,
-    input_signed_pods: Vec<Box<dyn Pod>>,
-    input_main_pods: Vec<Box<dyn Pod>>,
+ //   input_signed_pods: Vec<Box<dyn Pod>>,
+ //   input_main_pods: Vec<Box<dyn Pod>>,
     // New statements introduced by this pod
-    input_statements: Vec<Statement>,
+ //   input_statements: Vec<Statement>,
     public_statements: Vec<Statement>,
     operations: Vec<Operation>,
     // All statements (inherited + new)
@@ -331,9 +333,9 @@ impl MockMainPod {
         Ok(Self {
             params: params.clone(),
             id,
-            input_signed_pods,
-            input_main_pods,
-            input_statements,
+          //  input_signed_pods,
+          //  input_main_pods,
+          //  input_statements,
             public_statements,
             statements,
             operations,
@@ -470,7 +472,7 @@ impl Pod for MockMainPod {
     }
 
     fn serialized_proof(&self) -> String {
-        "".to_string()
+        BASE64_STANDARD.encode(serde_json::to_string(self).unwrap())
     }
 }
 

src/backends/plonky2/mock_main/operation.rs

@@ -1,10 +1,10 @@
 use anyhow::Result;
 use std::fmt;
-
+use serde::{Deserialize, Serialize};
 use super::Statement;
 use crate::middleware::{self, OperationType};
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub enum OperationArg {
     None,
     Index(usize),
@@ -16,7 +16,7 @@ impl OperationArg {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Operation(pub OperationType, pub Vec<OperationArg>);
 
 impl Operation {

src/backends/plonky2/mock_main/statement.rs

@@ -1,11 +1,12 @@
 use anyhow::{anyhow, Result};
 use std::fmt;
+use serde::{Deserialize, Serialize};
 
 use crate::middleware::{
     self, AnchoredKey, NativePredicate, Params, Predicate, StatementArg, ToFields,
 };
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Statement(pub Predicate, pub Vec<StatementArg>);
 
 impl Statement {

src/frontend/mod.rs

@@ -18,22 +18,22 @@ use crate::middleware::{OperationType, Predicate, KEY_SIGNER, KEY_TYPE};
 pub mod containers;
 mod custom;
 mod operation;
-mod serialization;
+pub mod serialization;
 mod statement;
 pub use custom::*;
 pub use operation::*;
 pub use statement::*;
 
 /// This type is just for presentation purposes.
-#[derive(Clone, Debug, Default, h::Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, h::Hash, PartialEq, Eq, Serialize, Deserialize)]
 pub enum PodClass {
     #[default]
     Signed,
     Main,
 }
 
 // An Origin, which represents a reference to an ancestor POD.
-#[derive(Clone, Debug, PartialEq, Eq, h::Hash, Default)]
+#[derive(Clone, Debug, PartialEq, Eq, h::Hash, Default, Serialize, Deserialize)]
 pub struct Origin(pub PodClass, pub PodId);
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -238,7 +238,7 @@ impl SignedPod {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, h::Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, h::Hash, Serialize, Deserialize)]
 pub struct AnchoredKey(pub Origin, pub String);
 
 impl From<AnchoredKey> for middleware::AnchoredKey {

src/frontend/serialization.rs

@@ -1,16 +1,19 @@
 use std::collections::HashMap;
 
+use base64::prelude::*;
 use serde::ser::{SerializeStruct, Serializer};
 use serde::{Deserialize, Serialize};
 
+use crate::backends::plonky2::mock_main::MockMainPod;
 use crate::backends::plonky2::mock_signed::MockSignedPod;
 use crate::frontend::containers::Dictionary;
-use crate::middleware::{PodId, F};
-use crate::middleware;
+use crate::frontend::Statement;
+use crate::middleware::{self, HASH_SIZE, VALUE_SIZE};
+use crate::middleware::{Hash, PodId, F};
 use plonky2::field::types::Field;
 
-use super::SignedPod;
 use super::Value;
+use super::{MainPod, SignedPod};
 
 impl Serialize for SignedPod {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -44,9 +47,13 @@ impl<'de> Deserialize<'de> for SignedPod {
         struct SignedPodHelper {
             entries: HashMap<String, Value>,
             proof: String,
+            pod_type: String,
         }
 
         let helper = SignedPodHelper::deserialize(deserializer)?;
+        if helper.pod_type != "signed" {
+            return Err(serde::de::Error::custom("pod_type is not signed"));
+        }
         let kvs = helper.entries;
         let dict = Dictionary::new(kvs.clone()).middleware_dict().clone();
         let pod = MockSignedPod::new(PodId(dict.commitment()), helper.proof, dict);
@@ -57,6 +64,45 @@ impl<'de> Deserialize<'de> for SignedPod {
     }
 }
 
+impl Serialize for MainPod {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut state = serializer.serialize_struct("MainPod", 2)?;
+        state.serialize_field("public_statements", &self.public_statements)?;
+        state.serialize_field("proof", &self.pod.serialized_proof())?;
+        state.serialize_field("pod_type", "main")?;
+        state.end()
+    }
+}
+
+impl<'de> Deserialize<'de> for MainPod {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct MainPodHelper {
+            public_statements: Vec<Statement>,
+            proof: String,
+            pod_type: String,
+        }
+
+        let helper = MainPodHelper::deserialize(deserializer)?;
+        if helper.pod_type != "main" {
+            return Err(serde::de::Error::custom("pod_type is not main"));
+        }
+        let proof = String::from_utf8(BASE64_STANDARD.decode(&helper.proof).unwrap()).unwrap();
+        let pod: MockMainPod = serde_json::from_str(&proof).unwrap();
+
+        Ok(MainPod {
+            pod: Box::new(pod),
+            public_statements: helper.public_statements,
+        })
+    }
+}
+
 pub fn serialize_i64<S>(value: &i64, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: serde::Serializer,
@@ -100,12 +146,70 @@ where
     Ok(middleware::Value(v))
 }
 
+pub fn serialize_hash_tuple<S>(value: &[F; HASH_SIZE], serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serializer.serialize_str(&format!(
+        "{:016x}{:016x}{:016x}{:016x}",
+        value[0].0, value[1].0, value[2].0, value[3].0
+    ))
+}
+
+pub fn deserialize_hash_tuple<'de, D>(deserializer: D) -> Result<[F; HASH_SIZE], D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let hex_str = String::deserialize(deserializer)?;
+    let mut v = [F::ZERO; 4];
+    for i in 0..4 {
+        let start = i * 16;
+        let end = start + 16;
+        let hex_part = &hex_str[start..end];
+        v[i] = F::from_canonical_u64(
+            u64::from_str_radix(hex_part, 16).map_err(serde::de::Error::custom)?,
+        );
+    }
+    Ok(v)
+}
+
+pub fn serialize_value_tuple<S>(value: &[F; VALUE_SIZE], serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serializer.serialize_str(&format!(
+        "{:016x}{:016x}{:016x}{:016x}",
+        value[0].0, value[1].0, value[2].0, value[3].0
+    ))
+}
+
+pub fn deserialize_value_tuple<'de, D>(deserializer: D) -> Result<[F; VALUE_SIZE], D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let hex_str = String::deserialize(deserializer)?;
+    let mut v = [F::ZERO; VALUE_SIZE];
+    for i in 0..VALUE_SIZE {
+        let start = i * 16;
+        let end = start + 16;
+        let hex_part = &hex_str[start..end];
+        v[i] = F::from_canonical_u64(
+            u64::from_str_radix(hex_part, 16).map_err(serde::de::Error::custom)?,
+        );
+    }
+    Ok(v)
+}
+
 #[cfg(test)]
 mod tests {
     use crate::{
-        backends::plonky2::mock_signed::MockSigner,
-        frontend::{containers::{Dictionary, Array, Set}, SignedPodBuilder},
-        middleware::Params,
+        backends::plonky2::{mock_main::MockProver, mock_signed::MockSigner},
+        examples::{zu_kyc_pod_builder, zu_kyc_sign_pod_builders},
+        frontend::{
+            containers::{Array, Dictionary, Set},
+            MainPodBuilder, Operation, OperationArg, SignedPodBuilder,
+        },
+        middleware::{NativeOperation, OperationType, Params},
     };
 
     use super::*;
@@ -172,4 +276,37 @@ mod tests {
         assert_eq!(pod.verify(), deserialized.verify());
         assert_eq!(pod.id(), deserialized.id())
     }
+
+    #[test]
+    fn test_main_pod_serialization() {
+        let params = middleware::Params::default();
+
+        let (gov_id_builder, pay_stub_builder, sanction_list_builder) =
+            zu_kyc_sign_pod_builders(&params);
+        let mut signer = MockSigner {
+            pk: "ZooGov".into(),
+        };
+        let gov_id_pod = gov_id_builder.sign(&mut signer).unwrap();
+        let mut signer = MockSigner {
+            pk: "ZooDeel".into(),
+        };
+        let pay_stub_pod = pay_stub_builder.sign(&mut signer).unwrap();
+        let mut signer = MockSigner {
+            pk: "ZooOFAC".into(),
+        };
+        let sanction_list_pod = sanction_list_builder.sign(&mut signer).unwrap();
+        let kyc_builder =
+            zu_kyc_pod_builder(&params, &gov_id_pod, &pay_stub_pod, &sanction_list_pod).unwrap();
+
+        let mut prover = MockProver {};
+        let kyc_pod = kyc_builder.prove(&mut prover, &params).unwrap();
+
+        let serialized = serde_json::to_string(&kyc_pod).unwrap();
+        println!("serialized: {}", serialized);
+        let deserialized: MainPod = serde_json::from_str(&serialized).unwrap();
+
+        assert_eq!(kyc_pod.public_statements, deserialized.public_statements);
+        assert_eq!(kyc_pod.pod.id(), deserialized.pod.id());
+        assert_eq!(kyc_pod.pod.verify(), deserialized.pod.verify());
+    }
 }