grassrootseconomics/openethereum
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Reformat the source code

Browse Source
This commit is contained in:
Artem Vorotnikov
2020-08-05 07:08:03 +03:00
parent 253ff3f37b
commit 610d9baba4
742 changed files with 175791 additions and 141379 deletions
Download Patch File Download Diff File Expand all files Collapse all files

348
ethcore/src/verification/queue/kind.rs
View File

@@ -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),
}
}
}
}