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 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  
 54  impl<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  }