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  use alphavm_utilities::DeserializeExt;
 22  
 23  impl<N: Network> Serialize for TransactionLeaf<N> {
 24      /// Serializes the leaf into string or bytes.
 25      fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
 26          match serializer.is_human_readable() {
 27              true => {
 28                  let mut leaf = serializer.serialize_struct("TransactionLeaf", 3)?;
 29                  leaf.serialize_field("variant", &self.variant)?;
 30                  leaf.serialize_field("index", &self.index)?;
 31                  leaf.serialize_field("id", &self.id)?;
 32                  leaf.end()
 33              }
 34              false => ToBytesSerializer::serialize_with_size_encoding(self, serializer),
 35          }
 36      }
 37  }
 38  
 39  impl<'de, N: Network> Deserialize<'de> for TransactionLeaf<N> {
 40      /// Deserializes the leaf from a string or bytes.
 41      fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
 42          match deserializer.is_human_readable() {
 43              true => {
 44                  // Parse the leaf from a string into a value.
 45                  let mut leaf = serde_json::Value::deserialize(deserializer)?;
 46                  // Recover the leaf.
 47                  Ok(Self::from(
 48                      // Retrieve the variant.
 49                      DeserializeExt::take_from_value::<D>(&mut leaf, "variant")?,
 50                      // Retrieve the index.
 51                      DeserializeExt::take_from_value::<D>(&mut leaf, "index")?,
 52                      // Retrieve the id.
 53                      DeserializeExt::take_from_value::<D>(&mut leaf, "id")?,
 54                  ))
 55              }
 56              false => FromBytesDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "transaction leaf"),
 57          }
 58      }
 59  }
 60  
 61  #[cfg(test)]
 62  mod tests {
 63      use super::*;
 64  
 65      #[test]
 66      fn test_serde_json() -> Result<()> {
 67          let mut rng = TestRng::default();
 68  
 69          // Sample the leaf.
 70          let expected = test_helpers::sample_leaf(&mut rng);
 71  
 72          // Serialize
 73          let expected_string = &expected.to_string();
 74          let candidate_string = serde_json::to_string(&expected)?;
 75          assert_eq!(expected, serde_json::from_str(&candidate_string)?);
 76  
 77          // Deserialize
 78          assert_eq!(expected, TransactionLeaf::from_str(expected_string)?);
 79          assert_eq!(expected, serde_json::from_str(&candidate_string)?);
 80  
 81          Ok(())
 82      }
 83  
 84      #[test]
 85      fn test_bincode() -> Result<()> {
 86          let mut rng = TestRng::default();
 87  
 88          // Sample the leaf.
 89          let expected = test_helpers::sample_leaf(&mut rng);
 90  
 91          // Serialize
 92          let expected_bytes = expected.to_bytes_le()?;
 93          let expected_bytes_with_size_encoding = bincode::serialize(&expected)?;
 94          assert_eq!(&expected_bytes[..], &expected_bytes_with_size_encoding[8..]);
 95  
 96          // Deserialize
 97          assert_eq!(expected, TransactionLeaf::read_le(&expected_bytes[..])?);
 98          assert_eq!(expected, bincode::deserialize(&expected_bytes_with_size_encoding[..])?);
 99  
100          Ok(())
101      }
102  }