snarkvm_ledger_block/transition/input/
bytes.rsuse super::*;
impl<N: Network> FromBytes for Input<N> {
fn read_le<R: Read>(mut reader: R) -> IoResult<Self> {
let variant = Variant::read_le(&mut reader)?;
let literal = match variant {
0 => {
let plaintext_hash: Field<N> = FromBytes::read_le(&mut reader)?;
let plaintext_exists: bool = FromBytes::read_le(&mut reader)?;
let plaintext = match plaintext_exists {
true => Some(FromBytes::read_le(&mut reader)?),
false => None,
};
Self::Constant(plaintext_hash, plaintext)
}
1 => {
let plaintext_hash: Field<N> = FromBytes::read_le(&mut reader)?;
let plaintext_exists: bool = FromBytes::read_le(&mut reader)?;
let plaintext = match plaintext_exists {
true => Some(FromBytes::read_le(&mut reader)?),
false => None,
};
Self::Public(plaintext_hash, plaintext)
}
2 => {
let ciphertext_hash: Field<N> = FromBytes::read_le(&mut reader)?;
let ciphertext_exists: bool = FromBytes::read_le(&mut reader)?;
let ciphertext = match ciphertext_exists {
true => Some(FromBytes::read_le(&mut reader)?),
false => None,
};
Self::Private(ciphertext_hash, ciphertext)
}
3 => {
let serial_number: Field<N> = FromBytes::read_le(&mut reader)?;
let tag: Field<N> = FromBytes::read_le(&mut reader)?;
Self::Record(serial_number, tag)
}
4 => Self::ExternalRecord(FromBytes::read_le(&mut reader)?),
5.. => return Err(error(format!("Failed to decode transition input variant {variant}"))),
};
Ok(literal)
}
}
impl<N: Network> ToBytes for Input<N> {
fn write_le<W: Write>(&self, mut writer: W) -> IoResult<()> {
match self {
Self::Constant(plaintext_hash, plaintext) => {
(0 as Variant).write_le(&mut writer)?;
plaintext_hash.write_le(&mut writer)?;
match plaintext {
Some(plaintext) => {
true.write_le(&mut writer)?;
plaintext.write_le(&mut writer)
}
None => false.write_le(&mut writer),
}
}
Self::Public(plaintext_hash, plaintext) => {
(1 as Variant).write_le(&mut writer)?;
plaintext_hash.write_le(&mut writer)?;
match plaintext {
Some(plaintext) => {
true.write_le(&mut writer)?;
plaintext.write_le(&mut writer)
}
None => false.write_le(&mut writer),
}
}
Self::Private(ciphertext_hash, ciphertext) => {
(2 as Variant).write_le(&mut writer)?;
ciphertext_hash.write_le(&mut writer)?;
match ciphertext {
Some(ciphertext) => {
true.write_le(&mut writer)?;
ciphertext.write_le(&mut writer)
}
None => false.write_le(&mut writer),
}
}
Self::Record(serial_number, tag) => {
(3 as Variant).write_le(&mut writer)?;
serial_number.write_le(&mut writer)?;
tag.write_le(&mut writer)
}
Self::ExternalRecord(input_commitment) => {
(4 as Variant).write_le(&mut writer)?;
input_commitment.write_le(&mut writer)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_bytes() {
for (_, expected) in crate::transition::input::test_helpers::sample_inputs() {
let expected_bytes = expected.to_bytes_le().unwrap();
assert_eq!(expected, Input::read_le(&expected_bytes[..]).unwrap());
}
}
}