bytes.rs
1 // Copyright (c) 2019-2025 Alpha-Delta Network Inc. 2 // This file is part of the alphavm 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 16 use super::*; 17 18 impl<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 74 impl<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)] 143 mod tests { 144 use super::*; 145 use alphavm_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: ax150w2lvhdzychwvzu54ys5zas7tm5s0ycdyw563pms83g9u0vucgqe5fs5w.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: ax150w2lvhdzychwvzu54ys5zas7tm5s0ycdyw563pms83g9u0vucgqe5fs5w.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 }