1  // Copyright (c) 2025-2026 ACDC Network
  2  // This file is part of the alphavm library.
  3  //
  4  // Alpha Chain | Delta Chain Protocol
  5  // International Monetary Graphite.
  6  //
  7  // Derived from Aleo (https://aleo.org) and ProvableHQ (https://provable.com).
  8  // They built world-class ZK infrastructure. We installed the EASY button.
  9  // Their cryptography: elegant. Our modifications: bureaucracy-compatible.
 10  // Original brilliance: theirs. Robert's Rules: ours. Bugs: definitely ours.
 11  //
 12  // Original Aleo/ProvableHQ code subject to Apache 2.0 https://www.apache.org/licenses/LICENSE-2.0
 13  // All modifications and new work: CC0 1.0 Universal Public Domain Dedication.
 14  // No rights reserved. No permission required. No warranty. No refunds.
 15  //
 16  // https://creativecommons.org/publicdomain/zero/1.0/
 17  // SPDX-License-Identifier: CC0-1.0
 18  
 19  use super::*;
 20  
 21  impl<N: Network> Serialize for PlaintextType<N> {
 22      /// Serializes the plaintext type into string or bytes.
 23      fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
 24          match serializer.is_human_readable() {
 25              true => serializer.collect_str(self),
 26              false => ToBytesSerializer::serialize_with_size_encoding(self, serializer),
 27          }
 28      }
 29  }
 30  
 31  impl<'de, N: Network> Deserialize<'de> for PlaintextType<N> {
 32      /// Deserializes the plaintext type from a string or bytes.
 33      fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
 34          match deserializer.is_human_readable() {
 35              true => FromStr::from_str(&String::deserialize(deserializer)?).map_err(de::Error::custom),
 36              false => FromBytesDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "plaintext type"),
 37          }
 38      }
 39  }
 40  
 41  #[cfg(test)]
 42  mod tests {
 43      use super::*;
 44      use alphavm_console_network::MainnetV0;
 45  
 46      type CurrentNetwork = MainnetV0;
 47  
 48      /// Add test cases here to be checked for serialization.
 49      const TEST_CASES: &[&str] = &[
 50          // Literal
 51          "address",
 52          "boolean",
 53          "field",
 54          "group",
 55          "i8",
 56          "i16",
 57          "i32",
 58          "i64",
 59          "i128",
 60          "u8",
 61          "u16",
 62          "u32",
 63          "u64",
 64          "u128",
 65          "scalar",
 66          "string",
 67          // Struct
 68          "signature",
 69          "message",
 70          "item",
 71          "passport",
 72          "object",
 73          "array",
 74      ];
 75  
 76      fn check_serde_json<
 77          T: Serialize + for<'a> Deserialize<'a> + Debug + Display + PartialEq + Eq + FromStr + ToBytes + FromBytes,
 78      >(
 79          expected: T,
 80      ) {
 81          // Serialize
 82          let expected_string = &expected.to_string();
 83          let candidate_string = serde_json::to_string(&expected).unwrap();
 84          assert_eq!(expected_string, serde_json::Value::from_str(&candidate_string).unwrap().as_str().unwrap());
 85  
 86          // Deserialize
 87          assert_eq!(expected, T::from_str(expected_string).unwrap_or_else(|_| panic!("FromStr: {expected_string}")));
 88          assert_eq!(expected, serde_json::from_str(&candidate_string).unwrap());
 89      }
 90  
 91      fn check_bincode<
 92          T: Serialize + for<'a> Deserialize<'a> + Debug + Display + PartialEq + Eq + FromStr + ToBytes + FromBytes,
 93      >(
 94          expected: T,
 95      ) {
 96          // Serialize
 97          let expected_bytes = expected.to_bytes_le().unwrap();
 98          let expected_bytes_with_size_encoding = bincode::serialize(&expected).unwrap();
 99          assert_eq!(&expected_bytes[..], &expected_bytes_with_size_encoding[8..]);
100  
101          // Deserialize
102          assert_eq!(expected, T::read_le(&expected_bytes[..]).unwrap());
103          assert_eq!(expected, bincode::deserialize(&expected_bytes_with_size_encoding[..]).unwrap());
104      }
105  
106      #[test]
107      fn test_serde_json() {
108          for case in TEST_CASES.iter().chain(crate::data_types::array_type::serialize::tests::TEST_CASES) {
109              check_serde_json(PlaintextType::<CurrentNetwork>::from_str(case).unwrap());
110          }
111      }
112  
113      #[test]
114      fn test_bincode() {
115          for case in TEST_CASES.iter().chain(crate::data_types::array_type::serialize::tests::TEST_CASES) {
116              check_bincode(PlaintextType::<CurrentNetwork>::from_str(case).unwrap());
117          }
118      }
119  }