snarkvm_console_program/request/input_id/
bytes.rs

1// Copyright 2024 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 InputID<N> {
19    /// Reads the input ID from a buffer.
20    fn read_le<R: Read>(mut reader: R) -> IoResult<Self> {
21        // Read the variant.
22        let variant = u8::read_le(&mut reader)?;
23        // Match the variant.
24        match variant {
25            // Constant input.
26            0 => Ok(Self::Constant(Field::read_le(&mut reader)?)),
27            // Public input.
28            1 => Ok(Self::Public(Field::read_le(&mut reader)?)),
29            // Private input.
30            2 => Ok(Self::Private(Field::read_le(&mut reader)?)),
31            // Record input.
32            3 => {
33                // Read the commitment.
34                let commitment = Field::read_le(&mut reader)?;
35                // Read the gamma value.
36                let gamma = Group::read_le(&mut reader)?;
37                // Read the serial number.
38                let serial_number = Field::read_le(&mut reader)?;
39                // Read the tag value.
40                let tag = Field::read_le(&mut reader)?;
41                // Return the record input.
42                Ok(Self::Record(commitment, gamma, serial_number, tag))
43            }
44            // External record input.
45            4 => Ok(Self::ExternalRecord(Field::read_le(&mut reader)?)),
46            // Invalid input.
47            _ => Err(error("Invalid input ID variant")),
48        }
49    }
50}
51
52impl<N: Network> ToBytes for InputID<N> {
53    /// Writes the input ID to a buffer.
54    fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> {
55        match self {
56            // Constant input.
57            Self::Constant(value) => {
58                // Write the variant.
59                0u8.write_le(&mut writer)?;
60                // Write the value.
61                value.write_le(&mut writer)
62            }
63            // Public input.
64            Self::Public(value) => {
65                // Write the variant.
66                1u8.write_le(&mut writer)?;
67                // Write the value.
68                value.write_le(&mut writer)
69            }
70            // Private input.
71            Self::Private(value) => {
72                // Write the variant.
73                2u8.write_le(&mut writer)?;
74                // Write the value.
75                value.write_le(&mut writer)
76            }
77            // Record input.
78            Self::Record(commitment, gamma, serial_number, tag) => {
79                // Write the variant.
80                3u8.write_le(&mut writer)?;
81                // Write the commitment.
82                commitment.write_le(&mut writer)?;
83                // Write the gamma value.
84                gamma.write_le(&mut writer)?;
85                // Write the serial number.
86                serial_number.write_le(&mut writer)?;
87                // Write the tag value.
88                tag.write_le(&mut writer)
89            }
90            // External record input.
91            Self::ExternalRecord(value) => {
92                // Write the variant.
93                4u8.write_le(&mut writer)?;
94                // Write the value.
95                value.write_le(&mut writer)
96            }
97        }
98    }
99}