From a7d7cb9ecb0d6a0838553f7a2b2fc39fc4aa32c2 Mon Sep 17 00:00:00 2001 From: Robert Habermeier Date: Fri, 20 May 2016 18:13:16 -0400 Subject: [PATCH] add Display impl for ethcore::Error, UtilError --- ethcore/src/error.rs | 168 ++++++++++++++++++++++++++++++++++++++++++- util/src/error.rs | 30 ++++++++ 2 files changed, 197 insertions(+), 1 deletion(-) diff --git a/ethcore/src/error.rs b/ethcore/src/error.rs index 110d37a0b..060403746 100644 --- a/ethcore/src/error.rs +++ b/ethcore/src/error.rs @@ -60,6 +60,43 @@ pub enum TransactionError { InvalidGasLimit(OutOfBounds), } +impl fmt::Display for TransactionError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + use self::TransactionError::*; + let msg = match *self { + AlreadyImported => { + "Already imported".into() + } + Old => { + "No longer valid".into() + } + TooCheapToReplace => { + "Gas price too low to replace".into() + } + LimitReached => { + "Transaction limit reached".into() + } + InsufficientGasPrice { minimal, got } => { + format!("Insufficient gas price. Min={}, Given={}", + minimal, got) + } + InsufficientBalance { balance, cost } => { + format!("Insufficient balance for transaction. Balance={}, Cost={}", + balance, cost) + } + GasLimitExceeded { limit, got } => { + format!("Gas limit exceeded. Limit={}, Given={}", + limit, got) + } + InvalidGasLimit(ref err) => { + format!("Invalid gas limit. {}", err) + } + }; + + f.write_fmt(format_args!("Transaction error ({})", msg)) + } +} + #[derive(Debug, PartialEq, Eq)] /// Errors concerning block processing. pub enum BlockError { @@ -98,7 +135,7 @@ pub enum BlockError { MismatchedH256SealElement(Mismatch), /// Proof-of-work aspect of seal, which we assume is a 256-bit value, is invalid. InvalidProofOfWork(OutOfBounds), - /// Some low-level aspect of the seal in incorrect. + /// Some low-level aspect of the seal is incorrect. InvalidSeal, /// Gas limit header field is invalid. InvalidGasLimit(OutOfBounds), @@ -121,6 +158,95 @@ pub enum BlockError { UnknownUncleParent(H256), } +impl fmt::Display for BlockError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + use self::BlockError::*; + + let msg = match *self { + TooManyUncles(ref oob) => { + format!("Block has too many uncles. {}", oob) + } + ExtraDataOutOfBounds(ref oob) => { + format!("Extra block data too long. {}", oob) + } + InvalidSealArity(ref mis) => { + format!("Block seal in incorrect format: {}", mis) + } + TooMuchGasUsed(ref oob) => { + format!("Block has too much gas used. {}", oob) + } + InvalidUnclesHash(ref mis) => { + format!("Block has invalid uncles hash: {}", mis) + } + UncleTooOld(ref oob) => { + format!("Uncle block is too old. {}", oob) + } + UncleIsBrother(ref oob) => { + format!("Uncle from same generation as block. {}", oob) + } + UncleInChain(ref hash) => { + format!("Uncle {} already in chain", hash) + } + UncleParentNotInChain(ref hash) => { + format!("Uncle {} has a parent not in the chain", hash) + } + InvalidStateRoot(ref mis) => { + format!("Invalid state root in header: {}", mis) + } + InvalidGasUsed(ref mis) => { + format!("Invalid gas used in header: {}", mis) + } + InvalidTransactionsRoot(ref mis) => { + format!("Invalid transactions root in header: {}", mis) + } + DifficultyOutOfBounds(ref oob) => { + format!("Invalid block difficulty: {}", oob) + } + InvalidDifficulty(ref mis) => { + format!("Invalid block difficulty: {}", mis) + } + MismatchedH256SealElement(ref mis) => { + format!("Seal element out of bounds: {}", mis) + } + InvalidProofOfWork(ref oob) => { + format!("Block has invalid PoW: {}", oob) + } + InvalidSeal => { + "Block has invalid seal.".into() + } + InvalidGasLimit(ref oob) => { + format!("Invalid gas limit: {}", oob) + } + InvalidReceiptsRoot(ref mis) => { + format!("Invalid receipts trie root in header: {}", mis) + } + InvalidTimestamp(ref oob) => { + format!("Invalid timestamp in header: {}", oob) + } + InvalidLogBloom(ref oob) => { + format!("Invalid log bloom in header: {}", oob) + } + InvalidParentHash(ref mis) => { + format!("Invalid parent hash: {}", mis) + } + InvalidNumber(ref mis) => { + format!("Invalid number in header: {}", mis) + } + RidiculousNumber(ref oob) => { + format!("Implausible block number. {}", oob) + } + UnknownParent(ref hash) => { + format!("Unknown parent: {}", hash) + } + UnknownUncleParent(ref hash) => { + format!("Unknown uncle parent: {}", hash) + } + }; + + f.write_fmt(format_args!("Block error ({})", msg)) + } +} + #[derive(Debug, PartialEq)] /// Import to the block queue result pub enum ImportError { @@ -132,6 +258,24 @@ pub enum ImportError { KnownBad, } +impl fmt::Display for ImportError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let msg = match self { + &ImportError::AlreadyInChain => { + "block already in chain" + } + &ImportError::AlreadyQueued => { + "block already in the block queue" + } + &ImportError::KnownBad => { + "block known to be bad" + } + }; + + f.write_fmt(format_args!("Block import error ({})", msg)) + } +} + #[derive(Debug)] /// General error type which should be capable of representing all errors in ethcore. pub enum Error { @@ -155,6 +299,28 @@ pub enum Error { PowInvalid, } +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + Error::Client(ref err) => f.write_fmt(format_args!("{}", err)), + Error::Util(ref err) => f.write_fmt(format_args!("{}", err)), + Error::Block(ref err) => f.write_fmt(format_args!("{}", err)), + Error::Execution(ref err) => f.write_fmt(format_args!("{}", err)), + Error::Transaction(ref err) => f.write_fmt(format_args!("{}", err)), + Error::Import(ref err) => f.write_fmt(format_args!("{}", err)), + Error::UnknownEngineName(ref name) => { + f.write_fmt(format_args!("Unknown engine name ({})", name)) + } + Error::PowHashInvalid => { + f.write_str("Invalid or out of date PoW hash.") + } + Error::PowInvalid => { + f.write_str("Invalid nonce or mishash") + } + } + } +} + /// Result of import block operation. pub type ImportResult = Result; diff --git a/util/src/error.rs b/util/src/error.rs index 74de40734..27c97352e 100644 --- a/util/src/error.rs +++ b/util/src/error.rs @@ -30,6 +30,17 @@ pub enum BaseDataError { NegativelyReferencedHash(H256), } +impl fmt::Display for BaseDataError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + BaseDataError::NegativelyReferencedHash(hash) => { + f.write_fmt(format_args!("Entry {} removed from database more times \ + than it was added.", hash)) + } + } + } +} + #[derive(Debug)] /// General error type which should be capable of representing all errors in ethcore. pub enum UtilError { @@ -57,6 +68,25 @@ pub enum UtilError { BadSize, } +impl fmt::Display for UtilError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + UtilError::Crypto(ref err) => f.write_fmt(format_args!("{}", err)), + UtilError::StdIo(ref err) => f.write_fmt(format_args!("{}", err)), + UtilError::Io(ref err) => f.write_fmt(format_args!("{}", err)), + UtilError::AddressParse(ref err) => f.write_fmt(format_args!("{}", err)), + UtilError::AddressResolve(Some(ref err)) => f.write_fmt(format_args!("{}", err)), + UtilError::AddressResolve(_) => f.write_str("Failed to resolve network address."), + UtilError::FromHex(ref err) => f.write_fmt(format_args!("{}", err)), + UtilError::BaseData(ref err) => f.write_fmt(format_args!("{}", err)), + UtilError::Network(ref err) => f.write_fmt(format_args!("{}", err)), + UtilError::Decoder(ref err) => f.write_fmt(format_args!("{}", err)), + UtilError::SimpleString(ref msg) => f.write_str(&msg), + UtilError::BadSize => f.write_str("Bad input size."), + } + } +} + #[derive(Debug, PartialEq, Eq)] /// Error indicating an expected value was not found. pub struct Mismatch {