Struct massa_models::block_header::BlockHeaderDeserializer

pub struct BlockHeaderDeserializer {

    slot_deserializer: SlotDeserializer,
    endorsement_serializer: EndorsementSerializer,
    endorsement_len_deserializer: U32VarIntDeserializer,
    hash_deserializer: HashDeserializer,
    thread_count: u8,
    endorsement_count: u32,
    last_start_period: Option<u64>,
    denunciation_len_deserializer: U32VarIntDeserializer,
    denunciation_deserializer: DenunciationDeserializer,
    network_versions_deserializer: U32VarIntDeserializer,
    opt_deserializer: OptionDeserializer<u32, U32VarIntDeserializer>,
    block_id_deserializer: BlockIdDeserializer,
    chain_id: u64,
}

Deserializer for BlockHeader

Fields

slot_deserializer: SlotDeserializer

endorsement_serializer: EndorsementSerializer

endorsement_len_deserializer: U32VarIntDeserializer

hash_deserializer: HashDeserializer

thread_count: u8

endorsement_count: u32

last_start_period: Option<u64>

denunciation_len_deserializer: U32VarIntDeserializer

denunciation_deserializer: DenunciationDeserializer

network_versions_deserializer: U32VarIntDeserializer

opt_deserializer: OptionDeserializer<u32, U32VarIntDeserializer>

block_id_deserializer: BlockIdDeserializer

chain_id: u64

Implementations

impl BlockHeaderDeserializer

pub fn new( thread_count: u8, endorsement_count: u32, max_denunciations_in_block_header: u32, last_start_period: Option<u64>, chain_id: u64, ) -> Self

Creates a new BlockHeaderDeserializer If last_start_period is Some(lsp), then the deserializer will check for valid (non)-genesis blocks

Trait Implementations

impl Deserializer<BlockHeader> for BlockHeaderDeserializer

fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>( &self, buffer: &'a [u8], ) -> IResult<&'a [u8], BlockHeader, E>

Example:

use massa_models::block_header::{BlockHeader, BlockHeaderDeserializer, BlockHeaderSerializer};
use massa_models::block_id::{BlockId};
use massa_models::{config::THREAD_COUNT, slot::Slot, secure_share::SecureShareContent};
use massa_models::endorsement::{Endorsement, EndorsementSerializer};
use massa_hash::Hash;
use massa_models::config::CHAINID;
use massa_signature::KeyPair;
use massa_serialization::{Serializer, Deserializer, DeserializeError};

let keypair = KeyPair::generate(0).unwrap();
let parents: Vec<BlockId> = (0..THREAD_COUNT)
  .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
  .collect();
let header = BlockHeader {
  current_version: 0,
  announced_version: None,
  slot: Slot::new(1, 1),
  parents: parents.clone(),
  operation_merkle_root: Hash::compute_from("mno".as_bytes()),
  endorsements: vec![
    Endorsement::new_verifiable(
       Endorsement {
         slot: Slot::new(1, 1),
         index: 0,
         endorsed_block: parents[1].clone(),
       },
    EndorsementSerializer::new(),
    &keypair,
    *CHAINID
    )
    .unwrap(),
    Endorsement::new_verifiable(
      Endorsement {
        slot: Slot::new(1, 1),
        index: 1,
        endorsed_block: parents[1].clone(),
      },
    EndorsementSerializer::new(),
    &keypair,
    *CHAINID
    )
    .unwrap(),
   ],
   denunciations: vec![],
};
let mut buffer = vec![];
BlockHeaderSerializer::new().serialize(&header, &mut buffer).unwrap();
let (rest, deserialized_header) = BlockHeaderDeserializer::new(32, 9, 10, Some(0), 77).deserialize::<DeserializeError>(&buffer).unwrap();
assert_eq!(rest.len(), 0);
let mut buffer2 = Vec::new();
BlockHeaderSerializer::new().serialize(&deserialized_header, &mut buffer2).unwrap();
assert_eq!(buffer, buffer2);