Struct bp_header_chain::justification::GrandpaJustification

pub struct GrandpaJustification<Header: HeaderT> {
    pub round: u64,
    pub commit: Commit<Header::Hash, Header::Number, AuthoritySignature, AuthorityId>,
    pub votes_ancestries: Vec<Header>,
}

A GRANDPA Justification is a proof that a given header was finalized at a certain height and with a certain set of authorities.

This particular proof is used to prove that headers on a bridged chain (so not our chain) have been finalized correctly.

Fields

round: u64

The round (voting period) this justification is valid for.

commit: Commit<Header::Hash, Header::Number, AuthoritySignature, AuthorityId>

The set of votes for the chain which is to be finalized.

votes_ancestries: Vec<Header>

A proof that the chain of blocks in the commit are related to each other.

Implementations

impl<H: HeaderT> GrandpaJustification<H>

pub fn max_reasonable_size<C>(required_precommits: u32) -> u32

where C: Chain + ChainWithGrandpa,

Returns reasonable size of justification using constants from the provided chain.

An imprecise analogue of MaxEncodedLen implementation. We don’t use it for any precise calculations - that’s just an estimation.

pub fn commit_target_id(&self) -> HeaderId<H::Hash, H::Number>

Return identifier of header that this justification claims to finalize.

Trait Implementations

impl<Header: Clone + HeaderT> Clone for GrandpaJustification<Header>

where Header::Hash: Clone, Header::Number: Clone,

fn clone(&self) -> GrandpaJustification<Header>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Header: HeaderT> Debug for GrandpaJustification<Header>

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

Formats the value using the given formatter.

impl<Header: HeaderT> Decode for GrandpaJustification<Header>

where Commit<Header::Hash, Header::Number, AuthoritySignature, AuthorityId>: Decode, Vec<Header>: Decode,

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<Header: HeaderT> Encode for GrandpaJustification<Header>

where Commit<Header::Hash, Header::Number, AuthoritySignature, AuthorityId>: Encode, Vec<Header>: Encode,

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy, )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<H: HeaderT> FinalityProof<<H as Header>::Hash, <H as Header>::Number> for GrandpaJustification<H>

fn target_header_hash(&self) -> H::Hash

Return hash of header that this proof is generated for.

fn target_header_number(&self) -> H::Number

Return number of header that this proof is generated for.

impl<C: ChainWithGrandpa> FindEquivocations<GrandpaJustification<<C as Chain>::Header>, JustificationVerificationContext, EquivocationProof<<C as Chain>::Hash, <C as Chain>::BlockNumber>> for GrandpaEquivocationsFinder<C>

type Error = Error

The type returned when encountering an error while looking for equivocations.

fn find_equivocations( verification_context: &JustificationVerificationContext, synced_proof: &GrandpaJustification<HeaderOf<C>>, source_proofs: &[GrandpaJustification<HeaderOf<C>>], ) -> Result<Vec<EquivocationProof<HashOf<C>, BlockNumberOf<C>>>, Self::Error>

Find equivocations.

impl<Header: PartialEq + HeaderT> PartialEq for GrandpaJustification<Header>

where Header::Hash: PartialEq, Header::Number: PartialEq,

fn eq(&self, other: &GrandpaJustification<Header>) -> 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<Header> TypeInfo for GrandpaJustification<Header>

where Commit<Header::Hash, Header::Number, AuthoritySignature, AuthorityId>: TypeInfo + 'static, Vec<Header>: TypeInfo + 'static, Header: HeaderT + TypeInfo + 'static,

type Identity = GrandpaJustification<Header>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<Header: HeaderT> EncodeLike for GrandpaJustification<Header>

where Commit<Header::Hash, Header::Number, AuthoritySignature, AuthorityId>: Encode, Vec<Header>: Encode,

impl<Header: Eq + HeaderT> Eq for GrandpaJustification<Header>

where Header::Hash: Eq, Header::Number: Eq,

impl<Header: HeaderT> StructuralPartialEq for GrandpaJustification<Header>