Struct RequestProcessProposal 

pub struct RequestProcessProposal {

    pub txs: Vec<Vec<u8>>,
    pub proposed_last_commit: Option<CommitInfo>,
    pub misbehavior: Vec<Misbehavior>,
    pub hash: Vec<u8>,
    pub height: i64,
    pub round: i32,
    pub time: Option<Timestamp>,
    pub next_validators_hash: Vec<u8>,
    pub core_chain_locked_height: u32,
    pub core_chain_lock_update: Option<CoreChainLock>,
    pub proposer_pro_tx_hash: Vec<u8>,
    pub proposed_app_version: u64,
    pub version: Option<Consensus>,
    pub quorum_hash: Vec<u8>,
}

Process prepared proposal.

Usage

• Contains fields from the proposed block.
  • The Application may fully execute the block as though it was handling RequestFinalizeBlock. However, any resulting state changes must be kept as candidate state, and the Application should be ready to backtrack/discard it in case the decided block is different.
• The height and timestamp values match the values from the header of the proposed block.
• If ResponseProcessProposal.status is REJECT, Tenderdash assumes the proposal received is not valid.
• In same-block execution mode, the Application is required to fully execute the block and provide values for parameters ResponseProcessProposal.app_hash, ResponseProcessProposal.tx_results, ResponseProcessProposal.validator_updates, and ResponseProcessProposal.consensus_param_updates, so that Tenderdash can then verify the hashes in the block’s header are correct. If the hashes mismatch, Tenderdash will reject the block even if ResponseProcessProposal.status was set to ACCEPT.
• The implementation of ProcessProposal MUST be deterministic. Moreover, the value of ResponseProcessProposal.status MUST exclusively depend on the parameters passed in the call to RequestProcessProposal, and the last committed Application state (see Requirements section).
• Moreover, application implementors SHOULD always set ResponseProcessProposal.status to ACCEPT, unless they really know what the potential liveness implications of returning REJECT are.

When does Tenderdash call it?

When a validator p enters Tenderdash consensus round r, height h, in which q is the proposer (possibly p = q):

1. p sets up timer ProposeTimeout.
2. If p is the proposer, p executes steps 1-6 in PrepareProposal.
3. Upon reception of Proposal message (which contains the header) for round r, height h from q, p’s Tenderdash verifies the block header.
4. Upon reception of Proposal message, along with all the block parts, for round r, height h from q, p’s Tenderdash follows its algorithm to check whether it should prevote for the block just received, or nil
5. If Tenderdash should prevote for the block just received
   1. Tenderdash calls RequestProcessProposal with the block. The call is synchronous.
   2. The Application checks/processes the proposed block, which is read-only, and returns true (accept) or false (reject) in ResponseProcessProposal.accept.
      • The Application, depending on its needs, may call ResponseProcessProposal
        • either after it has completely processed the block (the simpler case),
        • or immediately (after doing some basic checks), and process the block asynchronously. In this case the Application will not be able to reject the block, or force prevote/precommit nil afterwards.
   3. If the returned value is
      • accept, Tenderdash prevotes on this proposal for round r, height h.
      • reject, Tenderdash prevotes nil.

Fields

txs: Vec<Vec<u8>>

List of transactions that have been picked as part of the proposed

proposed_last_commit: Option<CommitInfo>

Info about the last commit, obtained from the information in the proposed block.

misbehavior: Vec<Misbehavior>

List of information about validators that acted incorrectly.

hash: Vec<u8>

The block header’s hash of the proposed block. It is computed as a Merkle tree from the header fields.

height: i64

The height of the proposed block.

round: i32

Round number for the block

time: Option<Timestamp>

Timestamp included in the proposed block.

next_validators_hash: Vec<u8>

Merkle root of the next validator set.

core_chain_locked_height: u32

Core chain lock height to be used when signing this block.

core_chain_lock_update: Option<CoreChainLock>

Next core-chain-lock-update for validation in ABCI.

proposer_pro_tx_hash: Vec<u8>

ProTxHash of the original proposer of the block.

proposed_app_version: u64

Proposer’s latest available app protocol version.

version: Option<Consensus>

App and block version used to generate the block. App version MUST be verified by the app.

quorum_hash: Vec<u8>

quorum_hash contains hash of validator quorum that will sign the block

Trait Implementations

impl Clone for RequestProcessProposal

fn clone(&self) -> RequestProcessProposal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RequestProcessProposal

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

Formats the value using the given formatter.

impl Default for RequestProcessProposal

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RequestProcessProposal

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<RequestProcessProposal> for Value

fn from(value: RequestProcessProposal) -> Self

Converts to this type from the input type.

impl Message for RequestProcessProposal

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 RequestProcessProposal

fn eq(&self, other: &RequestProcessProposal) -> 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 RequestProcessProposal

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 RequestProcessProposal