Reformat the source code

ethcore/src/verification/canon_verifier.rs

@@ -16,33 +16,32 @@
 
 //! Canonical verifier.
 
+use super::{verification, Verifier};
 use call_contract::CallContract;
 use client::BlockInfo;
 use engines::EthEngine;
 use error::Error;
 use types::header::Header;
-use super::Verifier;
-use super::verification;
 
 /// A canonial verifier -- this does full verification.
 pub struct CanonVerifier;
 
 impl<C: BlockInfo + CallContract> Verifier<C> for CanonVerifier {
-	fn verify_block_family(
-		&self,
-		header: &Header,
-		parent: &Header,
-		engine: &EthEngine,
-		do_full: Option<verification::FullFamilyParams<C>>,
-	) -> Result<(), Error> {
-		verification::verify_block_family(header, parent, engine, do_full)
-	}
+    fn verify_block_family(
+        &self,
+        header: &Header,
+        parent: &Header,
+        engine: &EthEngine,
+        do_full: Option<verification::FullFamilyParams<C>>,
+    ) -> Result<(), Error> {
+        verification::verify_block_family(header, parent, engine, do_full)
+    }
 
-	fn verify_block_final(&self, expected: &Header, got: &Header) -> Result<(), Error> {
-		verification::verify_block_final(expected, got)
-	}
+    fn verify_block_final(&self, expected: &Header, got: &Header) -> Result<(), Error> {
+        verification::verify_block_final(expected, got)
+    }
 
-	fn verify_block_external(&self, header: &Header, engine: &EthEngine) -> Result<(), Error> {
-		engine.verify_block_external(header)
-	}
+    fn verify_block_external(&self, header: &Header, engine: &EthEngine) -> Result<(), Error> {
+        engine.verify_block_external(header)
+    }
 }

ethcore/src/verification/mod.rs

@@ -16,17 +16,19 @@
 
 //! Block verification utilities.
 
-mod verification;
-mod verifier;
-pub mod queue;
 mod canon_verifier;
 mod noop_verifier;
+pub mod queue;
+mod verification;
+mod verifier;
 
-pub use self::verification::*;
-pub use self::verifier::Verifier;
-pub use self::canon_verifier::CanonVerifier;
-pub use self::noop_verifier::NoopVerifier;
-pub use self::queue::{BlockQueue, Config as QueueConfig, VerificationQueue, QueueInfo};
+pub use self::{
+    canon_verifier::CanonVerifier,
+    noop_verifier::NoopVerifier,
+    queue::{BlockQueue, Config as QueueConfig, QueueInfo, VerificationQueue},
+    verification::*,
+    verifier::Verifier,
+};
 
 use call_contract::CallContract;
 use client::BlockInfo;
@@ -34,29 +36,29 @@ use client::BlockInfo;
 /// Verifier type.
 #[derive(Debug, PartialEq, Clone)]
 pub enum VerifierType {
-	/// Verifies block normally.
-	Canon,
-	/// Verifies block normallly, but skips seal verification.
-	CanonNoSeal,
-	/// Does not verify block at all.
-	/// Used in tests.
-	Noop,
+    /// Verifies block normally.
+    Canon,
+    /// Verifies block normallly, but skips seal verification.
+    CanonNoSeal,
+    /// Does not verify block at all.
+    /// Used in tests.
+    Noop,
 }
 
 /// Create a new verifier based on type.
 pub fn new<C: BlockInfo + CallContract>(v: VerifierType) -> Box<Verifier<C>> {
-	match v {
-		VerifierType::Canon | VerifierType::CanonNoSeal => Box::new(CanonVerifier),
-		VerifierType::Noop => Box::new(NoopVerifier),
-	}
+    match v {
+        VerifierType::Canon | VerifierType::CanonNoSeal => Box::new(CanonVerifier),
+        VerifierType::Noop => Box::new(NoopVerifier),
+    }
 }
 
 impl VerifierType {
-	/// Check if seal verification is enabled for this verifier type.
-	pub fn verifying_seal(&self) -> bool {
-		match *self {
-			VerifierType::Canon => true,
-			VerifierType::Noop | VerifierType::CanonNoSeal => false,
-		}
-	}
+    /// Check if seal verification is enabled for this verifier type.
+    pub fn verifying_seal(&self) -> bool {
+        match *self {
+            VerifierType::Canon => true,
+            VerifierType::Noop | VerifierType::CanonNoSeal => false,
+        }
+    }
 }

