massa_models/
bytecode.rs

1use crate::serialization::{VecU8Deserializer, VecU8Serializer};
2use massa_serialization::{
3    Deserializer, SerializeError, Serializer, U64VarIntDeserializer, U64VarIntSerializer,
4};
5use nom::error::{ContextError, ParseError};
6use nom::IResult;
7use serde::{Deserialize, Serialize};
8use std::ops::Bound::Included;
9
10/// Current version of the bytecode
11pub const BYTECODE_VERSION: u64 = 0;
12
13/// Structure representing executable bytecode
14#[derive(Default, Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
15pub struct Bytecode(pub Vec<u8>);
16
17/// Serializer for `Bytecode`
18#[derive(Default)]
19pub struct BytecodeSerializer {
20    version_byte_serializer: U64VarIntSerializer,
21    vec_u8_serializer: VecU8Serializer,
22}
23
24impl BytecodeSerializer {
25    /// Creates a new `BytecodeSerializer`
26    pub fn new() -> Self {
27        Self {
28            version_byte_serializer: U64VarIntSerializer::new(),
29            vec_u8_serializer: VecU8Serializer::new(),
30        }
31    }
32}
33
34impl Serializer<Bytecode> for BytecodeSerializer {
35    fn serialize(&self, value: &Bytecode, buffer: &mut Vec<u8>) -> Result<(), SerializeError> {
36        self.version_byte_serializer
37            .serialize(&BYTECODE_VERSION, buffer)?;
38        self.vec_u8_serializer.serialize(&value.0, buffer)?;
39        Ok(())
40    }
41}
42
43/// Deserializer for `Bytecode`
44pub struct BytecodeDeserializer {
45    version_byte_deserializer: U64VarIntDeserializer,
46    vec_u8_deserializer: VecU8Deserializer,
47}
48
49impl BytecodeDeserializer {
50    /// Creates a new `BytecodeDeserializer`
51    pub fn new(max_bytecode_size: u64) -> Self {
52        Self {
53            version_byte_deserializer: U64VarIntDeserializer::new(Included(0), Included(u64::MAX)),
54            vec_u8_deserializer: VecU8Deserializer::new(
55                Included(u64::MIN),
56                Included(max_bytecode_size),
57            ),
58        }
59    }
60}
61
62impl Deserializer<Bytecode> for BytecodeDeserializer {
63    fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>(
64        &self,
65        buffer: &'a [u8],
66    ) -> IResult<&'a [u8], Bytecode, E> {
67        let (rest, _version) = self.version_byte_deserializer.deserialize(buffer)?;
68        let (rest, bytecode_vec) = self.vec_u8_deserializer.deserialize(rest)?;
69
70        Ok((rest, Bytecode(bytecode_vec)))
71    }
72}