snarkvm_console_program/data/literal/
bytes.rs

1// Copyright 2024-2025 Aleo Network Foundation
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> 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
46impl<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)]
124mod tests {
125    use super::*;
126    use snarkvm_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 = snarkvm_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}
snarkvm_console_program/data/literal/bytes.rs

snarkvm_console_program/data/literal/
bytes.rs
