snarkvm_console_program/request/input_id/
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> 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 record view key.
38                let record_view_key = Field::read_le(&mut reader)?;
39                // Read the serial number.
40                let serial_number = Field::read_le(&mut reader)?;
41                // Read the tag value.
42                let tag = Field::read_le(&mut reader)?;
43                // Return the record input.
44                Ok(Self::Record(commitment, gamma, record_view_key, serial_number, tag))
45            }
46            // External record input.
47            4 => Ok(Self::ExternalRecord(Field::read_le(&mut reader)?)),
48            // Invalid input.
49            _ => Err(error("Invalid input ID variant")),
50        }
51    }
52}
53
54impl<N: Network> ToBytes for InputID<N> {
55    /// Writes the input ID to a buffer.
56    fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> {
57        match self {
58            // Constant input.
59            Self::Constant(value) => {
60                // Write the variant.
61                0u8.write_le(&mut writer)?;
62                // Write the value.
63                value.write_le(&mut writer)
64            }
65            // Public input.
66            Self::Public(value) => {
67                // Write the variant.
68                1u8.write_le(&mut writer)?;
69                // Write the value.
70                value.write_le(&mut writer)
71            }
72            // Private input.
73            Self::Private(value) => {
74                // Write the variant.
75                2u8.write_le(&mut writer)?;
76                // Write the value.
77                value.write_le(&mut writer)
78            }
79            // Record input.
80            Self::Record(commitment, gamma, record_view_key, serial_number, tag) => {
81                // Write the variant.
82                3u8.write_le(&mut writer)?;
83                // Write the commitment.
84                commitment.write_le(&mut writer)?;
85                // Write the gamma value.
86                gamma.write_le(&mut writer)?;
87                // Write the record view key.
88                record_view_key.write_le(&mut writer)?;
89                // Write the serial number.
90                serial_number.write_le(&mut writer)?;
91                // Write the tag value.
92                tag.write_le(&mut writer)
93            }
94            // External record input.
95            Self::ExternalRecord(value) => {
96                // Write the variant.
97                4u8.write_le(&mut writer)?;
98                // Write the value.
99                value.write_le(&mut writer)
100            }
101        }
102    }
103}