1  // Copyright (c) 2025 ADnet Contributors
  2  // This file is part of the AlphaVM library.
  3  
  4  // Licensed under the Apache License, Version 2.0 (the "License");
  5  // you may not use this file except in compliance with the License.
  6  // You may obtain a copy of the License at:
  7  
  8  // http://www.apache.org/licenses/LICENSE-2.0
  9  
 10  // Unless required by applicable law or agreed to in writing, software
 11  // distributed under the License is distributed on an "AS IS" BASIS,
 12  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  // See the License for the specific language governing permissions and
 14  // limitations under the License.
 15  
 16  use super::*;
 17  
 18  impl<N: Network> Serialize for Committee<N> {
 19      /// Serializes the committee to a JSON-string or buffer.
 20      fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
 21          match serializer.is_human_readable() {
 22              true => {
 23                  let mut certificate = serializer.serialize_struct("Committee", 4)?;
 24                  certificate.serialize_field("id", &self.id)?;
 25                  certificate.serialize_field("starting_round", &self.starting_round)?;
 26                  certificate.serialize_field("members", &self.members)?;
 27                  certificate.serialize_field("total_stake", &self.total_stake)?;
 28                  certificate.end()
 29              }
 30              false => ToBytesSerializer::serialize_with_size_encoding(self, serializer),
 31          }
 32      }
 33  }
 34  
 35  impl<'de, N: Network> Deserialize<'de> for Committee<N> {
 36      /// Deserializes the committee from a JSON-string or buffer.
 37      fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
 38          match deserializer.is_human_readable() {
 39              true => {
 40                  let mut value = serde_json::Value::deserialize(deserializer)?;
 41                  let id: Field<N> = DeserializeExt::take_from_value::<D>(&mut value, "id")?;
 42                  let total_stake: u64 = DeserializeExt::take_from_value::<D>(&mut value, "total_stake")?;
 43                  let committee = Self::new(
 44                      DeserializeExt::take_from_value::<D>(&mut value, "starting_round")?,
 45                      DeserializeExt::take_from_value::<D>(&mut value, "members")?,
 46                  )
 47                  .map_err(de::Error::custom)?;
 48  
 49                  if committee.id != id {
 50                      return Err(de::Error::custom("committee ID mismatch"));
 51                  }
 52                  match committee.total_stake == total_stake {
 53                      true => Ok(committee),
 54                      false => Err(de::Error::custom("total stake mismatch")),
 55                  }
 56              }
 57              false => FromBytesDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "committee"),
 58          }
 59      }
 60  }
 61  
 62  #[cfg(test)]
 63  mod tests {
 64      use super::*;
 65  
 66      fn check_serde_json<
 67          T: Serialize + for<'a> Deserialize<'a> + Debug + Display + PartialEq + Eq + FromStr + ToBytes + FromBytes,
 68      >(
 69          expected: T,
 70      ) {
 71          // Serialize
 72          let expected_string = expected.to_string();
 73          let candidate_string = serde_json::to_string(&expected).unwrap();
 74          let candidate = serde_json::from_str::<T>(&candidate_string).unwrap();
 75          assert_eq!(expected, candidate);
 76          assert_eq!(expected_string, candidate_string);
 77          assert_eq!(expected_string, candidate.to_string());
 78  
 79          // Deserialize
 80          assert_eq!(expected, T::from_str(&expected_string).unwrap_or_else(|_| panic!("FromStr: {expected_string}")));
 81          assert_eq!(expected, serde_json::from_str(&candidate_string).unwrap());
 82      }
 83  
 84      fn check_bincode<
 85          T: Serialize + for<'a> Deserialize<'a> + Debug + Display + PartialEq + Eq + FromStr + ToBytes + FromBytes,
 86      >(
 87          expected: T,
 88      ) {
 89          // Serialize
 90          let expected_bytes = expected.to_bytes_le().unwrap();
 91          let expected_bytes_with_size_encoding = bincode::serialize(&expected).unwrap();
 92          assert_eq!(&expected_bytes[..], &expected_bytes_with_size_encoding[8..]);
 93  
 94          // Deserialize
 95          assert_eq!(expected, T::read_le(&expected_bytes[..]).unwrap());
 96          assert_eq!(expected, bincode::deserialize(&expected_bytes_with_size_encoding[..]).unwrap());
 97      }
 98  
 99      #[test]
100      fn test_serde_json() {
101          let rng = &mut TestRng::default();
102  
103          for expected in crate::test_helpers::sample_committees(rng) {
104              check_serde_json(expected);
105          }
106      }
107  
108      #[test]
109      fn test_bincode() {
110          let rng = &mut TestRng::default();
111  
112          for expected in crate::test_helpers::sample_committees(rng) {
113              check_bincode(expected);
114          }
115      }
116  }