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 ValueType<N> {
 22      /// Serializes the value 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 ValueType<N> {
 32      /// Deserializes the value 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, "value 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          // Future
 75          "future",
 76      ];
 77  
 78      fn check_serde_json<
 79          T: Serialize + for<'a> Deserialize<'a> + Debug + Display + PartialEq + Eq + FromStr + ToBytes + FromBytes,
 80      >(
 81          expected: T,
 82      ) {
 83          // Serialize
 84          let expected_string = &expected.to_string();
 85          let candidate_string = serde_json::to_string(&expected).unwrap();
 86          assert_eq!(expected_string, serde_json::Value::from_str(&candidate_string).unwrap().as_str().unwrap());
 87  
 88          // Deserialize
 89          assert_eq!(expected, T::from_str(expected_string).unwrap_or_else(|_| panic!("FromStr: {expected_string}")));
 90          assert_eq!(expected, serde_json::from_str(&candidate_string).unwrap());
 91      }
 92  
 93      fn check_bincode<
 94          T: Serialize + for<'a> Deserialize<'a> + Debug + Display + PartialEq + Eq + FromStr + ToBytes + FromBytes,
 95      >(
 96          expected: T,
 97      ) {
 98          // Serialize
 99          let expected_bytes = expected.to_bytes_le().unwrap();
100          let expected_bytes_with_size_encoding = bincode::serialize(&expected).unwrap();
101          assert_eq!(&expected_bytes[..], &expected_bytes_with_size_encoding[8..]);
102  
103          // Deserialize
104          assert_eq!(expected, T::read_le(&expected_bytes[..]).unwrap());
105          assert_eq!(expected, bincode::deserialize(&expected_bytes_with_size_encoding[..]).unwrap());
106      }
107  
108      #[test]
109      fn test_serde_json() {
110          for case in TEST_CASES.iter() {
111              for mode in &["constant", "public", "private"] {
112                  check_serde_json(ValueType::<CurrentNetwork>::from_str(&format!("{case}.{mode}")).unwrap());
113              }
114          }
115          check_serde_json(ValueType::<CurrentNetwork>::from_str("token.record").unwrap());
116          check_serde_json(ValueType::<CurrentNetwork>::from_str("hello_world.record").unwrap());
117          check_serde_json(ValueType::<CurrentNetwork>::from_str("hello_world.alpha/new.record").unwrap());
118      }
119  
120      #[test]
121      fn test_bincode() {
122          for case in TEST_CASES.iter() {
123              for mode in &["constant", "public", "private"] {
124                  check_bincode(ValueType::<CurrentNetwork>::from_str(&format!("{case}.{mode}")).unwrap());
125              }
126          }
127          check_bincode(ValueType::<CurrentNetwork>::from_str("token.record").unwrap());
128          check_bincode(ValueType::<CurrentNetwork>::from_str("hello_world.record").unwrap());
129          check_bincode(ValueType::<CurrentNetwork>::from_str("hello_world.alpha/new.record").unwrap());
130      }
131  }