Struct massa_models::endorsement::Endorsement

pub struct Endorsement {
    pub slot: Slot,
    pub index: u32,
    pub endorsed_block: BlockId,
}

an endorsement, as sent in the network

Fields

slot: Slot

Slot in which the endorsement can be included

index: u32

Endorsement index inside the including block

endorsed_block: BlockId

Hash of endorsed block. This is the parent in thread self.slot.thread of the block in which the endorsement is included

Trait Implementations

impl Clone for Endorsement

fn clone(&self) -> Endorsement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Endorsement

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Endorsement

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Deserializer<Endorsement> for EndorsementDeserializer

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

Example:

use massa_models::{slot::Slot, block_id::BlockId, endorsement::{Endorsement, EndorsementSerializer, EndorsementDeserializer}};
use massa_serialization::{Serializer, Deserializer, DeserializeError};
use massa_hash::Hash;

let endorsement = Endorsement {
  slot: Slot::new(1, 2),
  index: 0,
  endorsed_block: BlockId::generate_from_hash(Hash::compute_from("test".as_bytes()))
};
let mut buffer = Vec::new();
EndorsementSerializer::new().serialize(&endorsement, &mut buffer).unwrap();
let (rest, deserialized) = EndorsementDeserializer::new(32, 10).deserialize::<DeserializeError>(&buffer).unwrap();
assert_eq!(rest.len(), 0);
assert_eq!(deserialized.slot, endorsement.slot);
assert_eq!(deserialized.index, endorsement.index);
assert_eq!(deserialized.endorsed_block, endorsement.endorsed_block);

impl Deserializer<Endorsement> for EndorsementDeserializerLW

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

Example:

use massa_models::{slot::Slot, block_id::BlockId, endorsement::{Endorsement, EndorsementSerializerLW, EndorsementDeserializerLW}};
use massa_serialization::{Serializer, Deserializer, DeserializeError};
use massa_hash::Hash;

let slot = Slot::new(1, 2);
let endorsed_block = BlockId::generate_from_hash(Hash::compute_from("test".as_bytes()));
let endorsement = Endorsement {
  slot: slot,
  index: 0,
  endorsed_block: endorsed_block
};
let mut buffer = Vec::new();
EndorsementSerializerLW::new().serialize(&endorsement, &mut buffer).unwrap();
let (rest, deserialized) = EndorsementDeserializerLW::new(10, slot, endorsed_block).deserialize::<DeserializeError>(&buffer).unwrap();
assert_eq!(rest.len(), 0);
assert_eq!(deserialized.index, endorsement.index);

impl Display for Endorsement

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

Formats the value using the given formatter.

impl From<Endorsement> for Endorsement

fn from(value: Endorsement) -> Self

Converts to this type from the input type.

impl PartialEq for Endorsement

fn eq(&self, other: &Endorsement) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SecureShareContent for Endorsement

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 Endorsement

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Serializer<Endorsement> for EndorsementSerializer

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

Example:

use massa_models::{slot::Slot, block_id::BlockId, endorsement::{Endorsement, EndorsementSerializer}};
use massa_serialization::Serializer;
use massa_hash::Hash;

let endorsement = Endorsement {
  slot: Slot::new(1, 2),
  index: 0,
  endorsed_block: BlockId::generate_from_hash(Hash::compute_from("test".as_bytes()))
};
let mut buffer = Vec::new();
EndorsementSerializer::new().serialize(&endorsement, &mut buffer).unwrap();

impl Serializer<Endorsement> for EndorsementSerializerLW

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

Example:

use massa_models::{slot::Slot, block_id::BlockId, endorsement::{Endorsement, EndorsementSerializerLW}};
use massa_serialization::Serializer;
use massa_hash::Hash;

let endorsement = Endorsement {
  slot: Slot::new(1, 2),
  index: 0,
  endorsed_block: BlockId::generate_from_hash(Hash::compute_from("test".as_bytes()))
};
let mut buffer = Vec::new();
EndorsementSerializerLW::new().serialize(&endorsement, &mut buffer).unwrap();

impl Eq for Endorsement

impl StructuralPartialEq for Endorsement