ethcore/src/verification/noop_verifier.rs

@@ -16,33 +16,33 @@
 
 //! No-op verifier.
 
+use super::{verification, Verifier};
 use call_contract::CallContract;
 use client::BlockInfo;
 use engines::EthEngine;
 use error::Error;
 use types::header::Header;
-use super::{verification, Verifier};
 
 /// A no-op verifier -- this will verify everything it's given immediately.
 #[allow(dead_code)]
 pub struct NoopVerifier;
 
 impl<C: BlockInfo + CallContract> Verifier<C> for NoopVerifier {
-	fn verify_block_family(
-		&self,
-		_: &Header,
-		_t: &Header,
-		_: &EthEngine,
-		_: Option<verification::FullFamilyParams<C>>
-	) -> Result<(), Error> {
-		Ok(())
-	}
+    fn verify_block_family(
+        &self,
+        _: &Header,
+        _t: &Header,
+        _: &EthEngine,
+        _: Option<verification::FullFamilyParams<C>>,
+    ) -> Result<(), Error> {
+        Ok(())
+    }
 
-	fn verify_block_final(&self, _expected: &Header, _got: &Header) -> Result<(), Error> {
-		Ok(())
-	}
+    fn verify_block_final(&self, _expected: &Header, _got: &Header) -> Result<(), Error> {
+        Ok(())
+    }
 
-	fn verify_block_external(&self, _header: &Header, _engine: &EthEngine) -> Result<(), Error> {
-		Ok(())
-	}
+    fn verify_block_external(&self, _header: &Header, _engine: &EthEngine) -> Result<(), Error> {
+        Ok(())
+    }
 }

ethcore/src/verification/queue/kind.rs

@@ -19,25 +19,24 @@
 use engines::EthEngine;
 use error::Error;
 
-use heapsize::HeapSizeOf;
 use ethereum_types::{H256, U256};
+use heapsize::HeapSizeOf;
 
-pub use self::blocks::Blocks;
-pub use self::headers::Headers;
+pub use self::{blocks::Blocks, headers::Headers};
 
 /// Something which can produce a hash and a parent hash.
 pub trait BlockLike {
-	/// Get the hash of this item - i.e. the header hash.
-	fn hash(&self) -> H256;
+    /// Get the hash of this item - i.e. the header hash.
+    fn hash(&self) -> H256;
 
-	/// Get a raw hash of this item - i.e. the hash of the RLP representation.
-	fn raw_hash(&self) -> H256;
+    /// Get a raw hash of this item - i.e. the hash of the RLP representation.
+    fn raw_hash(&self) -> H256;
 
-	/// Get the hash of this item's parent.
-	fn parent_hash(&self) -> H256;
+    /// Get the hash of this item's parent.
+    fn parent_hash(&self) -> H256;
 
-	/// Get the difficulty of this item.
-	fn difficulty(&self) -> U256;
+    /// Get the difficulty of this item.
+    fn difficulty(&self) -> U256;
 }
 
 /// Defines transitions between stages of verification.
