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 FinalizeType<N> {
 22      /// Serializes the finalize 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 FinalizeType<N> {
 32      /// Deserializes the finalize 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, "finalize 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.public",
 52          "boolean.public",
 53          "field.public",
 54          "group.public",
 55          "i8.public",
 56          "i16.public",
 57          "i32.public",
 58          "i64.public",
 59          "i128.public",
 60          "u8.public",
 61          "u16.public",
 62          "u32.public",
 63          "u64.public",
 64          "u128.public",
 65          "scalar.public",
 66          "string.public",
 67          // Struct
 68          "signature.public",
 69          "message.public",
 70          "item.public",
 71          "passport.public",
 72          "object.public",
 73          "array.public",
 74          // Future
 75          "credits.alpha/mint_public.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              check_serde_json(FinalizeType::<CurrentNetwork>::from_str(case).unwrap());
112          }
113      }
114  
115      #[test]
116      fn test_bincode() {
117          for case in TEST_CASES.iter() {
118              check_bincode(FinalizeType::<CurrentNetwork>::from_str(case).unwrap());
119          }
120      }
121  }