Struct ethcore::engines::AuthorityRound

pub struct AuthorityRound { /* private fields */ }

Engine using AuthorityRound proof-of-authority BFT consensus.

Implementations

impl AuthorityRound

pub fn new(
    our_params: AuthorityRoundParams,
    machine: EthereumMachine
) -> Result<Arc<Self>, Error>

Create a new instance of AuthorityRound engine.

Trait Implementations

impl Engine<EthereumMachine> for AuthorityRound

fn seal_fields(&self, header: &Header) -> usize

Three fields - consensus step and the corresponding proposer signature, and a list of empty step messages (which should be empty if no steps are skipped)

fn extra_info(&self, header: &Header) -> BTreeMap<String, String>

Additional engine-specific information for the user/developer concerning header.

fn generate_seal(&self, block: &ExecutedBlock, parent: &Header) -> Seal

Attempt to seal the block internally.

This operation is synchronous and may (quite reasonably) not be available, in which case Seal::None will be returned.

fn on_new_block(
    &self,
    block: &mut ExecutedBlock,
    epoch_begin: bool,
    _ancestry: &mut dyn Iterator<Item = ExtendedHeader>
) -> Result<(), Error>

Apply operations on new epoch. Apply rewrite bytecode transitions if available.

fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error>

Apply the block reward on finalisation of the block.

fn verify_block_basic(&self, header: &Header) -> Result<(), Error>

Check the number of seal fields.

fn verify_block_family(
    &self,
    header: &Header,
    parent: &Header
) -> Result<(), Error>

Do the step and gas limit validation.

fn name(&self) -> &str

The name of this engine.

fn machine(&self) -> &EthereumMachine

Get access to the underlying state machine.

fn step(&self)

Trigger next step of the consensus engine.

fn maximum_uncle_count(&self, block: BlockNumber) -> usize

Maximum number of uncles a block is allowed to declare.

fn populate_from_parent(&self, header: &mut Header, parent: &Header)

Populate a header’s fields based on its parent’s header. Usually implements the chain scoring rule based on weight.

fn is_allowed_to_seal(&self) -> bool

Returns whether the current node is a validator and actually may seal a block if AuRa engine is used.

fn sealing_state(&self) -> SealingState

Returns the engine’s current sealing state.

fn handle_message(&self, rlp: &[u8]) -> Result<(), EngineError>

Handle any potential consensus messages; updating consensus state and potentially issuing a new one.

fn verify_local_seal(&self, _header: &Header) -> Result<(), Error>

Verify a locally-generated seal of a header.

fn generate_engine_transactions(
    &self,
    block: &ExecutedBlock
) -> Result<Vec<SignedTransaction>, Error>

Returns a list of transactions for a new block if we are the author.

fn verify_block_external(&self, header: &Header) -> Result<(), Error>

Phase 4 verification. Verify block header against potentially external data. Should only be called when register_client has been called previously.

fn genesis_epoch_data(
    &self,
    header: &Header,
    call: &Call<'_>
) -> Result<Vec<u8>, String>

Genesis epoch data.

fn signals_epoch_end(
    &self,
    header: &Header,
    aux: AuxiliaryData<'_>
) -> EpochChange<EthereumMachine>

Whether an epoch change is signalled at the given header but will require finality. If a change can be enacted immediately then return No from this function but Yes from is_epoch_end.

fn is_epoch_end(
    &self,
    chain_head: &Header,
    finalized: &[H256],
    chain: &Headers<'_, Header>,
    transition_store: &PendingTransitionStore<'_>
) -> Option<Vec<u8>>

Whether a block is the end of an epoch.

fn epoch_verifier<'a>(
    &self,
    _header: &Header,
    proof: &'a [u8]
) -> ConstructedVerifier<'a, EthereumMachine>

Create an epoch verifier from validation proof and a flag indicating whether finality is required.

fn register_client(&self, client: Weak<dyn EngineClient>)

Add Client which can be used for sealing, potentially querying the state and sending messages.

fn set_signer(&self, signer: Option<Box<dyn EngineSigner>>)

Register a component which signs consensus messages.

fn sign(&self, hash: H256) -> Result<Signature, Error>

Sign using the EngineSigner, to be used for consensus tx signing.

fn snapshot_components(&self) -> Option<Box<dyn SnapshotComponents>>

Create a factory for building snapshot chunks and restoring from them. Returning None indicates that this engine doesn’t support snapshot creation.

fn fork_choice(
    &self,
    new: &ExtendedHeader,
    current: &ExtendedHeader
) -> ForkChoice

Check whether the given new block is the best block, after finalization check.

fn ancestry_actions(
    &self,
    header: &Header,
    ancestry: &mut dyn Iterator<Item = ExtendedHeader>
) -> Vec<AncestryAction>

the ancestry exists.

fn gas_limit_override(&self, header: &Header) -> Option<U256>

Overrides the block gas limit. Whenever this returns Some for a header, the next block’s gas limit must be exactly that value. used by AuRa engine.

fn maximum_gas_limit(&self) -> Option<U256>

Optional maximum gas limit.

fn on_seal_block(&self, _block: &mut ExecutedBlock) -> Result<(), Error>

Allow mutating the header during seal generation. Currently only used by Clique.

fn should_reseal_on_update(&self) -> bool

Called in miner.chain_new_blocks if the engine wishes to update_sealing after a block was recently sealed.

fn verify_block_unordered(&self, _header: &Header) -> Result<(), M::Error>

Phase 2 verification. Perform costly checks such as transaction signatures. Returns either a null Ok or a general error detailing the problem with import. The verification module can optionally avoid checking the seal (check_seal), if seal verification is disabled this method won’t be called.

fn supports_warp(&self) -> bool

Whether this engine supports warp sync.

fn open_block_header_timestamp(&self, parent_timestamp: u64) -> u64

Return a new open block header timestamp based on the parent timestamp.

fn is_timestamp_valid(
    &self,
    header_timestamp: u64,
    parent_timestamp: u64
) -> bool

Check whether the parent timestamp is valid.

fn executive_author(&self, header: &Header) -> Result<Address, Error>

Returns author should used when executing tx’s for this block.