Trait ethcore::engines::Engine[−][src]

pub trait Engine<M: Machine>: Sync + Send {
    fn name(&self) -> &str;

    fn machine(&self) -> &M;

    fn verify_local_seal(&self, header: &M::Header) -> Result<(), M::Error>;

    fn fork_choice(
        &self, 
        new: &M::ExtendedHeader, 
        best: &M::ExtendedHeader
    ) -> ForkChoice;

    fn seal_fields(&self, _header: &M::Header) -> usize { ... }

    fn extra_info(&self, _header: &M::Header) -> BTreeMap<String, String> { ... }

    fn maximum_uncle_count(&self, _block: BlockNumber) -> usize { ... }

    fn maximum_uncle_age(&self) -> usize { ... }

    fn on_new_block(
        &self, 
        _block: &mut M::LiveBlock, 
        _epoch_begin: bool, 
        _ancestry: &mut Iterator<Item = M::ExtendedHeader>
    ) -> Result<(), M::Error> { ... }

    fn on_close_block(&self, _block: &mut M::LiveBlock) -> Result<(), M::Error> { ... }

    fn seals_internally(&self) -> Option<bool> { ... }

    fn generate_seal(&self, _block: &M::LiveBlock, _parent: &M::Header) -> Seal { ... }

    fn verify_block_basic(&self, _header: &M::Header) -> Result<(), M::Error> { ... }

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

    fn verify_block_family(
        &self, 
        _header: &M::Header, 
        _parent: &M::Header
    ) -> Result<(), M::Error> { ... }

    fn verify_block_external(&self, _header: &M::Header) -> Result<(), M::Error> { ... }

    fn genesis_epoch_data<'a>(
        &self, 
        _header: &M::Header, 
        _state: &<M as Localized<'a>>::StateContext
    ) -> Result<Vec<u8>, String> { ... }

    fn signals_epoch_end<'a>(
        &self, 
        _header: &M::Header, 
        _aux: <M as Localized<'a>>::AuxiliaryData
    ) -> EpochChange<M> { ... }

    fn is_epoch_end(
        &self, 
        _chain_head: &M::Header, 
        _chain: &Headers<M::Header>, 
        _transition_store: &PendingTransitionStore
    ) -> Option<Vec<u8>> { ... }

    fn epoch_verifier<'a>(
        &self, 
        _header: &M::Header, 
        _proof: &'a [u8]
    ) -> ConstructedVerifier<'a, M> { ... }

    fn populate_from_parent(&self, _header: &mut M::Header, _parent: &M::Header) { ... }

    fn handle_message(&self, _message: &[u8]) -> Result<(), EngineError> { ... }

    fn is_proposal(&self, _verified_header: &M::Header) -> bool { ... }

    fn set_signer(
        &self, 
        _account_provider: Arc<AccountProvider>, 
        _address: Address, 
        _password: Password
    ) { ... }

    fn sign(&self, _hash: H256) -> Result<Signature, M::Error> { ... }

    fn register_client(&self, _client: Weak<M::EngineClient>) { ... }

    fn step(&self) { ... }

    fn stop(&self) { ... }

    fn snapshot_components(&self) -> Option<Box<SnapshotComponents>> { ... }

    fn supports_warp(&self) -> bool { ... }

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

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

    fn ancestry_actions(
        &self, 
        _block: &M::LiveBlock, 
        _ancestry: &mut Iterator<Item = M::ExtendedHeader>
    ) -> Vec<AncestryAction> { ... }
}

A consensus mechanism for the chain. Generally either proof-of-work or proof-of-stake-based. Provides hooks into each of the major parts of block import.

Required Methods

The name of this engine.

ⓘImportant traits for &'a mut R

Get access to the underlying state machine.

Verify a locally-generated seal of a header.

If this engine seals internally, no checks have to be done here, since all internally generated seals should be valid.

Externally-generated seals (e.g. PoW) will need to be checked for validity.

It is fine to require access to state or a full client for this function, since light clients do not generate seals.

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

Provided Methods

The number of additional header fields required for this engine.

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

Maximum number of uncles a block is allowed to declare.

The number of generations back that uncles can be.

Block transformation functions, before the transactions. epoch_begin set to true if this block kicks off an epoch.

Block transformation functions, after the transactions.

None means that it requires external input (e.g. PoW) to seal a block. Some(true) means the engine is currently prime for seal generation (i.e. node is the current validator). Some(false) means that the node might seal internally but is not qualified now.

Attempt to seal the block internally.

If Some is returned, then you get a valid seal.

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

It is fine to require access to state or a full client for this function, since light clients do not generate seals.

Phase 1 quick block verification. Only does checks that are cheap. Returns either a null Ok or a general error detailing the problem with import.

Phase 2 verification. Perform costly checks such as transaction signatures. Returns either a null Ok or a general error detailing the problem with import.

Phase 3 verification. Check block information against parent. Returns either a null Ok or a general error detailing the problem with import.

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

Genesis epoch data.

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.

If auxiliary data of the block is required, return an auxiliary request and the function will be called again with them. Return Yes or No when the answer is definitively known.

Should not interact with state.

Whether a block is the end of an epoch.

This either means that an immediate transition occurs or a block signalling transition has reached finality. The Headers given are not guaranteed to return any blocks from any epoch other than the current.

Return optional transition proof.

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

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

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

Find out if the block is a proposal block and should not be inserted into the DB. Takes a header of a fully verified block.

Register an account which signs consensus messages.

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

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

Trigger next step of the consensus engine.

Stops any services that the may hold the Engine and makes it safe to drop.

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

Whether this engine supports warp sync.

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

Check whether the parent timestamp is valid.

ⓘImportant traits for Vec<u8>

Gather all ancestry actions. Called at the last stage when a block is committed. The Engine must guarantee that the ancestry exists.

Implementations on Foreign Types

impl Engine<EthereumMachine> for Arc<Ethash>
[src]

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

Apply the block reward on finalisation of the block. This assumes that all uncles are valid uncles (i.e. of at least one generation before the current).

ⓘImportant traits for Vec<u8>

Implementors