snarkvm_synthesizer_program/logic/finalize_operation/
serialize.rs

1// Copyright (c) 2019-2025 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
18impl<N: Network> Serialize for FinalizeOperation<N> {
19    /// Serializes the finalize operations 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                // Serialize the components.
24                match self {
25                    Self::InitializeMapping(mapping_id) => {
26                        let mut operation = serializer.serialize_struct("FinalizeOperation", 2)?;
27                        operation.serialize_field("type", "initialize_mapping")?;
28                        operation.serialize_field("mapping_id", mapping_id)?;
29                        operation.end()
30                    }
31                    Self::InsertKeyValue(mapping_id, key_id, value_id) => {
32                        let mut operation = serializer.serialize_struct("FinalizeOperation", 4)?;
33                        operation.serialize_field("type", "insert_key_value")?;
34                        operation.serialize_field("mapping_id", mapping_id)?;
35                        operation.serialize_field("key_id", key_id)?;
36                        operation.serialize_field("value_id", value_id)?;
37                        operation.end()
38                    }
39                    Self::UpdateKeyValue(mapping_id, key_id, value_id) => {
40                        let mut operation = serializer.serialize_struct("FinalizeOperation", 4)?;
41                        operation.serialize_field("type", "update_key_value")?;
42                        operation.serialize_field("mapping_id", mapping_id)?;
43                        operation.serialize_field("key_id", key_id)?;
44                        operation.serialize_field("value_id", value_id)?;
45                        operation.end()
46                    }
47                    Self::RemoveKeyValue(mapping_id, key_id) => {
48                        let mut operation = serializer.serialize_struct("FinalizeOperation", 3)?;
49                        operation.serialize_field("type", "remove_key_value")?;
50                        operation.serialize_field("mapping_id", mapping_id)?;
51                        operation.serialize_field("key_id", key_id)?;
52                        operation.end()
53                    }
54                    Self::ReplaceMapping(mapping_id) => {
55                        let mut operation = serializer.serialize_struct("FinalizeOperation", 2)?;
56                        operation.serialize_field("type", "replace_mapping")?;
57                        operation.serialize_field("mapping_id", mapping_id)?;
58                        operation.end()
59                    }
60                    Self::RemoveMapping(mapping_id) => {
61                        let mut operation = serializer.serialize_struct("FinalizeOperation", 2)?;
62                        operation.serialize_field("type", "remove_mapping")?;
63                        operation.serialize_field("mapping_id", mapping_id)?;
64                        operation.end()
65                    }
66                }
67            }
68            false => ToBytesSerializer::serialize_with_size_encoding(self, serializer),
69        }
70    }
71}
72
73impl<'de, N: Network> Deserialize<'de> for FinalizeOperation<N> {
74    /// Deserializes the finalize operations from a JSON-string or buffer.
75    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
76        match deserializer.is_human_readable() {
77            true => {
78                let mut operation = serde_json::Value::deserialize(deserializer)?;
79                // Recover the operation.
80                let finalize_operation = match operation.get("type").and_then(|t| t.as_str()) {
81                    Some("initialize_mapping") => {
82                        // Deserialize the mapping ID.
83                        let mapping_id = DeserializeExt::take_from_value::<D>(&mut operation, "mapping_id")?;
84                        // Return the operation.
85                        Self::InitializeMapping(mapping_id)
86                    }
87                    Some("insert_key_value") => {
88                        // Deserialize the mapping ID.
89                        let mapping_id = DeserializeExt::take_from_value::<D>(&mut operation, "mapping_id")?;
90                        // Deserialize the key ID.
91                        let key_id = DeserializeExt::take_from_value::<D>(&mut operation, "key_id")?;
92                        // Deserialize the value ID.
93                        let value_id = DeserializeExt::take_from_value::<D>(&mut operation, "value_id")?;
94                        // Return the operation.
95                        Self::InsertKeyValue(mapping_id, key_id, value_id)
96                    }
97                    Some("update_key_value") => {
98                        // Deserialize the mapping ID.
99                        let mapping_id = DeserializeExt::take_from_value::<D>(&mut operation, "mapping_id")?;
100                        // Deserialize the key ID.
101                        let key_id = DeserializeExt::take_from_value::<D>(&mut operation, "key_id")?;
102                        // Deserialize the value ID.
103                        let value_id = DeserializeExt::take_from_value::<D>(&mut operation, "value_id")?;
104                        // Return the operation.
105                        Self::UpdateKeyValue(mapping_id, key_id, value_id)
106                    }
107                    Some("remove_key_value") => {
108                        // Deserialize the mapping ID.
109                        let mapping_id = DeserializeExt::take_from_value::<D>(&mut operation, "mapping_id")?;
110                        // Deserialize the key ID.
111                        let key_id = DeserializeExt::take_from_value::<D>(&mut operation, "key_id")?;
112                        // Return the operation.
113                        Self::RemoveKeyValue(mapping_id, key_id)
114                    }
115                    Some("replace_mapping") => {
116                        // Deserialize the mapping ID.
117                        let mapping_id = DeserializeExt::take_from_value::<D>(&mut operation, "mapping_id")?;
118                        // Return the operation.
119                        Self::ReplaceMapping(mapping_id)
120                    }
121                    Some("remove_mapping") => {
122                        // Deserialize the mapping ID.
123                        let mapping_id = DeserializeExt::take_from_value::<D>(&mut operation, "mapping_id")?;
124                        // Return the operation.
125                        Self::RemoveMapping(mapping_id)
126                    }
127                    _ => return Err(de::Error::custom("Invalid finalize operation type")),
128                };
129                // Return the operation.
130                Ok(finalize_operation)
131            }
132            false => FromBytesDeserializer::<Self>::deserialize_with_size_encoding(deserializer, "finalize operations"),
133        }
134    }
135}
136
137#[cfg(test)]
138mod tests {
139    use super::*;
140
141    fn check_serde_json<
142        T: Serialize + for<'a> Deserialize<'a> + Debug + Display + PartialEq + Eq + FromStr + ToBytes + FromBytes,
143    >(
144        expected: T,
145    ) {
146        // Serialize
147        let expected_string = expected.to_string();
148        let candidate_string = serde_json::to_string(&expected).unwrap();
149        let candidate = serde_json::from_str::<T>(&candidate_string).unwrap();
150        assert_eq!(expected, candidate);
151        assert_eq!(expected_string, candidate_string);
152        assert_eq!(expected_string, candidate.to_string());
153
154        // Deserialize
155        assert_eq!(expected, T::from_str(&expected_string).unwrap_or_else(|_| panic!("FromStr: {expected_string}")));
156        assert_eq!(expected, serde_json::from_str(&candidate_string).unwrap());
157    }
158
159    fn check_bincode<
160        T: Serialize + for<'a> Deserialize<'a> + Debug + Display + PartialEq + Eq + FromStr + ToBytes + FromBytes,
161    >(
162        expected: T,
163    ) {
164        // Serialize
165        let expected_bytes = expected.to_bytes_le().unwrap();
166        let expected_bytes_with_size_encoding = bincode::serialize(&expected).unwrap();
167        assert_eq!(&expected_bytes[..], &expected_bytes_with_size_encoding[8..]);
168
169        // Deserialize
170        assert_eq!(expected, T::read_le(&expected_bytes[..]).unwrap());
171        assert_eq!(expected, bincode::deserialize(&expected_bytes_with_size_encoding[..]).unwrap());
172    }
173
174    #[test]
175    fn test_serde_json() {
176        for finalize in crate::logic::finalize_operation::test_helpers::sample_finalize_operations() {
177            check_serde_json(finalize);
178        }
179    }
180
181    #[test]
182    fn test_bincode() {
183        for finalize in crate::logic::finalize_operation::test_helpers::sample_finalize_operations() {
184            check_bincode(finalize);
185        }
186    }
187}
snarkvm_synthesizer_program/logic/finalize_operation/serialize.rs

snarkvm_synthesizer_program/logic/finalize_operation/
serialize.rs
