snarkvm_console_program/request/input_id/
serialize.rs

1// Copyright (c) 2019-2026 Provable Inc.
2// This file is part of the snarkVM 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
16use super::*;
17
18use snarkvm_utilities::DeserializeExt;
19
20impl<N: Network> Serialize for InputID<N> {
21    /// Serializes the input ID into string or bytes.
22    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
23        match serializer.is_human_readable() {
24            true => match self {
25                Self::Constant(id) => {
26                    let mut input = serializer.serialize_struct("InputID", 2)?;
27                    input.serialize_field("type", "constant")?;
28                    input.serialize_field("id", &id)?;
29                    input.end()
30                }
31                Self::Public(id) => {
32                    let mut input = serializer.serialize_struct("InputID", 2)?;
33                    input.serialize_field("type", "public")?;
34                    input.serialize_field("id", &id)?;
35                    input.end()
36                }
37                Self::Private(id) => {
38                    let mut input = serializer.serialize_struct("InputID", 2)?;
39                    input.serialize_field("type", "private")?;
40                    input.serialize_field("id", &id)?;
41                    input.end()
42                }
43                Self::Record(commitment, gamma, record_view_key, serial_number, tag) => {
44                    let mut input = serializer.serialize_struct("InputID", 5)?;
45                    input.serialize_field("type", "record")?;
46                    input.serialize_field("commitment", &commitment)?;
47                    input.serialize_field("gamma", &gamma)?;
48                    input.serialize_field("record_view_key", &record_view_key)?;
49                    input.serialize_field("serial_number", &serial_number)?;
50                    input.serialize_field("tag", &tag)?;
51                    input.end()
52                }
53                Self::ExternalRecord(id) => {
54                    let mut input = serializer.serialize_struct("InputID", 2)?;
55                    input.serialize_field("type", "external_record")?;
56                    input.serialize_field("id", &id)?;
57                    input.end()
58                }
59                Self::DynamicRecord(id) => {
60                    let mut input = serializer.serialize_struct("InputID", 2)?;
61                    input.serialize_field("type", "record_dynamic")?;
62                    input.serialize_field("id", &id)?;
63                    input.end()
64                }
65            },
66            false => ToBytesSerializer::serialize_with_size_encoding(self, serializer),
67        }
68    }
69}
70
71impl<'de, N: Network> Deserialize<'de> for InputID<N> {
72    /// Deserializes the input ID from a string or bytes.
73    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
74        match deserializer.is_human_readable() {
75            true => {
76                // Parse the input ID from a string into a value.
77                let mut input = serde_json::Value::deserialize(deserializer)?;
78                // Recover the input.
79                let input_id = match input.get("type").and_then(|t| t.as_str()) {
80                    Some("constant") => InputID::Constant(DeserializeExt::take_from_value::<D>(&mut input, "id")?),
81                    Some("public") => InputID::Public(DeserializeExt::take_from_value::<D>(&mut input, "id")?),
82                    Some("private") => InputID::Private(DeserializeExt::take_from_value::<D>(&mut input, "id")?),
83                    Some("record") => InputID::Record(
84                        DeserializeExt::take_from_value::<D>(&mut input, "commitment")?,
85                        DeserializeExt::take_from_value::<D>(&mut input, "gamma")?,
86                        DeserializeExt::take_from_value::<D>(&mut input, "record_view_key")?,
87                        DeserializeExt::take_from_value::<D>(&mut input, "serial_number")?,
88                        DeserializeExt::take_from_value::<D>(&mut input, "tag")?,
89                    ),
90                    Some("external_record") => {
91                        InputID::ExternalRecord(DeserializeExt::take_from_value::<D>(&mut input, "id")?)
92                    }
93                    Some("record_dynamic") => {
94                        InputID::DynamicRecord(DeserializeExt::take_from_value::<D>(&mut input, "id")?)
95                    }
96                    _ => return Err(de::Error::custom("Invalid input type")),
97                };
98                Ok(input_id)
99            }
100            false => FromBytesDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "input ID"),
101        }
102    }
103}
104
105#[cfg(test)]
106mod tests {
107    use super::*;
108    use snarkvm_console_network::MainnetV0;
109
110    type CurrentNetwork = MainnetV0;
111
112    /// Add test cases here to be checked for serialization.
113    const TEST_CASES: &[&str] = &[
114        "{\"type\":\"constant\",\"id\":\"5field\"}",
115        "{\"type\":\"public\",\"id\":\"0field\"}",
116        "{\"type\":\"private\",\"id\":\"123field\"}",
117        "{\"type\":\"record\",\"commitment\":\"123123field\",\"tag\":\"0field\",\"record_view_key\":\"0field\",\"serial_number\":\"123456789field\",\"gamma\":\"0group\"}",
118        "{\"type\":\"external_record\",\"id\":\"123456789field\"}",
119        "{\"type\":\"record_dynamic\",\"id\":\"987654321field\"}",
120    ];
121
122    fn check_serde_json<
123        T: Serialize + for<'a> Deserialize<'a> + Debug + Display + PartialEq + Eq + FromStr + ToBytes + FromBytes,
124    >(
125        expected: T,
126    ) {
127        // Serialize
128        let expected_string = expected.to_string();
129        let candidate_string = serde_json::to_string(&expected).unwrap();
130        let candidate = serde_json::from_str::<T>(&candidate_string).unwrap();
131        assert_eq!(expected, candidate);
132        assert_eq!(expected_string, candidate_string);
133        assert_eq!(expected_string, candidate.to_string());
134
135        // Deserialize
136        assert_eq!(expected, T::from_str(&expected_string).unwrap_or_else(|_| panic!("FromStr: {expected_string}")));
137        assert_eq!(expected, serde_json::from_str(&candidate_string).unwrap());
138    }
139
140    fn check_bincode<
141        T: Serialize + for<'a> Deserialize<'a> + Debug + Display + PartialEq + Eq + FromStr + ToBytes + FromBytes,
142    >(
143        expected: T,
144    ) {
145        // Serialize
146        let expected_bytes = expected.to_bytes_le().unwrap();
147        let expected_bytes_with_size_encoding = bincode::serialize(&expected).unwrap();
148        assert_eq!(&expected_bytes[..], &expected_bytes_with_size_encoding[8..]);
149
150        // Deserialize
151        assert_eq!(expected, T::read_le(&expected_bytes[..]).unwrap());
152        assert_eq!(expected, bincode::deserialize(&expected_bytes_with_size_encoding[..]).unwrap());
153    }
154
155    #[test]
156    fn test_serde_json() {
157        for case in TEST_CASES.iter() {
158            check_serde_json(InputID::<CurrentNetwork>::from_str(case).unwrap());
159        }
160    }
161
162    #[test]
163    fn test_bincode() {
164        for case in TEST_CASES.iter() {
165            check_bincode(InputID::<CurrentNetwork>::from_str(case).unwrap());
166        }
167    }
168}
snarkvm_console_program/request/input_id/serialize.rs

snarkvm_console_program/request/input_id/
serialize.rs
