1  // Copyright (c) 2025-2026 ACDC Network
 2  // This file is part of the alphavm library.
 3  //
 4  // Alpha Chain | Delta Chain Protocol
 5  // International Monetary Graphite.
 6  //
 7  // Derived from Aleo (https://aleo.org) and ProvableHQ (https://provable.com).
 8  // They built world-class ZK infrastructure. We installed the EASY button.
 9  // Their cryptography: elegant. Our modifications: bureaucracy-compatible.
10  // Original brilliance: theirs. Robert's Rules: ours. Bugs: definitely ours.
11  //
12  // Original Aleo/ProvableHQ code subject to Apache 2.0 https://www.apache.org/licenses/LICENSE-2.0
13  // All modifications and new work: CC0 1.0 Universal Public Domain Dedication.
14  // No rights reserved. No permission required. No warranty. No refunds.
15  //
16  // https://creativecommons.org/publicdomain/zero/1.0/
17  // SPDX-License-Identifier: CC0-1.0
18  
19  use super::*;
20  
21  impl<N: Network> FromBytes for Register<N> {
22      /// Reads the register from a buffer.
23      fn read_le<R: Read>(mut reader: R) -> IoResult<Self> {
24          let variant = u8::read_le(&mut reader)?;
25          let locator = read_variable_length_integer(&mut reader)?;
26          match variant {
27              0 => Ok(Self::Locator(locator)),
28              1 => {
29                  // Read the number of accesses.
30                  let num_accesses = u16::read_le(&mut reader)?;
31                  if num_accesses as usize > N::MAX_DATA_DEPTH {
32                      return Err(error("Failed to deserialize register: Register access exceeds maximum depth"));
33                  }
34                  // Read the accesses.
35                  let accesses = (0..num_accesses).map(|_| Access::read_le(&mut reader)).collect::<IoResult<Vec<_>>>()?;
36                  Ok(Self::Access(locator, accesses))
37              }
38              2.. => Err(error(format!("Failed to deserialize register variant {variant}"))),
39          }
40      }
41  }
42  
43  impl<N: Network> ToBytes for Register<N> {
44      /// Writes the register to a buffer.
45      fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> {
46          match self {
47              Self::Locator(locator) => {
48                  u8::write_le(&0u8, &mut writer)?;
49                  variable_length_integer(locator).write_le(&mut writer)
50              }
51              Self::Access(locator, accesses) => {
52                  // Ensure the number of accesses is within the limit.
53                  if accesses.len() > N::MAX_DATA_DEPTH {
54                      return Err(error("Failed to serialize register: too many accesses"));
55                  }
56  
57                  u8::write_le(&1u8, &mut writer)?;
58                  variable_length_integer(locator).write_le(&mut writer)?;
59                  u16::try_from(accesses.len()).map_err(error)?.write_le(&mut writer)?;
60                  accesses.write_le(&mut writer)
61              }
62          }
63      }
64  }