@@ -51,188 +50,221 @@ pub trait BlockLike {
 /// For correctness, the hashes produced by each stage of the pipeline should be
 /// consistent.
 pub trait Kind: 'static + Sized + Send + Sync {
-	/// The first stage: completely unverified.
-	type Input: Sized + Send + BlockLike + HeapSizeOf;
+    /// The first stage: completely unverified.
+    type Input: Sized + Send + BlockLike + HeapSizeOf;
 
-	/// The second stage: partially verified.
-	type Unverified: Sized + Send + BlockLike + HeapSizeOf;
+    /// The second stage: partially verified.
+    type Unverified: Sized + Send + BlockLike + HeapSizeOf;
 
-	/// The third stage: completely verified.
-	type Verified: Sized + Send + BlockLike + HeapSizeOf;
+    /// The third stage: completely verified.
+    type Verified: Sized + Send + BlockLike + HeapSizeOf;
 
-	/// Attempt to create the `Unverified` item from the input.
-	fn create(input: Self::Input, engine: &EthEngine, check_seal: bool) -> Result<Self::Unverified, (Self::Input, Error)>;
+    /// Attempt to create the `Unverified` item from the input.
+    fn create(
+        input: Self::Input,
+        engine: &EthEngine,
+        check_seal: bool,
+    ) -> Result<Self::Unverified, (Self::Input, Error)>;
 
-	/// Attempt to verify the `Unverified` item using the given engine.
-	fn verify(unverified: Self::Unverified, engine: &EthEngine, check_seal: bool) -> Result<Self::Verified, Error>;
+    /// Attempt to verify the `Unverified` item using the given engine.
+    fn verify(
+        unverified: Self::Unverified,
+        engine: &EthEngine,
+        check_seal: bool,
+    ) -> Result<Self::Verified, Error>;
 }
 
 /// The blocks verification module.
 pub mod blocks {
-	use super::{Kind, BlockLike};
+    use super::{BlockLike, Kind};
 
-	use engines::EthEngine;
-	use error::{Error, ErrorKind, BlockError};
-	use types::header::Header;
-	use verification::{PreverifiedBlock, verify_block_basic, verify_block_unordered};
-	use types::transaction::UnverifiedTransaction;
+    use engines::EthEngine;
+    use error::{BlockError, Error, ErrorKind};
+    use types::{header::Header, transaction::UnverifiedTransaction};
+    use verification::{verify_block_basic, verify_block_unordered, PreverifiedBlock};
 
-	use heapsize::HeapSizeOf;
-	use ethereum_types::{H256, U256};
-	use bytes::Bytes;
+    use bytes::Bytes;
+    use ethereum_types::{H256, U256};
+    use heapsize::HeapSizeOf;
 
-	/// A mode for verifying blocks.
-	pub struct Blocks;
+    /// A mode for verifying blocks.
+    pub struct Blocks;
 
-	impl Kind for Blocks {
-		type Input = Unverified;
-		type Unverified = Unverified;
-		type Verified = PreverifiedBlock;
+    impl Kind for Blocks {
+        type Input = Unverified;
+        type Unverified = Unverified;
+        type Verified = PreverifiedBlock;
 
-		fn create(input: Self::Input, engine: &EthEngine, check_seal: bool) -> Result<Self::Unverified, (Self::Input, Error)> {
-			match verify_block_basic(&input, engine, check_seal) {
-				Ok(()) => Ok(input),
-				Err(Error(ErrorKind::Block(BlockError::TemporarilyInvalid(oob)), _)) => {
-					debug!(target: "client", "Block received too early {}: {:?}", input.hash(), oob);
-					Err((input, BlockError::TemporarilyInvalid(oob).into()))
-				},
-				Err(e) => {
-					warn!(target: "client", "Stage 1 block verification failed for {}: {:?}", input.hash(), e);
-					Err((input, e))
-				}
-			}
-		}
+        fn create(
+            input: Self::Input,
+            engine: &EthEngine,
+            check_seal: bool,
+        ) -> Result<Self::Unverified, (Self::Input, Error)> {
+            match verify_block_basic(&input, engine, check_seal) {
+                Ok(()) => Ok(input),
+                Err(Error(ErrorKind::Block(BlockError::TemporarilyInvalid(oob)), _)) => {
+                    debug!(target: "client", "Block received too early {}: {:?}", input.hash(), oob);
+                    Err((input, BlockError::TemporarilyInvalid(oob).into()))
+                }
+                Err(e) => {
+                    warn!(target: "client", "Stage 1 block verification failed for {}: {:?}", input.hash(), e);
+                    Err((input, e))
+                }
+            }
+        }
 
-		fn verify(un: Self::Unverified, engine: &EthEngine, check_seal: bool) -> Result<Self::Verified, Error> {
-			let hash = un.hash();
-			match verify_block_unordered(un, engine, check_seal) {
-				Ok(verified) => Ok(verified),
-				Err(e) => {
-					warn!(target: "client", "Stage 2 block verification failed for {}: {:?}", hash, e);
-					Err(e)
-				}
-			}
-		}
-	}
+        fn verify(
+            un: Self::Unverified,
+            engine: &EthEngine,
+            check_seal: bool,
+        ) -> Result<Self::Verified, Error> {
+            let hash = un.hash();
+            match verify_block_unordered(un, engine, check_seal) {
+                Ok(verified) => Ok(verified),
+                Err(e) => {
+                    warn!(target: "client", "Stage 2 block verification failed for {}: {:?}", hash, e);
+                    Err(e)
+                }
+            }
+        }
+    }
 
-	/// An unverified block.
-	#[derive(PartialEq, Debug)]
-	pub struct Unverified {
-		/// Unverified block header.
-		pub header: Header,
-		/// Unverified block transactions.
-		pub transactions: Vec<UnverifiedTransaction>,
-		/// Unverified block uncles.
-		pub uncles: Vec<Header>,
-		/// Raw block bytes.
-		pub bytes: Bytes,
-	}
+    /// An unverified block.
+    #[derive(PartialEq, Debug)]
+    pub struct Unverified {
+        /// Unverified block header.
+        pub header: Header,
+        /// Unverified block transactions.
+        pub transactions: Vec<UnverifiedTransaction>,
+        /// Unverified block uncles.
+        pub uncles: Vec<Header>,
+        /// Raw block bytes.
+        pub bytes: Bytes,
+    }
 
-	impl Unverified {
-		/// Create an `Unverified` from raw bytes.
-		pub fn from_rlp(bytes: Bytes) -> Result<Self, ::rlp::DecoderError> {
-			use rlp::Rlp;
-			let (header, transactions, uncles) = {
-				let rlp = Rlp::new(&bytes);
-				let header = rlp.val_at(0)?;
-				let transactions = rlp.list_at(1)?;
-				let uncles = rlp.list_at(2)?;
-				(header, transactions, uncles)
-			};
+    impl Unverified {
+        /// Create an `Unverified` from raw bytes.
+        pub fn from_rlp(bytes: Bytes) -> Result<Self, ::rlp::DecoderError> {
+            use rlp::Rlp;
+            let (header, transactions, uncles) = {
+                let rlp = Rlp::new(&bytes);
+                let header = rlp.val_at(0)?;
+                let transactions = rlp.list_at(1)?;
+                let uncles = rlp.list_at(2)?;
+                (header, transactions, uncles)
+            };
 
-			Ok(Unverified {
-				header,
-				transactions,
-				uncles,
-				bytes,
-			})
-		}
-	}
+            Ok(Unverified {
+                header,
+                transactions,
+                uncles,
+                bytes,
+            })
+        }
+    }
 
-	impl HeapSizeOf for Unverified {
-		fn heap_size_of_children(&self) -> usize {
-			self.header.heap_size_of_children()
-				+ self.transactions.heap_size_of_children()
-				+ self.uncles.heap_size_of_children()
-				+ self.bytes.heap_size_of_children()
-		}
-	}
+    impl HeapSizeOf for Unverified {
+        fn heap_size_of_children(&self) -> usize {
+            self.header.heap_size_of_children()
+                + self.transactions.heap_size_of_children()
+                + self.uncles.heap_size_of_children()
+                + self.bytes.heap_size_of_children()
+        }
+    }
 
-	impl BlockLike for Unverified {
-		fn hash(&self) -> H256 {
-			self.header.hash()
-		}
+    impl BlockLike for Unverified {
+        fn hash(&self) -> H256 {
+            self.header.hash()
+        }
 
-		fn raw_hash(&self) -> H256 {
-			hash::keccak(&self.bytes)
-		}
+        fn raw_hash(&self) -> H256 {
+            hash::keccak(&self.bytes)
+        }
 
-		fn parent_hash(&self) -> H256 {
-			self.header.parent_hash().clone()
-		}
+        fn parent_hash(&self) -> H256 {
+            self.header.parent_hash().clone()
+        }
 
-		fn difficulty(&self) -> U256 {
-			self.header.difficulty().clone()
-		}
-	}
+        fn difficulty(&self) -> U256 {
+            self.header.difficulty().clone()
+        }
+    }
 
-	impl BlockLike for PreverifiedBlock {
-		fn hash(&self) -> H256 {
-			self.header.hash()
-		}
+    impl BlockLike for PreverifiedBlock {
+        fn hash(&self) -> H256 {
+            self.header.hash()
+        }
 
-		fn raw_hash(&self) -> H256 {
-			hash::keccak(&self.bytes)
-		}
+        fn raw_hash(&self) -> H256 {
+            hash::keccak(&self.bytes)
+        }
 
-		fn parent_hash(&self) -> H256 {
-			self.header.parent_hash().clone()
-		}
+        fn parent_hash(&self) -> H256 {
+            self.header.parent_hash().clone()
+        }
 
-		fn difficulty(&self) -> U256 {
-			self.header.difficulty().clone()
-		}
-	}
+        fn difficulty(&self) -> U256 {
+            self.header.difficulty().clone()
+        }
+    }
 }
 
 /// Verification for headers.
 pub mod headers {
-	use super::{Kind, BlockLike};
+    use super::{BlockLike, Kind};
 
-	use engines::EthEngine;
-	use error::Error;
-	use types::header::Header;
-	use verification::verify_header_params;
+    use engines::EthEngine;
+    use error::Error;
+    use types::header::Header;
+    use verification::verify_header_params;
 
-	use ethereum_types::{H256, U256};
+    use ethereum_types::{H256, U256};
 
-	impl BlockLike for Header {
-		fn hash(&self) -> H256 { self.hash() }
-		fn raw_hash(&self) -> H256 { self.hash() }
-		fn parent_hash(&self) -> H256 { self.parent_hash().clone() }
-		fn difficulty(&self) -> U256 { self.difficulty().clone() }
-	}
+    impl BlockLike for Header {
+        fn hash(&self) -> H256 {
+            self.hash()
+        }
+        fn raw_hash(&self) -> H256 {
+            self.hash()
+        }
+        fn parent_hash(&self) -> H256 {
+            self.parent_hash().clone()
+        }
+        fn difficulty(&self) -> U256 {
+            self.difficulty().clone()
+        }
+    }
 
-	/// A mode for verifying headers.
-	pub struct Headers;
+    /// A mode for verifying headers.
+    pub struct Headers;
 
-	impl Kind for Headers {
-		type Input = Header;
-		type Unverified = Header;
-		type Verified = Header;
+    impl Kind for Headers {
+        type Input = Header;
+        type Unverified = Header;
+        type Verified = Header;
 
-		fn create(input: Self::Input, engine: &EthEngine, check_seal: bool) -> Result<Self::Unverified, (Self::Input, Error)> {
-			match verify_header_params(&input, engine, true, check_seal) {
-				Ok(_) => Ok(input),
-				Err(err) => Err((input, err))
-			}
-		}
+        fn create(
+            input: Self::Input,
+            engine: &EthEngine,
+            check_seal: bool,
+        ) -> Result<Self::Unverified, (Self::Input, Error)> {
+            match verify_header_params(&input, engine, true, check_seal) {
+                Ok(_) => Ok(input),
+                Err(err) => Err((input, err)),
+            }
+        }
 
-		fn verify(unverified: Self::Unverified, engine: &EthEngine, check_seal: bool) -> Result<Self::Verified, Error> {
-			match check_seal {
-				true => engine.verify_block_unordered(&unverified,).map(|_| unverified),
-				false => Ok(unverified),
-			}
-		}
-	}
+        fn verify(
+            unverified: Self::Unverified,
+            engine: &EthEngine,
+            check_seal: bool,
+        ) -> Result<Self::Verified, Error> {
+            match check_seal {
+                true => engine
+                    .verify_block_unordered(&unverified)
+                    .map(|_| unverified),
+                false => Ok(unverified),
+            }
+        }
+    }
 }

