# Enum ethcore::error::BlockError [−] [src]

    pub enum BlockError {
        TooManyUncles(OutOfBounds<usize>),
        ExtraDataOutOfBounds(OutOfBounds<usize>),
        InvalidSealArity(Mismatch<usize>),
        TooMuchGasUsed(OutOfBounds<U256>),
        InvalidUnclesHash(Mismatch<H256>),
        UncleTooOld(OutOfBounds<BlockNumber>),
        UncleIsBrother(OutOfBounds<BlockNumber>),
        UncleInChain(H256),
        UncleParentNotInChain(H256),
        InvalidStateRoot(Mismatch<H256>),
        InvalidGasUsed(Mismatch<U256>),
        InvalidTransactionsRoot(Mismatch<H256>),
        DifficultyOutOfBounds(OutOfBounds<U256>),
        InvalidDifficulty(Mismatch<U256>),
        MismatchedH256SealElement(Mismatch<H256>),
        InvalidProofOfWork(OutOfBounds<U256>),
        InvalidSeal,
        InvalidGasLimit(OutOfBounds<U256>),
        InvalidReceiptsRoot(Mismatch<H256>),
        InvalidTimestamp(OutOfBounds<u64>),
        InvalidLogBloom(Mismatch<H2048>),
        InvalidParentHash(Mismatch<H256>),
        InvalidNumber(Mismatch<BlockNumber>),
        RidiculousNumber(OutOfBounds<BlockNumber>),
        UnknownParent(H256),
        UnknownUncleParent(H256),
    }

Errors concerning block processing.

## Variants

`TooManyUncles(OutOfBounds<usize>)`

Block has too many uncles.

`ExtraDataOutOfBounds(OutOfBounds<usize>)`

Extra data is of an invalid length.

`InvalidSealArity(Mismatch<usize>)`

Seal is incorrect format.

`TooMuchGasUsed(OutOfBounds<U256>)`

Block has too much gas used.

`InvalidUnclesHash(Mismatch<H256>)`

Uncles hash in header is invalid.

`UncleTooOld(OutOfBounds<BlockNumber>)`

An uncle is from a generation too old.

`UncleIsBrother(OutOfBounds<BlockNumber>)`

An uncle is from the same generation as the block.

`UncleInChain(H256)`

An uncle is already in the chain.

`UncleParentNotInChain(H256)`

An uncle has a parent not in the chain.

`InvalidStateRoot(Mismatch<H256>)`

State root header field is invalid.

`InvalidGasUsed(Mismatch<U256>)`

Gas used header field is invalid.

`InvalidTransactionsRoot(Mismatch<H256>)`

Transactions root header field is invalid.

`DifficultyOutOfBounds(OutOfBounds<U256>)`

Difficulty is out of range; this can be used as an looser error prior to getting a definitive value for difficulty. This error needs only provide bounds of which it is out.

`InvalidDifficulty(Mismatch<U256>)`

Difficulty header field is invalid; this is a strong error used after getting a definitive value for difficulty (which is provided).

`MismatchedH256SealElement(Mismatch<H256>)`

Seal element of type H256 (max_hash for Ethash, but could be something else for other seal engines) is out of bounds.

`InvalidProofOfWork(OutOfBounds<U256>)`

Proof-of-work aspect of seal, which we assume is a 256-bit value, is invalid.

`InvalidSeal`

Some low-level aspect of the seal is incorrect.

`InvalidGasLimit(OutOfBounds<U256>)`

Gas limit header field is invalid.

`InvalidReceiptsRoot(Mismatch<H256>)`

Receipts trie root header field is invalid.

`InvalidTimestamp(OutOfBounds<u64>)`

Timestamp header field is invalid.

`InvalidLogBloom(Mismatch<H2048>)`

Log bloom header field is invalid.

`InvalidParentHash(Mismatch<H256>)`

Parent hash field of header is invalid; this is an invalid error indicating a logic flaw in the codebase. TODO: remove and favour an assert!/panic!.

`InvalidNumber(Mismatch<BlockNumber>)`

Number field of header is invalid.

`RidiculousNumber(OutOfBounds<BlockNumber>)`

Block number isn't sensible.

`UnknownParent(H256)`

Parent given is unknown.

`UnknownUncleParent(H256)`

Uncle parent given is unknown.

## Trait Implementations

### `impl Debug for BlockError`
[src]

#### `fn fmt(&self, __arg_0: &mut Formatter) -> Result`

Formats the value using the given formatter.

### `impl PartialEq for BlockError`
[src]

#### `fn eq(&self, __arg_0: &BlockError) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, __arg_0: &BlockError) -> bool`

This method tests for `!=`.

### `impl Clone for BlockError`
[src]

#### `fn clone(&self) -> BlockError`

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`
1.0.0

Performs copy-assignment from `source`. Read more

### `impl Copy for BlockError`
[src]

### `impl Eq for BlockError`
[src]

### `impl Display for BlockError`
[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`

Formats the value using the given formatter.

### `impl BinaryConvertable for BlockError where BlockError: Copy`

#### `fn from_bytes(bytes: &[u8],
_length_stack: &mut VecDeque<usize>)
-> Result<Self, BinaryConvertError>`

#### `fn to_bytes(&self,
buffer: &mut [u8],
_length_stack: &mut VecDeque<usize>)
-> Result<(), BinaryConvertError>`

#### `fn size(&self) -> usize`

#### `fn from_empty_bytes() -> Result<Self, BinaryConvertError>`

#### `fn len_params() -> usize`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)