Struct vapash_engine::Vapash

pub struct Vapash { /* fields omitted */ }

Engine using Vapash proof-of-work consensus algorithm, suitable for Vapory mainnet chains in the Olympic, Frontier and Homestead eras.

Implementations

impl Vapash

pub fn new<T: Into<Option<OptimizeFor>>>(
    cache_dir: &Path,
    vapash_params: VapashParams,
    mashina: Machine,
    optimize_for: T
) -> Self

Create a new instance of Vapash engine

Trait Implementations

impl Engine for Vapash

fn name(&self) -> &str

The name of this engine.

fn mashina(&self) -> &Machine

Get access to the underlying state mashina.

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

The number of additional header fields required for this engine.

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

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

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

Maximum number of uncles a block is allowed to declare.

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

Optional maximum gas limit.

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

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).

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

Verify a locally-generated seal of a header.

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

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. The verification module can optionally avoid checking the seal (check_seal), if seal verification is disabled this method won’t be called.

fn verify_block_unordered(&self, header: &Header) -> Result<(), 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 verify_block_family(
    &self,
    header: &Header,
    parent: &Header
) -> Result<(), Error>

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

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

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

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 snapshot_mode(&self) -> Snapshotting

Snapshot mode for the engine: Unsupported, PoW or PoA

fn params(&self) -> &CommonParams

Get the general parameters of the chain.

pub fn on_new_block(
    &self,
    _block: &mut ExecutedBlock,
    _epoch_begin: bool
) -> Result<(), VapcoreError>

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

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

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

pub fn generate_engine_transactions(
    &self,
    _block: &ExecutedBlock
) -> Result<Vec<SignedTransaction, Global>, VapcoreError>

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

pub fn sealing_state(&self) -> SealingState

Returns the engine’s current sealing state.

pub 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.

pub fn generate_seal(&self, _block: &ExecutedBlock, _parent: &Header) -> Seal

Attempt to seal the block internally.

pub fn verify_block_external(
    &self,
    _header: &Header
) -> Result<(), VapcoreError>

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

pub fn genesis_epoch_data(
    &self,
    _header: &Header,
    _state: &dyn Fn(H160, Vec<u8, Global>)
) -> Result<Vec<u8, Global>, String>

Genesis epoch data.

pub fn signals_epoch_end(
    &self,
    _header: &Header,
    _aux: AuxiliaryData<'a>
) -> EpochChange

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.

pub fn is_epoch_end(
    &self,
    _chain_head: &Header,
    _finalized: &[H256],
    _chain: &dyn Fn(H256),
    _transition_store: &dyn Fn(H256)
) -> Option<Vec<u8, Global>>

Whether a block is the end of an epoch.

pub fn is_epoch_end_light(
    &self,
    _chain_head: &Header,
    _chain: &dyn Fn(H256),
    _transition_store: &dyn Fn(H256)
) -> Option<Vec<u8, Global>>

Whether a block is the end of an epoch.

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

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

pub fn set_signer(
    &self,
    _signer: Option<Box<dyn EngineSigner + 'static, Global>>
)

Register a component which signs consensus messages.

pub fn sign(&self, _hash: H256) -> Result<Signature, VapcoreError>

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

pub fn register_client(&self, _client: Weak<dyn EngineClient + 'static>)

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

pub fn step(&self)

Trigger next step of the consensus engine.

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

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

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

Check whether the parent timestamp is valid.

pub fn ancestry_actions(
    &self,
    _header: &Header,
    _ancestry: &mut dyn Iterator<Item = ExtendedHeader>
) -> Vec<AncestryAction, Global>

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

pub fn executive_author(&self, header: &Header) -> Result<H160, VapcoreError>

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

pub 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.

pub fn schedule(&self, block_number: u64) -> Schedule

Get the VVM schedule for the given block number.

pub fn builtins(&self) -> &BTreeMap<H160, Builtin>

Builtin-contracts for the chain..

pub fn builtin(&self, a: &H160, block_number: u64) -> Option<&Builtin>

Attempt to get a handle to a built-in contract. Only returns references to activated built-ins.

pub fn maximum_extra_data_size(&self) -> usize

Some intrinsic operation parameters; by default they take their value from the spec()’s engine_params.

pub fn account_start_nonce(&self, block: u64) -> U256

The nonce with which accounts begin at given block.

pub fn signing_chain_id(&self, env_info: &EnvInfo) -> Option<u64>

The network ID that transactions should be signed with.

pub fn verify_transaction_basic(
    &self,
    t: &UnverifiedTransaction,
    header: &Header
) -> Result<(), Error>

Perform basic/cheap transaction verification.

pub fn decode_transaction(
    &self,
    transaction: &[u8]
) -> Result<UnverifiedTransaction, Error>

Performs pre-validation of RLP decoded transaction before other processing

pub fn min_gas_limit(&self) -> U256

The configured minimum gas limit.