diff --git a/ethcore/light/src/client/header_chain.rs b/ethcore/light/src/client/header_chain.rs index c3a119473..fa42f50da 100644 --- a/ethcore/light/src/client/header_chain.rs +++ b/ethcore/light/src/client/header_chain.rs @@ -33,7 +33,7 @@ use cht; use ethcore::block_status::BlockStatus; use ethcore::encoded; use ethcore::engines::epoch::{Transition as EpochTransition, PendingTransition as PendingEpochTransition}; -use ethcore::error::{Error, BlockImportError, BlockImportErrorKind, BlockError}; +use ethcore::error::{Error, EthcoreResult, ErrorKind as EthcoreErrorKind, BlockError}; use ethcore::header::Header; use ethcore::ids::BlockId; use ethcore::spec::{Spec, SpecHardcodedSync}; @@ -351,7 +351,7 @@ impl HeaderChain { transaction: &mut DBTransaction, header: &Header, transition_proof: Option>, - ) -> Result { + ) -> EthcoreResult { self.insert_inner(transaction, header, None, transition_proof) } @@ -364,7 +364,7 @@ impl HeaderChain { header: &Header, total_difficulty: U256, transition_proof: Option>, - ) -> Result { + ) -> EthcoreResult { self.insert_inner(transaction, header, Some(total_difficulty), transition_proof) } @@ -374,7 +374,7 @@ impl HeaderChain { header: &Header, total_difficulty: Option, transition_proof: Option>, - ) -> Result { + ) -> EthcoreResult { let hash = header.hash(); let number = header.number(); let parent_hash = *header.parent_hash(); @@ -403,7 +403,7 @@ impl HeaderChain { .and_then(|entry| entry.candidates.iter().find(|c| c.hash == parent_hash)) .map(|c| c.total_difficulty) .ok_or_else(|| BlockError::UnknownParent(parent_hash)) - .map_err(BlockImportErrorKind::Block)? + .map_err(EthcoreErrorKind::Block)? }; parent_td + *header.difficulty() diff --git a/ethcore/light/src/client/mod.rs b/ethcore/light/src/client/mod.rs index 3c88e8b80..e97d92589 100644 --- a/ethcore/light/src/client/mod.rs +++ b/ethcore/light/src/client/mod.rs @@ -22,7 +22,7 @@ use ethcore::block_status::BlockStatus; use ethcore::client::{ClientReport, EnvInfo, ClientIoMessage}; use ethcore::engines::{epoch, EthEngine, EpochChange, EpochTransition, Proof}; use ethcore::machine::EthereumMachine; -use ethcore::error::{Error, BlockImportError}; +use ethcore::error::{Error, EthcoreResult}; use ethcore::ids::BlockId; use ethcore::header::{BlockNumber, Header}; use ethcore::verification::queue::{self, HeaderQueue}; @@ -85,7 +85,7 @@ pub trait LightChainClient: Send + Sync { /// Queue header to be verified. Required that all headers queued have their /// parent queued prior. - fn queue_header(&self, header: Header) -> Result; + fn queue_header(&self, header: Header) -> EthcoreResult; /// Attempt to get a block hash by block id. fn block_hash(&self, id: BlockId) -> Option; @@ -206,7 +206,7 @@ impl Client { } /// Import a header to the queue for additional verification. - pub fn import_header(&self, header: Header) -> Result { + pub fn import_header(&self, header: Header) -> EthcoreResult { self.queue.import(header).map_err(Into::into) } @@ -526,7 +526,7 @@ impl LightChainClient for Client { fn chain_info(&self) -> BlockChainInfo { Client::chain_info(self) } - fn queue_header(&self, header: Header) -> Result { + fn queue_header(&self, header: Header) -> EthcoreResult { self.import_header(header) } diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index d9c2a5781..4efff53af 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -43,7 +43,7 @@ use client::{ }; use client::{ BlockId, TransactionId, UncleId, TraceId, ClientConfig, BlockChainClient, - TraceFilter, CallAnalytics, BlockImportError, Mode, + TraceFilter, CallAnalytics, Mode, ChainNotify, ChainRoute, PruningInfo, ProvingBlockChainClient, EngineInfo, ChainMessageType, IoClient, BadBlocks, }; @@ -51,8 +51,8 @@ use client::bad_blocks; use encoded; use engines::{EthEngine, EpochTransition, ForkChoice}; use error::{ - ImportErrorKind, BlockImportErrorKind, ExecutionError, CallError, BlockError, ImportResult, - QueueError, QueueErrorKind, Error as EthcoreError + ImportErrorKind, ExecutionError, CallError, BlockError, + QueueError, QueueErrorKind, Error as EthcoreError, EthcoreResult, ErrorKind as EthcoreErrorKind }; use vm::{EnvInfo, LastHashes}; use evm::Schedule; @@ -1392,23 +1392,23 @@ impl CallContract for Client { } impl ImportBlock for Client { - fn import_block(&self, unverified: Unverified) -> Result { + fn import_block(&self, unverified: Unverified) -> EthcoreResult { if self.chain.read().is_known(&unverified.hash()) { - bail!(BlockImportErrorKind::Import(ImportErrorKind::AlreadyInChain)); + bail!(EthcoreErrorKind::Import(ImportErrorKind::AlreadyInChain)); } let status = self.block_status(BlockId::Hash(unverified.parent_hash())); if status == BlockStatus::Unknown { - bail!(BlockImportErrorKind::Block(BlockError::UnknownParent(unverified.parent_hash()))); + bail!(EthcoreErrorKind::Block(BlockError::UnknownParent(unverified.parent_hash()))); } let raw = unverified.bytes.clone(); - match self.importer.block_queue.import(unverified).map_err(Into::into) { + match self.importer.block_queue.import(unverified) { Ok(res) => Ok(res), // we only care about block errors (not import errors) - Err(BlockImportError(BlockImportErrorKind::Block(err), _))=> { + Err(EthcoreError(EthcoreErrorKind::Block(err), _))=> { self.importer.bad_blocks.report(raw, format!("{:?}", err)); - bail!(BlockImportErrorKind::Block(err)) + bail!(EthcoreErrorKind::Block(err)) }, Err(e) => Err(e), } @@ -2085,14 +2085,14 @@ impl IoClient for Client { }); } - fn queue_ancient_block(&self, unverified: Unverified, receipts_bytes: Bytes) -> Result { + fn queue_ancient_block(&self, unverified: Unverified, receipts_bytes: Bytes) -> EthcoreResult { trace_time!("queue_ancient_block"); let hash = unverified.hash(); { // check block order if self.chain.read().is_known(&hash) { - bail!(BlockImportErrorKind::Import(ImportErrorKind::AlreadyInChain)); + bail!(EthcoreErrorKind::Import(ImportErrorKind::AlreadyInChain)); } let parent_hash = unverified.parent_hash(); // NOTE To prevent race condition with import, make sure to check queued blocks first @@ -2101,7 +2101,7 @@ impl IoClient for Client { if !is_parent_pending { let status = self.block_status(BlockId::Hash(parent_hash)); if status == BlockStatus::Unknown { - bail!(BlockImportErrorKind::Block(BlockError::UnknownParent(parent_hash))); + bail!(EthcoreErrorKind::Block(BlockError::UnknownParent(parent_hash))); } } } @@ -2237,7 +2237,7 @@ impl ScheduleInfo for Client { } impl ImportSealedBlock for Client { - fn import_sealed_block(&self, block: SealedBlock) -> ImportResult { + fn import_sealed_block(&self, block: SealedBlock) -> EthcoreResult { let h = block.header().hash(); let start = Instant::now(); let route = { diff --git a/ethcore/src/client/mod.rs b/ethcore/src/client/mod.rs index 964a56f53..4148bb586 100644 --- a/ethcore/src/client/mod.rs +++ b/ethcore/src/client/mod.rs @@ -50,7 +50,7 @@ pub use types::call_analytics::CallAnalytics; pub use executive::{Executed, Executive, TransactOptions}; pub use vm::{LastHashes, EnvInfo}; -pub use error::{BlockImportError, BlockImportErrorKind, TransactionImportError}; +pub use error::TransactionImportError; pub use verification::VerifierType; mod traits; diff --git a/ethcore/src/client/test_client.rs b/ethcore/src/client/test_client.rs index 81fbc4e6f..9198cadec 100644 --- a/ethcore/src/client/test_client.rs +++ b/ethcore/src/client/test_client.rs @@ -37,7 +37,7 @@ use blockchain::{TreeRoute, BlockReceipts}; use client::{ Nonce, Balance, ChainInfo, BlockInfo, ReopenBlock, CallContract, TransactionInfo, RegistryInfo, PrepareOpenBlock, BlockChainClient, BlockChainInfo, BlockStatus, BlockId, Mode, - TransactionId, UncleId, TraceId, TraceFilter, LastHashes, CallAnalytics, BlockImportError, + TransactionId, UncleId, TraceId, TraceFilter, LastHashes, CallAnalytics, ProvingBlockChainClient, ScheduleInfo, ImportSealedBlock, BroadcastProposalBlock, ImportBlock, StateOrBlock, Call, StateClient, EngineInfo, AccountData, BlockChain, BlockProducer, SealedBlockImporter, IoClient, BadBlocks, @@ -47,7 +47,7 @@ use header::{Header as BlockHeader, BlockNumber}; use filter::Filter; use log_entry::LocalizedLogEntry; use receipt::{Receipt, LocalizedReceipt, TransactionOutcome}; -use error::{Error, ImportResult}; +use error::{Error, EthcoreResult}; use vm::Schedule; use miner::{self, Miner, MinerService}; use spec::Spec; @@ -416,7 +416,7 @@ impl ScheduleInfo for TestBlockChainClient { } impl ImportSealedBlock for TestBlockChainClient { - fn import_sealed_block(&self, _block: SealedBlock) -> ImportResult { + fn import_sealed_block(&self, _block: SealedBlock) -> EthcoreResult { Ok(H256::default()) } } @@ -523,7 +523,7 @@ impl RegistryInfo for TestBlockChainClient { } impl ImportBlock for TestBlockChainClient { - fn import_block(&self, unverified: Unverified) -> Result { + fn import_block(&self, unverified: Unverified) -> EthcoreResult { let header = unverified.header; let h = header.hash(); let number: usize = header.number() as usize; @@ -883,7 +883,7 @@ impl IoClient for TestBlockChainClient { self.miner.import_external_transactions(self, txs); } - fn queue_ancient_block(&self, unverified: Unverified, _r: Bytes) -> Result { + fn queue_ancient_block(&self, unverified: Unverified, _r: Bytes) -> EthcoreResult { self.import_block(unverified) } diff --git a/ethcore/src/client/traits.rs b/ethcore/src/client/traits.rs index 719fce916..e216b49d5 100644 --- a/ethcore/src/client/traits.rs +++ b/ethcore/src/client/traits.rs @@ -24,7 +24,7 @@ use blockchain::TreeRoute; use client::Mode; use encoded; use vm::LastHashes; -use error::{Error, ImportResult, CallError, BlockImportError}; +use error::{Error, CallError, EthcoreResult}; use evm::Schedule; use executive::Executed; use filter::Filter; @@ -168,7 +168,7 @@ pub trait RegistryInfo { /// Provides methods to import block into blockchain pub trait ImportBlock { /// Import a block into the blockchain. - fn import_block(&self, block: Unverified) -> Result; + fn import_block(&self, block: Unverified) -> EthcoreResult; } /// Provides `call_contract` method @@ -205,7 +205,7 @@ pub trait IoClient: Sync + Send { fn queue_transactions(&self, transactions: Vec, peer_id: usize); /// Queue block import with transaction receipts. Does no sealing and transaction validation. - fn queue_ancient_block(&self, block_bytes: Unverified, receipts_bytes: Bytes) -> Result; + fn queue_ancient_block(&self, block_bytes: Unverified, receipts_bytes: Bytes) -> EthcoreResult; /// Queue conensus engine message. fn queue_consensus_message(&self, message: Bytes); @@ -414,7 +414,7 @@ pub trait ScheduleInfo { ///Provides `import_sealed_block` method pub trait ImportSealedBlock { /// Import sealed block. Skips all verifications. - fn import_sealed_block(&self, block: SealedBlock) -> ImportResult; + fn import_sealed_block(&self, block: SealedBlock) -> EthcoreResult; } /// Provides `broadcast_proposal_block` method diff --git a/ethcore/src/error.rs b/ethcore/src/error.rs index 29ef89612..02268747a 100644 --- a/ethcore/src/error.rs +++ b/ethcore/src/error.rs @@ -29,6 +29,7 @@ use engines::EngineError; use ethkey::Error as EthkeyError; use account_provider::SignError as AccountsError; use transaction::Error as TransactionError; +use rlp; pub use executed::{ExecutionError, CallError}; @@ -194,40 +195,6 @@ error_chain! { } } -error_chain! { - types { - BlockImportError, BlockImportErrorKind, BlockImportErrorResultExt; - } - - links { - Import(ImportError, ImportErrorKind) #[doc = "Import error"]; - Queue(QueueError, QueueErrorKind) #[doc = "Io channel queue error"]; - } - - foreign_links { - Block(BlockError) #[doc = "Block error"]; - Decoder(::rlp::DecoderError) #[doc = "Rlp decoding error"]; - } - - errors { - #[doc = "Other error"] - Other(err: String) { - description("Other error") - display("Other error {}", err) - } - } -} - -impl From for BlockImportError { - fn from(e: Error) -> Self { - match e { - Error(ErrorKind::Block(block_error), _) => BlockImportErrorKind::Block(block_error).into(), - Error(ErrorKind::Import(import_error), _) => BlockImportErrorKind::Import(import_error.into()).into(), - _ => BlockImportErrorKind::Other(format!("other block import error: {:?}", e)).into(), - } - } -} - /// Api-level error for transaction import #[derive(Debug, Clone)] pub enum TransactionImportError { @@ -253,6 +220,7 @@ error_chain! { links { Import(ImportError, ImportErrorKind) #[doc = "Error concerning block import." ]; + Queue(QueueError, QueueErrorKind) #[doc = "Io channel queue error"]; } foreign_links { @@ -265,6 +233,7 @@ error_chain! { Snappy(InvalidInput) #[doc = "Snappy error."]; Engine(EngineError) #[doc = "Consensus vote error."]; Ethkey(EthkeyError) #[doc = "Ethkey error."]; + Decoder(rlp::DecoderError) #[doc = "RLP decoding errors"]; } errors { @@ -297,40 +266,15 @@ error_chain! { description("Unknown engine name") display("Unknown engine name ({})", name) } - - #[doc = "RLP decoding errors"] - Decoder(err: ::rlp::DecoderError) { - description("decoding value failed") - display("decoding value failed with error: {}", err) - } } } -/// Result of import block operation. -pub type ImportResult = EthcoreResult; - impl From for Error { fn from(err: AccountsError) -> Error { ErrorKind::AccountProvider(err).into() } } -impl From<::rlp::DecoderError> for Error { - fn from(err: ::rlp::DecoderError) -> Error { - ErrorKind::Decoder(err).into() - } -} - -impl From for Error { - fn from(err: BlockImportError) -> Error { - match err { - BlockImportError(BlockImportErrorKind::Block(e), _) => ErrorKind::Block(e).into(), - BlockImportError(BlockImportErrorKind::Import(e), _) => ErrorKind::Import(e).into(), - _ => ErrorKind::Msg(format!("other block import error: {:?}", err)).into(), - } - } -} - impl From for Error { fn from(err: SnapshotError) -> Error { match err { diff --git a/ethcore/src/verification/queue/mod.rs b/ethcore/src/verification/queue/mod.rs index 41b82d0f6..8c65d2ea7 100644 --- a/ethcore/src/verification/queue/mod.rs +++ b/ethcore/src/verification/queue/mod.rs @@ -464,7 +464,7 @@ impl VerificationQueue { } /// Add a block to the queue. - pub fn import(&self, input: K::Input) -> ImportResult { + pub fn import(&self, input: K::Input) -> EthcoreResult { let h = input.hash(); { if self.processing.read().contains_key(&h) { diff --git a/ethcore/sync/src/block_sync.rs b/ethcore/sync/src/block_sync.rs index 55b23cba4..727e5e23e 100644 --- a/ethcore/sync/src/block_sync.rs +++ b/ethcore/sync/src/block_sync.rs @@ -24,8 +24,8 @@ use heapsize::HeapSizeOf; use ethereum_types::H256; use rlp::{self, Rlp}; use ethcore::header::BlockNumber; -use ethcore::client::{BlockStatus, BlockId, BlockImportError, BlockImportErrorKind}; -use ethcore::error::{ImportErrorKind, QueueErrorKind, BlockError}; +use ethcore::client::{BlockStatus, BlockId}; +use ethcore::error::{ImportErrorKind, QueueErrorKind, BlockError, Error as EthcoreError, ErrorKind as EthcoreErrorKind}; use sync_io::SyncIo; use blocks::{BlockCollection, SyncBody, SyncHeader}; @@ -489,11 +489,11 @@ impl BlockDownloader { }; match result { - Err(BlockImportError(BlockImportErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => { + Err(EthcoreError(EthcoreErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => { trace!(target: "sync", "Block already in chain {:?}", h); self.block_imported(&h, number, &parent); }, - Err(BlockImportError(BlockImportErrorKind::Import(ImportErrorKind::AlreadyQueued), _)) => { + Err(EthcoreError(EthcoreErrorKind::Import(ImportErrorKind::AlreadyQueued), _)) => { trace!(target: "sync", "Block already queued {:?}", h); self.block_imported(&h, number, &parent); }, @@ -502,18 +502,18 @@ impl BlockDownloader { imported.insert(h.clone()); self.block_imported(&h, number, &parent); }, - Err(BlockImportError(BlockImportErrorKind::Block(BlockError::UnknownParent(_)), _)) if allow_out_of_order => { + Err(EthcoreError(EthcoreErrorKind::Block(BlockError::UnknownParent(_)), _)) if allow_out_of_order => { break; }, - Err(BlockImportError(BlockImportErrorKind::Block(BlockError::UnknownParent(_)), _)) => { + Err(EthcoreError(EthcoreErrorKind::Block(BlockError::UnknownParent(_)), _)) => { trace!(target: "sync", "Unknown new block parent, restarting sync"); break; }, - Err(BlockImportError(BlockImportErrorKind::Block(BlockError::TemporarilyInvalid(_)), _)) => { + Err(EthcoreError(EthcoreErrorKind::Block(BlockError::TemporarilyInvalid(_)), _)) => { debug!(target: "sync", "Block temporarily invalid, restarting sync"); break; }, - Err(BlockImportError(BlockImportErrorKind::Queue(QueueErrorKind::Full(limit)), _)) => { + Err(EthcoreError(EthcoreErrorKind::Queue(QueueErrorKind::Full(limit)), _)) => { debug!(target: "sync", "Block import queue full ({}), restarting sync", limit); break; }, diff --git a/ethcore/sync/src/chain/handler.rs b/ethcore/sync/src/chain/handler.rs index 15f234fbb..be95a3c28 100644 --- a/ethcore/sync/src/chain/handler.rs +++ b/ethcore/sync/src/chain/handler.rs @@ -17,8 +17,8 @@ use api::WARP_SYNC_PROTOCOL_ID; use block_sync::{BlockDownloaderImportError as DownloaderImportError, DownloadAction}; use bytes::Bytes; -use ethcore::client::{BlockStatus, BlockId, BlockImportError, BlockImportErrorKind}; -use ethcore::error::*; +use ethcore::client::{BlockId, BlockStatus}; +use ethcore::error::{Error as EthcoreError, ErrorKind as EthcoreErrorKind, ImportErrorKind, BlockError}; use ethcore::header::BlockNumber; use ethcore::snapshot::{ManifestData, RestorationStatus}; use ethcore::verification::queue::kind::blocks::Unverified; @@ -182,10 +182,10 @@ impl SyncHandler { return Err(DownloaderImportError::Invalid); } match io.chain().import_block(block) { - Err(BlockImportError(BlockImportErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => { + Err(EthcoreError(EthcoreErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => { trace!(target: "sync", "New block already in chain {:?}", hash); }, - Err(BlockImportError(BlockImportErrorKind::Import(ImportErrorKind::AlreadyQueued), _)) => { + Err(EthcoreError(EthcoreErrorKind::Import(ImportErrorKind::AlreadyQueued), _)) => { trace!(target: "sync", "New block already queued {:?}", hash); }, Ok(_) => { @@ -194,7 +194,7 @@ impl SyncHandler { sync.new_blocks.mark_as_known(&hash, number); trace!(target: "sync", "New block queued {:?} ({})", hash, number); }, - Err(BlockImportError(BlockImportErrorKind::Block(BlockError::UnknownParent(p)), _)) => { + Err(EthcoreError(EthcoreErrorKind::Block(BlockError::UnknownParent(p)), _)) => { unknown = true; trace!(target: "sync", "New block with unknown parent ({:?}) {:?}", p, hash); }, diff --git a/ethcore/sync/src/light_sync/mod.rs b/ethcore/sync/src/light_sync/mod.rs index 4b67c3a47..b4000c082 100644 --- a/ethcore/sync/src/light_sync/mod.rs +++ b/ethcore/sync/src/light_sync/mod.rs @@ -427,7 +427,7 @@ impl LightSync { // handles request dispatch, block import, state machine transitions, and timeouts. fn maintain_sync(&self, ctx: &BasicContext) { - use ethcore::error::{BlockImportError, BlockImportErrorKind, ImportErrorKind}; + use ethcore::error::{Error as EthcoreError, ErrorKind as EthcoreErrorKind, ImportErrorKind}; const DRAIN_AMOUNT: usize = 128; @@ -457,10 +457,10 @@ impl LightSync { for header in sink.drain(..) { match client.queue_header(header) { Ok(_) => {} - Err(BlockImportError(BlockImportErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => { + Err(EthcoreError(EthcoreErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => { trace!(target: "sync", "Block already in chain. Continuing."); }, - Err(BlockImportError(BlockImportErrorKind::Import(ImportErrorKind::AlreadyQueued), _)) => { + Err(EthcoreError(EthcoreErrorKind::Import(ImportErrorKind::AlreadyQueued), _)) => { trace!(target: "sync", "Block already queued. Continuing."); }, Err(e) => { diff --git a/parity/blockchain.rs b/parity/blockchain.rs index c7a70770b..9c1cf20dc 100644 --- a/parity/blockchain.rs +++ b/parity/blockchain.rs @@ -26,8 +26,8 @@ use ethereum_types::{U256, H256, Address}; use bytes::ToPretty; use rlp::PayloadInfo; use ethcore::account_provider::AccountProvider; -use ethcore::client::{Mode, DatabaseCompactionProfile, VMType, BlockImportError, Nonce, Balance, BlockChainClient, BlockId, BlockInfo, ImportBlock}; -use ethcore::error::{ImportErrorKind, BlockImportErrorKind}; +use ethcore::client::{Mode, DatabaseCompactionProfile, VMType, Nonce, Balance, BlockChainClient, BlockId, BlockInfo, ImportBlock}; +use ethcore::error::{ImportErrorKind, ErrorKind as EthcoreErrorKind, Error as EthcoreError}; use ethcore::miner::Miner; use ethcore::verification::queue::VerifierSettings; use ethcore::verification::queue::kind::blocks::Unverified; @@ -251,7 +251,7 @@ fn execute_import_light(cmd: ImportBlockchain) -> Result<(), String> { } match client.import_header(header) { - Err(BlockImportError(BlockImportErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => { + Err(EthcoreError(EthcoreErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => { trace!("Skipping block already in chain."); } Err(e) => { @@ -421,7 +421,7 @@ fn execute_import(cmd: ImportBlockchain) -> Result<(), String> { let block = Unverified::from_rlp(bytes).map_err(|_| "Invalid block rlp")?; while client.queue_info().is_full() { sleep(Duration::from_secs(1)); } match client.import_block(block) { - Err(BlockImportError(BlockImportErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => { + Err(EthcoreError(EthcoreErrorKind::Import(ImportErrorKind::AlreadyInChain), _)) => { trace!("Skipping block already in chain."); } Err(e) => {