Struct massa_models::block_header::BlockHeaderSerializer

pub struct BlockHeaderSerializer {
    slot_serializer: SlotSerializer,
    endorsement_serializer: SecureShareSerializer,
    endorsement_content_serializer: EndorsementSerializerLW,
    denunciation_serializer: DenunciationSerializer,
    u32_serializer: U32VarIntSerializer,
    opt_serializer: OptionSerializer<u32, U32VarIntSerializer>,
    block_id_serializer: BlockIdSerializer,
}

Serializer for BlockHeader

Fields

slot_serializer: SlotSerializer

endorsement_serializer: SecureShareSerializer

endorsement_content_serializer: EndorsementSerializerLW

denunciation_serializer: DenunciationSerializer

u32_serializer: U32VarIntSerializer

opt_serializer: OptionSerializer<u32, U32VarIntSerializer>

block_id_serializer: BlockIdSerializer

Implementations

impl BlockHeaderSerializer

pub fn new() -> Self

Creates a new BlockHeaderSerializer

Trait Implementations

impl Default for BlockHeaderSerializer

fn default() -> Self

Returns the “default value” for a type.

impl Serializer<BlockHeader> for BlockHeaderSerializer

fn serialize( &self, value: &BlockHeader, buffer: &mut Vec<u8>, ) -> Result<(), SerializeError>

Example:

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

let keypair = KeyPair::generate(0).unwrap();
let parents = (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,
  operation_merkle_root: Hash::compute_from("mno".as_bytes()),
  endorsements: vec![
    Endorsement::new_verifiable(
       Endorsement {
         slot: Slot::new(1, 1),
         index: 1,
         endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk1".as_bytes())),
       },
    EndorsementSerializer::new(),
    &keypair,
    *CHAINID
    )
    .unwrap(),
    Endorsement::new_verifiable(
      Endorsement {
        slot: Slot::new(4, 0),
        index: 3,
        endorsed_block: BlockId::generate_from_hash(Hash::compute_from("blk2".as_bytes())),
      },
    EndorsementSerializer::new(),
    &keypair,
    *CHAINID
    )
    .unwrap(),
   ],
  denunciations: vec![],
};
let mut buffer = vec![];
BlockHeaderSerializer::new().serialize(&header, &mut buffer).unwrap();