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

    pub enum Error {
        Client(ClientError),
        Util(UtilError),
        Block(BlockError),
        UnknownEngineName(String),
        Execution(ExecutionError),
        Transaction(TransactionError),
        Import(ImportError),
        PowHashInvalid,
        PowInvalid,
        Trie(TrieError),
        Io(IoError),
        StdIo(Error),
        Snappy(InvalidInput),
        Snapshot(SnapshotError),
        Engine(EngineError),
        Ethkey(EthkeyError),
        AccountProvider(AccountsError),
    }

General error type which should be capable of representing all errors in ethcore.

## Variants

`Client(ClientError)`

Client configuration error.

`Util(UtilError)`

Error concerning a utility.

`Block(BlockError)`

Error concerning block processing.

`UnknownEngineName(String)`

Unknown engine given.

`Execution(ExecutionError)`

Error concerning EVM code execution.

`Transaction(TransactionError)`

Error concerning transaction processing.

`Import(ImportError)`

Error concerning block import.

`PowHashInvalid`

PoW hash is invalid or out of date.

`PowInvalid`

The value of the nonce or mishash is invalid.

`Trie(TrieError)`

Error concerning TrieDBs

`Io(IoError)`

Io crate error.

`StdIo(Error)`

Standard io error.

`Snappy(InvalidInput)`

Snappy error.

`Snapshot(SnapshotError)`

Snapshot error.

`Engine(EngineError)`

Consensus vote error.

`Ethkey(EthkeyError)`

Ethkey error.

`AccountProvider(AccountsError)`

Account Provider error.

## Trait Implementations

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

### `impl From<ClientError> for Error`
[src]

#### `fn from(err: ClientError) -> Error`

Performs the conversion.

### `impl From<TransactionError> for Error`
[src]

#### `fn from(err: TransactionError) -> Error`

Performs the conversion.

### `impl From<ImportError> for Error`
[src]

#### `fn from(err: ImportError) -> Error`

Performs the conversion.

### `impl From<BlockError> for Error`
[src]

#### `fn from(err: BlockError) -> Error`

Performs the conversion.

### `impl From<ExecutionError> for Error`
[src]

#### `fn from(err: ExecutionError) -> Error`

Performs the conversion.

### `impl From<DecoderError> for Error`
[src]

#### `fn from(err: DecoderError) -> Error`

Performs the conversion.

### `impl From<UtilError> for Error`
[src]

#### `fn from(err: UtilError) -> Error`

Performs the conversion.

### `impl From<IoError> for Error`
[src]

#### `fn from(err: IoError) -> Error`

Performs the conversion.

### `impl From<TrieError> for Error`
[src]

#### `fn from(err: TrieError) -> Error`

Performs the conversion.

### `impl From<Error> for Error`
[src]

#### `fn from(err: Error) -> Error`

Performs the conversion.

### `impl From<BlockImportError> for Error`
[src]

#### `fn from(err: BlockImportError) -> Error`

Performs the conversion.

### `impl From<InvalidInput> for Error`
[src]

#### `fn from(err: InvalidInput) -> Error`

Performs the conversion.

### `impl From<SnapshotError> for Error`
[src]

#### `fn from(err: SnapshotError) -> Error`

Performs the conversion.

### `impl From<EngineError> for Error`
[src]

#### `fn from(err: EngineError) -> Error`

Performs the conversion.

### `impl From<EthkeyError> for Error`
[src]

#### `fn from(err: EthkeyError) -> Error`

Performs the conversion.

### `impl From<AccountsError> for Error`
[src]

#### `fn from(err: AccountsError) -> Error`

Performs the conversion.

### `impl<E> From<Box<E>> for Error where Error: From<E>`
[src]

#### `fn from(err: Box<E>) -> Error`

Performs the conversion.

# 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`)