snarkvm_console_program/data/record/
bytes.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, Private: Visibility> FromBytes for Record<N, Private> {
19    /// Reads the record from a buffer.
20    fn read_le<R: Read>(mut reader: R) -> IoResult<Self> {
21        // Read the variant.
22        let variant = U8::<N>::new(u8::read_le(&mut reader)?);
23
24        // Set the version based on the variant.
25        let version = match *variant {
26            0 | 1 => U8::zero(),
27            2 | 3 => U8::one(),
28            4.. => return Err(error(format!("Failed to decode record variant ({variant}) for the version"))),
29        };
30
31        // Read the owner.
32        let owner = match *variant {
33            0 | 2 => Owner::Public(Address::read_le(&mut reader)?),
34            1 | 3 => Owner::Private(Private::read_le(&mut reader)?),
35            4.. => return Err(error(format!("Failed to decode record variant ({variant}) for the owner"))),
36        };
37
38        // Read the number of entries in the record data.
39        let num_entries = u8::read_le(&mut reader)?;
40        // Read the record data.
41        let mut data = IndexMap::with_capacity(num_entries as usize);
42        for _ in 0..num_entries {
43            // Read the identifier.
44            let identifier = Identifier::<N>::read_le(&mut reader)?;
45            // Read the entry value (in 2 steps to prevent infinite recursion).
46            let num_bytes = u16::read_le(&mut reader)?;
47            // Read the entry bytes.
48            let mut bytes = Vec::new();
49            (&mut reader).take(num_bytes as u64).read_to_end(&mut bytes)?;
50            // Recover the entry value.
51            let entry = Entry::read_le(&mut bytes.as_slice())?;
52            // Add the entry.
53            data.insert(identifier, entry);
54        }
55
56        // Read the nonce.
57        let nonce = Group::read_le(&mut reader)?;
58
59        // Prepare the reserved entry names.
60        let reserved = [Identifier::from_str("owner").map_err(|e| error(e.to_string()))?];
61        // Ensure the entries has no duplicate names.
62        if has_duplicates(data.keys().chain(reserved.iter())) {
63            return Err(error("Duplicate entry type found in record"));
64        }
65        // Ensure the number of entries is within the maximum limit.
66        if data.len() > N::MAX_DATA_ENTRIES {
67            return Err(error("Failed to parse record - too many entries"));
68        }
69
70        Ok(Self { owner, data, nonce, version })
71    }
72}
73
74impl<N: Network, Private: Visibility> ToBytes for Record<N, Private> {
75    /// Writes the record to a buffer.
76    fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> {
77        // Set the variant.
78        let variant = match (*self.version, self.owner.is_public()) {
79            (0, true) => 0u8,
80            (0, false) => 1u8,
81            (1, true) => 2u8,
82            (1, false) => 3u8,
83            (_, _) => {
84                return Err(error(format!(
85                    "Failed to encode record - variant mismatch (version = {}, hiding = {}, owner = {})",
86                    self.version,
87                    self.is_hiding(),
88                    self.owner.is_public()
89                )));
90            }
91        };
92
93        #[cfg(debug_assertions)]
94        {
95            // Ensure the version is correct.
96            let is_version_correct = match (!self.is_hiding(), self.owner.is_public()) {
97                (true, true) => variant == 0,
98                (true, false) => variant == 1,
99                (false, true) => variant == 2,
100                (false, false) => variant == 3,
101            };
102            if !is_version_correct {
103                return Err(error(format!(
104                    "Failed to encode record - version mismatch (version = {}, hiding = {}, owner = {})",
105                    self.version,
106                    self.is_hiding(),
107                    self.owner.is_public()
108                )));
109            }
110        }
111
112        // Write the variant.
113        variant.write_le(&mut writer)?;
114
115        // Write the owner.
116        match &self.owner {
117            Owner::Public(owner) => owner.write_le(&mut writer)?,
118            Owner::Private(owner) => owner.write_le(&mut writer)?,
119        };
120
121        // Write the number of entries in the record data.
122        u8::try_from(self.data.len()).or_halt_with::<N>("Record length exceeds u8::MAX").write_le(&mut writer)?;
123        // Write each entry.
124        for (entry_name, entry_value) in &self.data {
125            // Write the entry name.
126            entry_name.write_le(&mut writer)?;
127            // Write the entry value (performed in 2 steps to prevent infinite recursion).
128            let bytes = entry_value.to_bytes_le().map_err(|e| error(e.to_string()))?;
129            // Write the number of bytes.
130            u16::try_from(bytes.len())
131                .or_halt_with::<N>("Record entry exceeds u16::MAX bytes")
132                .write_le(&mut writer)?;
133            // Write the bytes.
134            bytes.write_le(&mut writer)?;
135        }
136
137        // Write the nonce.
138        self.nonce.write_le(&mut writer)
139    }
140}
141
142#[cfg(test)]
143mod tests {
144    use super::*;
145    use snarkvm_console_network::MainnetV0;
146
147    type CurrentNetwork = MainnetV0;
148
149    #[test]
150    fn test_bytes() -> Result<()> {
151        // Construct a new record.
152        let expected = Record::<CurrentNetwork, Plaintext<CurrentNetwork>>::from_str(
153            "{ owner: aleo1d5hg2z3ma00382pngntdp68e74zv54jdxy249qhaujhks9c72yrs33ddah.private, token_amount: 100u64.private, _nonce: 0group.public }",
154        )?;
155
156        // Check the byte representation.
157        let expected_bytes = expected.to_bytes_le()?;
158        assert_eq!(expected, Record::read_le(&expected_bytes[..])?);
159
160        // Construct a new record.
161        let expected = Record::<CurrentNetwork, Plaintext<CurrentNetwork>>::from_str(
162            "{ owner: aleo1d5hg2z3ma00382pngntdp68e74zv54jdxy249qhaujhks9c72yrs33ddah.private, token_amount: 100u64.private, _nonce: 0group.public, _version: 1u8.public }",
163        )?;
164
165        // Check the byte representation.
166        let expected_bytes = expected.to_bytes_le()?;
167        assert_eq!(expected, Record::read_le(&expected_bytes[..])?);
168        Ok(())
169    }
170}
snarkvm_console_program/data/record/bytes.rs

snarkvm_console_program/data/record/
bytes.rs
