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 Request<N> {
 24      /// Serializes the request 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 transition = serializer.serialize_struct("Request", 11)?;
 29                  transition.serialize_field("signer", &self.signer)?;
 30                  transition.serialize_field("network", &self.network_id)?;
 31                  transition.serialize_field("program", &self.program_id)?;
 32                  transition.serialize_field("function", &self.function_name)?;
 33                  transition.serialize_field("input_ids", &self.input_ids)?;
 34                  transition.serialize_field("inputs", &self.inputs)?;
 35                  transition.serialize_field("signature", &self.signature)?;
 36                  transition.serialize_field("sk_tag", &self.sk_tag)?;
 37                  transition.serialize_field("tvk", &self.tvk)?;
 38                  transition.serialize_field("tcm", &self.tcm)?;
 39                  transition.serialize_field("scm", &self.scm)?;
 40                  transition.end()
 41              }
 42              false => ToBytesSerializer::serialize_with_size_encoding(self, serializer),
 43          }
 44      }
 45  }
 46  
 47  impl<'de, N: Network> Deserialize<'de> for Request<N> {
 48      /// Deserializes the request from a string or bytes.
 49      fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
 50          match deserializer.is_human_readable() {
 51              true => {
 52                  // Parse the request from a string into a value.
 53                  let mut request = serde_json::Value::deserialize(deserializer)?;
 54                  // Recover the request.
 55                  Ok(Self::from((
 56                      // Retrieve the signer.
 57                      DeserializeExt::take_from_value::<D>(&mut request, "signer")?,
 58                      // Retrieve the network ID.
 59                      DeserializeExt::take_from_value::<D>(&mut request, "network")?,
 60                      // Retrieve the program ID.
 61                      DeserializeExt::take_from_value::<D>(&mut request, "program")?,
 62                      // Retrieve the function name.
 63                      DeserializeExt::take_from_value::<D>(&mut request, "function")?,
 64                      // Retrieve the input IDs.
 65                      DeserializeExt::take_from_value::<D>(&mut request, "input_ids")?,
 66                      // Retrieve the inputs.
 67                      DeserializeExt::take_from_value::<D>(&mut request, "inputs")?,
 68                      // Retrieve the signature.
 69                      DeserializeExt::take_from_value::<D>(&mut request, "signature")?,
 70                      // Retrieve the `sk_tag`.
 71                      DeserializeExt::take_from_value::<D>(&mut request, "sk_tag")?,
 72                      // Retrieve the `tvk`.
 73                      DeserializeExt::take_from_value::<D>(&mut request, "tvk")?,
 74                      // Retrieve the `tcm`.
 75                      DeserializeExt::take_from_value::<D>(&mut request, "tcm")?,
 76                      // Retrieve the `scm`.
 77                      DeserializeExt::take_from_value::<D>(&mut request, "scm")?,
 78                  )))
 79              }
 80              false => FromBytesDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "request"),
 81          }
 82      }
 83  }
 84  
 85  #[cfg(test)]
 86  mod tests {
 87      use super::*;
 88  
 89      #[test]
 90      fn test_serde_json() -> Result<()> {
 91          let mut rng = TestRng::default();
 92  
 93          for expected in test_helpers::sample_requests(&mut rng).into_iter() {
 94              // Serialize
 95              let expected_string = &expected.to_string();
 96              let candidate_string = serde_json::to_string(&expected)?;
 97  
 98              // Deserialize
 99              assert_eq!(expected, Request::from_str(expected_string)?);
100              assert_eq!(expected, serde_json::from_str(&candidate_string)?);
101          }
102          Ok(())
103      }
104  
105      #[test]
106      fn test_bincode() {
107          let mut rng = TestRng::default();
108  
109          for expected in test_helpers::sample_requests(&mut rng).into_iter() {
110              // Serialize
111              let expected_bytes = expected.to_bytes_le().unwrap();
112              let expected_bytes_with_size_encoding = bincode::serialize(&expected).unwrap();
113              assert_eq!(&expected_bytes[..], &expected_bytes_with_size_encoding[8..]);
114  
115              // Deserialize
116              assert_eq!(expected, Request::read_le(&expected_bytes[..]).unwrap());
117              assert_eq!(expected, bincode::deserialize(&expected_bytes_with_size_encoding).unwrap());
118          }
119      }
120  }