Struct massa_models::block::BlockSerializer

pub struct BlockSerializer {
    header_serializer: SecureShareSerializer,
    op_ids_serializer: OperationIdsSerializer,
}

Serializer for Block

Fields

header_serializer: SecureShareSerializer

op_ids_serializer: OperationIdsSerializer

Implementations

impl BlockSerializer

pub fn new() -> Self

Creates a new BlockSerializer

Trait Implementations

impl Default for BlockSerializer

fn default() -> Self

Returns the “default value” for a type.

impl Serializer<Block> for BlockSerializer

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

Example:

use massa_models::{block::{Block, BlockSerializer}, config::THREAD_COUNT, slot::Slot, endorsement::{Endorsement, EndorsementSerializer}, secure_share::SecureShareContent, prehash::PreHashSet};
use massa_models::block_header::{BlockHeader, BlockHeaderSerializer};
use massa_models::block_id::{BlockId};
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 = (0..THREAD_COUNT)
    .map(|i| BlockId::generate_from_hash(Hash::compute_from(&[i])))
    .collect();

// create block header
let orig_header = BlockHeader::new_verifiable(
    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::new(),
    },
    BlockHeaderSerializer::new(),
    &keypair,
    *CHAINID
)
.unwrap();

// create block
let orig_block = Block {
    header: orig_header,
    operations: Vec::new(),
};

let mut buffer = Vec::new();
BlockSerializer::new().serialize(&orig_block, &mut buffer).unwrap();