Struct RequestFinalizeBlock 

pub struct RequestFinalizeBlock {
    pub commit: Option<CommitInfo>,
    pub misbehavior: Vec<Misbehavior>,
    pub hash: Vec<u8>,
    pub height: i64,
    pub round: i32,
    pub block: Option<Block>,
    pub block_id: Option<BlockId>,
}

Finalize newly decided block.

Usage

• Contains the fields of the newly decided block.
• The height and timestamp values match the values from the header of the proposed block.
• The Application can use RequestFinalizeBlock.decided_last_commit and RequestFinalizeBlock.byzantine_validators to determine rewards and punishments for the validators.
• The application must execute the transactions in full, in the order they appear in RequestFinalizeBlock.txs, before returning control to Tenderdash. Alternatively, it can commit the candidate state corresponding to the same block previously executed via PrepareProposal or ProcessProposal.
• If ProcessProposal for the same arguments have succeeded, FinalizeBlock MUST always succeed.
• Application is expected to persist its state at the end of this call, before returning ResponseFinalizeBlock.
• Later calls to Query can return proofs about the application state anchored in this Merkle root hash.
• Use ResponseFinalizeBlock.retain_height with caution! If all nodes in the network remove historical blocks then this data is permanently lost, and no new nodes will be able to join the network and bootstrap. Historical blocks may also be required for other purposes, e.g. auditing, replay of non-persisted heights, light client verification, and so on.
• Just as ProcessProposal, the implementation of FinalizeBlock MUST be deterministic, since it is making the Application’s state evolve in the context of state machine replication.
• Currently, Tenderdash will fill up all fields in RequestFinalizeBlock, even if they were already passed on to the Application via RequestPrepareProposal or RequestProcessProposal. If the Application is in same-block execution mode, it applies the right candidate state here (rather than executing the whole block). In this case the Application disregards all parameters in RequestFinalizeBlock except RequestFinalizeBlock.hash.

Fields

commit: Option<CommitInfo>

Info about the current commit

misbehavior: Vec<Misbehavior>

List of information about validators that acted incorrectly.

hash: Vec<u8>

The block header’s hash. Present for convenience (can be derived from the block header).

height: i64

The height of the finalized block.

round: i32

Round number for the block

block: Option<Block>

The block that was finalized

block_id: Option<BlockId>

The block ID that was finalized

Trait Implementations

impl Clone for RequestFinalizeBlock

fn clone(&self) -> RequestFinalizeBlock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequestFinalizeBlock

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

Formats the value using the given formatter.

impl Default for RequestFinalizeBlock

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RequestFinalizeBlock

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<RequestFinalizeBlock> for Value

fn from(value: RequestFinalizeBlock) -> Self

Converts to this type from the input type.

impl Message for RequestFinalizeBlock

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

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

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

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

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for RequestFinalizeBlock

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for RequestFinalizeBlock

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RequestFinalizeBlock