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