ethcore/src/verification/verifier.rs

@@ -16,28 +16,29 @@
 
 //! A generic verifier trait.
 
+use super::verification;
 use call_contract::CallContract;
 use client::BlockInfo;
 use engines::EthEngine;
 use error::Error;
 use types::header::Header;
-use super::verification;
 
 /// Should be used to verify blocks.
 pub trait Verifier<C>: Send + Sync
-	where C: BlockInfo + CallContract
+where
+    C: BlockInfo + CallContract,
 {
-	/// Verify a block relative to its parent and uncles.
-	fn verify_block_family(
-		&self,
-		header: &Header,
-		parent: &Header,
-		engine: &EthEngine,
-		do_full: Option<verification::FullFamilyParams<C>>
-	) -> Result<(), Error>;
+    /// Verify a block relative to its parent and uncles.
+    fn verify_block_family(
+        &self,
+        header: &Header,
+        parent: &Header,
+        engine: &EthEngine,
+        do_full: Option<verification::FullFamilyParams<C>>,
+    ) -> Result<(), Error>;
 
-	/// Do a final verification check for an enacted header vs its expected counterpart.
-	fn verify_block_final(&self, expected: &Header, got: &Header) -> Result<(), Error>;
-	/// Verify a block, inspecing external state.
-	fn verify_block_external(&self, header: &Header, engine: &EthEngine) -> Result<(), Error>;
+    /// Do a final verification check for an enacted header vs its expected counterpart.
+    fn verify_block_final(&self, expected: &Header, got: &Header) -> Result<(), Error>;
+    /// Verify a block, inspecing external state.
+    fn verify_block_external(&self, header: &Header, engine: &EthEngine) -> Result<(), Error>;
 }