Struct massa_models::block_header::BlockHeader

pub struct BlockHeader {
    pub current_version: u32,
    pub announced_version: Option<u32>,
    pub slot: Slot,
    pub parents: Vec<BlockId>,
    pub operation_merkle_root: Hash,
    pub endorsements: Vec<SecureShareEndorsement>,
    pub denunciations: Vec<Denunciation>,
}

block header

Fields

current_version: u32

current network version

announced_version: Option<u32>

announced network version

slot: Slot

slot

parents: Vec<BlockId>

parents

operation_merkle_root: Hash

all operations hash

endorsements: Vec<SecureShareEndorsement>

endorsements

denunciations: Vec<Denunciation>

denunciations

Trait Implementations

impl Clone for BlockHeader

fn clone(&self) -> BlockHeader

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BlockHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BlockHeader

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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);

impl Display for BlockHeader

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<BlockHeader> for BlockHeader

fn from(value: BlockHeader) -> Self

Converts to this type from the input type.

impl SecureShareContent for BlockHeader

fn compute_signed_hash( &self, public_key: &PublicKey, content_hash: &Hash, ) -> Hash

compute the signed hash

fn sign( &self, keypair: &KeyPair, content_hash: &Hash, ) -> Result<Signature, ModelsError>

Sign the SecureShare given the content

fn verify_signature( &self, public_key: &PublicKey, content_hash: &Hash, signature: &Signature, ) -> Result<(), ModelsError>

verify signature

fn new_verifiable<Ser: Serializer<Self>, ID: Id>( self, content_serializer: Ser, keypair: &KeyPair, chain_id: u64, ) -> Result<SecureShare<Self, ID>, ModelsError>

Using the provided key-pair, applies a cryptographic signature, and packages the data required to share and verify the data in a trust-free network of peers.

fn compute_hash( &self, content_serialized: &[u8], content_creator_pub_key: &PublicKey, _chain_id: u64, ) -> Hash

Compute hash

fn serialize( signature: &Signature, creator_public_key: &PublicKey, serialized_content: &[u8], buffer: &mut Vec<u8>, ) -> Result<(), SerializeError>

Serialize the secured structure

fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>, Deser: Deserializer<Self>, ID: Id>( content_serializer: Option<&dyn Serializer<Self>>, signature_deserializer: &SignatureDeserializer, creator_public_key_deserializer: &PublicKeyDeserializer, content_deserializer: &Deser, buffer: &'a [u8], chain_id: u64, ) -> IResult<&'a [u8], SecureShare<Self, ID>, E>

Deserialize the secured structure

impl Serialize for BlockHeader

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

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();