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> FromBytes for Literal<N> { 19 /// Reads the literal from a buffer. 20 fn read_le<R: Read>(mut reader: R) -> IoResult<Self> { 21 let index = u16::read_le(&mut reader)?; 22 let literal = match index { 23 0 => Self::Address(Address::read_le(&mut reader)?), 24 1 => Self::Boolean(Boolean::read_le(&mut reader)?), 25 2 => Self::Field(Field::read_le(&mut reader)?), 26 3 => Self::Group(Group::read_le(&mut reader)?), 27 4 => Self::I8(I8::read_le(&mut reader)?), 28 5 => Self::I16(I16::read_le(&mut reader)?), 29 6 => Self::I32(I32::read_le(&mut reader)?), 30 7 => Self::I64(I64::read_le(&mut reader)?), 31 8 => Self::I128(I128::read_le(&mut reader)?), 32 9 => Self::U8(U8::read_le(&mut reader)?), 33 10 => Self::U16(U16::read_le(&mut reader)?), 34 11 => Self::U32(U32::read_le(&mut reader)?), 35 12 => Self::U64(U64::read_le(&mut reader)?), 36 13 => Self::U128(U128::read_le(&mut reader)?), 37 14 => Self::Scalar(Scalar::read_le(&mut reader)?), 38 15 => Self::Signature(Box::new(Signature::read_le(&mut reader)?)), 39 16 => Self::String(StringType::read_le(&mut reader)?), 40 17.. => return Err(error(format!("Failed to decode literal variant {index}"))), 41 }; 42 Ok(literal) 43 } 44 } 45 46 impl<N: Network> ToBytes for Literal<N> { 47 /// Writes the literal to a buffer. 48 fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> { 49 type Size = u16; 50 match self { 51 Self::Address(primitive) => { 52 (0 as Size).write_le(&mut writer)?; 53 primitive.write_le(&mut writer) 54 } 55 Self::Boolean(primitive) => { 56 (1 as Size).write_le(&mut writer)?; 57 primitive.write_le(&mut writer) 58 } 59 Self::Field(primitive) => { 60 (2 as Size).write_le(&mut writer)?; 61 primitive.write_le(&mut writer) 62 } 63 Self::Group(primitive) => { 64 (3 as Size).write_le(&mut writer)?; 65 primitive.write_le(&mut writer) 66 } 67 Self::I8(primitive) => { 68 (4 as Size).write_le(&mut writer)?; 69 primitive.write_le(&mut writer) 70 } 71 Self::I16(primitive) => { 72 (5 as Size).write_le(&mut writer)?; 73 primitive.write_le(&mut writer) 74 } 75 Self::I32(primitive) => { 76 (6 as Size).write_le(&mut writer)?; 77 primitive.write_le(&mut writer) 78 } 79 Self::I64(primitive) => { 80 (7 as Size).write_le(&mut writer)?; 81 primitive.write_le(&mut writer) 82 } 83 Self::I128(primitive) => { 84 (8 as Size).write_le(&mut writer)?; 85 primitive.write_le(&mut writer) 86 } 87 Self::U8(primitive) => { 88 (9 as Size).write_le(&mut writer)?; 89 primitive.write_le(&mut writer) 90 } 91 Self::U16(primitive) => { 92 (10 as Size).write_le(&mut writer)?; 93 primitive.write_le(&mut writer) 94 } 95 Self::U32(primitive) => { 96 (11 as Size).write_le(&mut writer)?; 97 primitive.write_le(&mut writer) 98 } 99 Self::U64(primitive) => { 100 (12 as Size).write_le(&mut writer)?; 101 primitive.write_le(&mut writer) 102 } 103 Self::U128(primitive) => { 104 (13 as Size).write_le(&mut writer)?; 105 primitive.write_le(&mut writer) 106 } 107 Self::Scalar(primitive) => { 108 (14 as Size).write_le(&mut writer)?; 109 primitive.write_le(&mut writer) 110 } 111 Self::Signature(primitive) => { 112 (15 as Size).write_le(&mut writer)?; 113 primitive.write_le(&mut writer) 114 } 115 Self::String(primitive) => { 116 (16 as Size).write_le(&mut writer)?; 117 primitive.write_le(&mut writer) 118 } 119 } 120 } 121 } 122 123 #[cfg(test)] 124 mod tests { 125 use super::*; 126 use alphavm_console_network::MainnetV0; 127 128 type CurrentNetwork = MainnetV0; 129 130 const ITERATIONS: u32 = 1000; 131 132 fn check_bytes(expected: Literal<CurrentNetwork>) -> Result<()> { 133 // Check the byte representation. 134 let expected_bytes = expected.to_bytes_le()?; 135 assert_eq!(expected, Literal::read_le(&expected_bytes[..])?); 136 Ok(()) 137 } 138 139 #[test] 140 fn test_bytes() -> Result<()> { 141 let rng = &mut TestRng::default(); 142 143 for _ in 0..ITERATIONS { 144 let private_key = alphavm_console_account::PrivateKey::<CurrentNetwork>::new(rng)?; 145 146 // Address 147 check_bytes(Literal::<CurrentNetwork>::Address(Address::try_from(private_key)?))?; 148 // Boolean 149 check_bytes(Literal::<CurrentNetwork>::Boolean(Boolean::new(Uniform::rand(rng))))?; 150 // Field 151 check_bytes(Literal::<CurrentNetwork>::Field(Uniform::rand(rng)))?; 152 // Group 153 check_bytes(Literal::<CurrentNetwork>::Group(Uniform::rand(rng)))?; 154 // I8 155 check_bytes(Literal::<CurrentNetwork>::I8(I8::new(Uniform::rand(rng))))?; 156 // I16 157 check_bytes(Literal::<CurrentNetwork>::I16(I16::new(Uniform::rand(rng))))?; 158 // I32 159 check_bytes(Literal::<CurrentNetwork>::I32(I32::new(Uniform::rand(rng))))?; 160 // I64 161 check_bytes(Literal::<CurrentNetwork>::I64(I64::new(Uniform::rand(rng))))?; 162 // I128 163 check_bytes(Literal::<CurrentNetwork>::I128(I128::new(Uniform::rand(rng))))?; 164 // U8 165 check_bytes(Literal::<CurrentNetwork>::U8(U8::new(Uniform::rand(rng))))?; 166 // U16 167 check_bytes(Literal::<CurrentNetwork>::U16(U16::new(Uniform::rand(rng))))?; 168 // U32 169 check_bytes(Literal::<CurrentNetwork>::U32(U32::new(Uniform::rand(rng))))?; 170 // U64 171 check_bytes(Literal::<CurrentNetwork>::U64(U64::new(Uniform::rand(rng))))?; 172 // U128 173 check_bytes(Literal::<CurrentNetwork>::U128(U128::new(Uniform::rand(rng))))?; 174 // Scalar 175 check_bytes(Literal::<CurrentNetwork>::Scalar(Uniform::rand(rng)))?; 176 // Signature 177 check_bytes(Literal::sample(LiteralType::Signature, rng))?; 178 // String 179 check_bytes(Literal::<CurrentNetwork>::String(StringType::rand(rng)))?; 180 } 181 Ok(()) 182 } 183 }