diff --git a/enigma-tools-m/Cargo.toml b/enigma-tools-m/Cargo.toml index dfbe720f..c5e9f4d8 100644 --- a/enigma-tools-m/Cargo.toml +++ b/enigma-tools-m/Cargo.toml @@ -19,7 +19,7 @@ rustc-hex = { version = "2.0.1", default-features = false } ethabi_std = { package = "ethabi", version = "6.0.1", optional = true } ethereum_types_std = { package = "ethereum-types", version = "0.4", optional = true } rmp_serde_std = { package = "rmp-serde", git = "https://github.com/3Hren/msgpack-rust.git", optional = true } -serde_std = { package = "serde", version = "1.0", default-features = false, optional = true } +serde_std = { package = "serde", version = "1.0", default-features = false, features = ["derive"], optional = true } serde_json_std = { package = "serde_json", version = "1.0", optional = true } @@ -28,7 +28,7 @@ ethabi_sgx = { package = "ethabi", git = "https://github.com/enigmampc/ethabi.gi ethereum_types_sgx = { package = "ethereum-types", git = "https://github.com/enigmampc/primitives.git", rev = "sgx-v0.4.0", default-features = false, optional = true } rmp_serde_sgx = { package = "rmp-serde", git = "https://github.com/enigmampc/msgpack-rust.git", rev = "0.14.0-sgx-1.0.8", optional = true } sgx_tstd = { git = "https://github.com/baidu/rust-sgx-sdk.git", rev = "v1.0.8", optional = true } -serde_sgx = { package = "serde", git = "https://github.com/mesalock-linux/serde-sgx.git", rev = "407aaaa2558dda5c2367d57ba40324c52cf9acc2", default-features = false, optional = true } +serde_sgx = { package = "serde", git = "https://github.com/mesalock-linux/serde-sgx.git", rev = "407aaaa2558dda5c2367d57ba40324c52cf9acc2", default-features = false, features = ["derive"], optional = true } serde_json_sgx = { package = "serde_json", git = "https://github.com/enigmampc/serde-json-sgx.git", rev = "1.0.39-sgx-1.0.8", optional = true } [features] diff --git a/enigma-tools-m/src/primitives/km_primitives.rs b/enigma-tools-m/src/primitives/km_primitives.rs index 04017b10..4349981d 100644 --- a/enigma-tools-m/src/primitives/km_primitives.rs +++ b/enigma-tools-m/src/primitives/km_primitives.rs @@ -8,14 +8,16 @@ use enigma_types::{ContractAddress, DhKey, PubKey, StateKey}; pub type MsgID = [u8; 12]; -#[derive(Debug, PartialEq, Clone)] +#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)] +#[serde(crate = "crate::serde")] pub enum PrincipalMessageType { Response(Vec<(ContractAddress, StateKey)>), Request(Option>), EncryptedResponse(Vec), } -#[derive(Debug, PartialEq, Clone)] +#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)] +#[serde(crate = "crate::serde")] pub struct PrincipalMessage { pub data: PrincipalMessageType, pub(crate) pubkey: Vec, @@ -131,7 +133,8 @@ impl<'a> Encryption<&'a DhKey, CryptoError, Self, [u8; 12]> for PrincipalMessage } } -#[derive(Debug, PartialEq, Clone)] +#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)] +#[serde(crate = "crate::serde")] pub struct UserMessage { pub(crate) pubkey: Vec, } diff --git a/enigma-tools-m/src/primitives/mod.rs b/enigma-tools-m/src/primitives/mod.rs index 20cc0d91..7026788d 100644 --- a/enigma-tools-m/src/primitives/mod.rs +++ b/enigma-tools-m/src/primitives/mod.rs @@ -1,2 +1 @@ -pub mod km_primitives; -pub mod serde_impls; +pub mod km_primitives; \ No newline at end of file diff --git a/enigma-tools-m/src/primitives/serde_impls.rs b/enigma-tools-m/src/primitives/serde_impls.rs deleted file mode 100644 index fa1eaee5..00000000 --- a/enigma-tools-m/src/primitives/serde_impls.rs +++ /dev/null @@ -1,224 +0,0 @@ -use crate::localstd::fmt::{self, Formatter}; -use crate::localstd::vec::Vec; -use crate::primitives::km_primitives::*; -use crate::serde::{de::{EnumAccess, Error, IgnoredAny, MapAccess, SeqAccess, Unexpected, VariantAccess, Visitor}, - ser::SerializeStruct, - Deserialize, Deserializer, Serialize, Serializer}; -use enigma_types::{ContractAddress, StateKey}; -// The main reason why we need to implement Serialize/Deserialize ourselves is because the derive macro -// contains `extern crate serde as _serde` but we renamed serde. so that's invalid. https://github.com/serde-rs/serde/pull/1499 -impl Serialize for UserMessage { - fn serialize(&self, ser: S) -> Result - where S: Serializer { - let mut state = Serializer::serialize_struct(ser, "UserMessage", 1)?; - state.serialize_field("pubkey", &self.pubkey)?; - state.end() - } -} - -impl<'de> Deserialize<'de> for UserMessage { - fn deserialize(des: D) -> Result - where D: Deserializer<'de> { - struct UserMessageVisitor; - - impl<'de> Visitor<'de> for UserMessageVisitor { - type Value = UserMessage; - fn expecting(&self, fmt: &mut Formatter) -> fmt::Result { fmt.write_str("struct UserMessage") } - - fn visit_seq(self, mut seq: A) -> Result - where A: SeqAccess<'de> { - let err_msg = "struct UserMessage with 1 elements"; - let pubkey = seq.next_element::>()?.ok_or_else(|| Error::invalid_length(0, &err_msg))?; - if pubkey.len() != 64 { - return Err(Error::invalid_value(Unexpected::Bytes(&pubkey), &"The pubkey should be 64 bytes")); - } - Ok(UserMessage { pubkey }) - } - } - - des.deserialize_newtype_struct("UserMessage", UserMessageVisitor) - } -} - -impl Serialize for PrincipalMessageType { - fn serialize(&self, ser: S) -> Result - where S: Serializer { - match *self { - PrincipalMessageType::Response(ref f) => ser.serialize_newtype_variant("PrincipalMessageType", 0, "Response", f), - PrincipalMessageType::Request(ref f) => ser.serialize_newtype_variant("PrincipalMessageType", 1, "Request", f), - PrincipalMessageType::EncryptedResponse(ref f) => { - ser.serialize_newtype_variant("PrincipalMessageType", 2, "EncryptedResponse", f) - } - } - } -} - -impl<'de> Deserialize<'de> for PrincipalMessageType { - #[inline] - fn deserialize(des: D) -> Result - where D: Deserializer<'de> { - enum PrincipalMessageTypeFields { - Response, - Request, - EncryptedResponse, - } - struct FieldsVisitor; - - struct PrincipalMessageTypeVisitor; - const VARIANTS: &[&str] = &["Response", "Request", "EncryptedResponse"]; - - impl<'de> Visitor<'de> for FieldsVisitor { - type Value = PrincipalMessageTypeFields; - fn expecting(&self, fmt: &mut Formatter) -> fmt::Result { fmt.write_str("variant identifier") } - fn visit_str(self, value: &str) -> Result - where E: Error { - match value { - "Response" => Ok(PrincipalMessageTypeFields::Response), - "Request" => Ok(PrincipalMessageTypeFields::Request), - "EncryptedResponse" => Ok(PrincipalMessageTypeFields::EncryptedResponse), - _ => Err(Error::unknown_variant(value, VARIANTS)), - } - } - } - - impl<'de> Deserialize<'de> for PrincipalMessageTypeFields { - #[inline] - fn deserialize(des: D) -> Result - where D: Deserializer<'de> { - des.deserialize_identifier(FieldsVisitor) - } - } - - impl<'de> Visitor<'de> for PrincipalMessageTypeVisitor { - type Value = PrincipalMessageType; - fn expecting(&self, fmt: &mut Formatter) -> fmt::Result { fmt.write_str("enum PrincipalMessageType") } - fn visit_enum(self, data: A) -> Result - where A: EnumAccess<'de> { - match data.variant()? { - (PrincipalMessageTypeFields::Response, var) => { - var.newtype_variant::>().map(PrincipalMessageType::Response) - } - (PrincipalMessageTypeFields::Request, var) => { - var.newtype_variant::>>().map(PrincipalMessageType::Request) - } - (PrincipalMessageTypeFields::EncryptedResponse, var) => { - var.newtype_variant::>().map(PrincipalMessageType::EncryptedResponse) - } - } - } - } - - des.deserialize_enum("PrincipalMessageType", VARIANTS, PrincipalMessageTypeVisitor) - } -} - -impl Serialize for PrincipalMessage { - fn serialize(&self, ser: S) -> Result - where S: Serializer { - let mut state = Serializer::serialize_struct(ser, "PrincipalMessage", 3)?; - state.serialize_field("data", &self.data)?; - state.serialize_field("pubkey", &self.pubkey)?; - state.serialize_field("id", &self.id)?; - state.end() - } -} - -impl<'de> Deserialize<'de> for PrincipalMessage { - fn deserialize(des: D) -> Result - where D: Deserializer<'de> { - #[allow(non_camel_case_types)] - enum PrincipalMessageFields { - data, - pubkey, - id, - __ignore, - } - struct FieldsVisitor; - struct PrincipalMessageVisitor; - const VARIANTS: &[&str] = &["prefix", "data", "pubkey", "id"]; - - impl<'de> Visitor<'de> for FieldsVisitor { - type Value = PrincipalMessageFields; - fn expecting(&self, fmt: &mut Formatter) -> fmt::Result { fmt.write_str("field identifier") } - fn visit_str(self, value: &str) -> Result - where E: Error { - match value { - "data" => Ok(PrincipalMessageFields::data), - "pubkey" => Ok(PrincipalMessageFields::pubkey), - "id" => Ok(PrincipalMessageFields::id), - _ => Ok(PrincipalMessageFields::__ignore), - } - } - } - - impl<'de> Deserialize<'de> for PrincipalMessageFields { - #[inline] - fn deserialize(des: D) -> Result - where D: Deserializer<'de> { - des.deserialize_identifier(FieldsVisitor) - } - } - - impl<'de> Visitor<'de> for PrincipalMessageVisitor { - type Value = PrincipalMessage; - fn expecting(&self, fmt: &mut Formatter) -> fmt::Result { fmt.write_str("struct PrincipalMessage") } - - fn visit_seq(self, mut seq: A) -> Result - where A: SeqAccess<'de> { - let err_msg = "struct PrincipalMessage with 3 elements"; - let data = seq.next_element::()?.ok_or_else(|| Error::invalid_length(0, &err_msg))?; - let pubkey = seq.next_element::>()?.ok_or_else(|| Error::invalid_length(1, &err_msg))?; - if pubkey.len() != 64 { - return Err(Error::invalid_value(Unexpected::Bytes(&pubkey), &"The pubkey should be 64 bytes")); - } - let id = seq.next_element::()?.ok_or_else(|| Error::invalid_length(2, &err_msg))?; - - Ok(PrincipalMessage { data, pubkey, id }) - } - - fn visit_map(self, mut map: A) -> Result - where A: MapAccess<'de> { - let mut data: Option = None; - let mut pubkey: Option> = None; - let mut id: Option = None; - - while let Some(key) = map.next_key::()? { - match key { - PrincipalMessageFields::data => { - if data.is_some() { - return Err(::duplicate_field("data")); - } else { - data = Some(map.next_value()?); - } - } - PrincipalMessageFields::pubkey => { - if pubkey.is_some() { - return Err(::duplicate_field("pubkey")); - } else { - pubkey = Some(map.next_value()?); - } - } - PrincipalMessageFields::id => { - if id.is_some() { - return Err(::duplicate_field("id")); - } else { - id = Some(map.next_value()?); - } - } - _ => { - map.next_value::()?; - } - } - } - - let data = data.ok_or_else(|| Error::missing_field("data"))?; - let pubkey = pubkey.ok_or_else(|| Error::missing_field("pubkey"))?; - let id = id.ok_or_else(|| Error::missing_field("id"))?; - - Ok(PrincipalMessage { data, pubkey, id }) - } - } - - des.deserialize_struct("PrincipalMessage", VARIANTS, PrincipalMessageVisitor) - } -}