Struct phron_finality::sync::substrate::justification::Justification

pub struct Justification {
    pub header: Header,
    pub inner_justification: InnerJustification,
}

A justification, including the related header.

Fields

header: Header

inner_justification: InnerJustification

Implementations

impl Justification

pub fn phron_justification( header: Header, phron_justification: PhronJustification ) -> Self

pub fn genesis_justification(header: Header) -> Self

pub fn into_inner(self) -> InnerJustification

Trait Implementations

impl ChainStatus<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Justification> for SubstrateChainStatus

type Error = Error

fn finalized_at( &self, number: BlockNumber ) -> Result<FinalizationStatus<Justification>, Self::Error>

The justification at this block number, if we have it otherwise just block id if the block is finalized without justification. Should return NotFinalized variant if the request is above the top finalized.

fn block(&self, id: BlockId) -> Result<Option<Block>, Self::Error>

Export a copy of the block.

fn status_of( &self, id: BlockId ) -> Result<BlockStatus<Justification>, Self::Error>

The status of the block.

fn best_block(&self) -> Result<PhronHeader, Self::Error>

The header of the best block.

fn top_finalized(&self) -> Result<Justification, Self::Error>

The justification of the top finalized block.

fn children(&self, id: BlockId) -> Result<Vec<PhronHeader>, Self::Error>

Children of the specified block.

impl Clone for Justification

fn clone(&self) -> Justification

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Justification

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

Formats the value using the given formatter.

impl Decode for Justification

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 Encode for Justification

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<BE, C> Finalizer<Justification> for PhronFinalizer<Block, BE, C>

where BE: Backend<Block>, C: HeaderBackend<Block> + LockImportRun<Block, BE> + SubstrateFinalizer<Block, BE>,

type Error = Error

fn finalize(&self, justification: Justification) -> Result<(), Self::Error>

Finalize a block using this justification. Since the justification contains the header, we don’t need to additionally specify the block.

impl Justification for Justification

type Header = Header<u32, BlakeTwo256>

type Unverified = Justification

fn header(&self) -> &Self::Header

The header of the block.

fn into_unverified(self) -> Self::Unverified

Return an unverified version of this, for sending over the network.

impl UnverifiedJustification for Justification

type UnverifiedHeader = Header<u32, BlakeTwo256>

fn header(&self) -> &Self::UnverifiedHeader

The header of the block.

impl<AP, FS> Verifier<Justification> for VerifierCache<AP, FS, Header>

where AP: AuthorityProvider, FS: FinalizationInfo,

type Error = VerificationError

fn verify_justification( &mut self, justification: Justification ) -> Result<Justification, Self::Error>

Verifies the raw justification and returns a full justification if successful, otherwise an error.

fn verify_header(&mut self, header: Header) -> Result<Header, Self::Error>

impl EncodeLike for Justification