1032 lines
36 KiB
Rust
1032 lines
36 KiB
Rust
// Copyright 2015-2019 Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity Ethereum.
|
|
|
|
// Parity Ethereum is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// Parity Ethereum is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Parity Ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
use std::{cmp, collections::BTreeMap, path::Path, sync::Arc};
|
|
|
|
use ethereum_types::{H256, H64, U256};
|
|
use ethjson;
|
|
use hash::KECCAK_EMPTY_LIST_RLP;
|
|
use rlp::Rlp;
|
|
use types::{
|
|
header::{ExtendedHeader, Header},
|
|
BlockNumber,
|
|
};
|
|
use unexpected::{Mismatch, OutOfBounds};
|
|
|
|
use block::ExecutedBlock;
|
|
use engines::{
|
|
self,
|
|
block_reward::{self, BlockRewardContract, RewardKind},
|
|
Engine,
|
|
};
|
|
use error::{BlockError, Error};
|
|
use ethash::{self, quick_get_difficulty, slow_hash_block_number, EthashManager, OptimizeFor};
|
|
use machine::EthereumMachine;
|
|
|
|
/// Number of blocks in an ethash snapshot.
|
|
// make dependent on difficulty incrment divisor?
|
|
const SNAPSHOT_BLOCKS: u64 = 5000;
|
|
/// Maximum number of blocks allowed in an ethash snapshot.
|
|
const MAX_SNAPSHOT_BLOCKS: u64 = 30000;
|
|
|
|
/// Ethash specific seal
|
|
#[derive(Debug, PartialEq)]
|
|
pub struct Seal {
|
|
/// Ethash seal mix_hash
|
|
pub mix_hash: H256,
|
|
/// Ethash seal nonce
|
|
pub nonce: H64,
|
|
}
|
|
|
|
impl Seal {
|
|
/// Tries to parse rlp as ethash seal.
|
|
pub fn parse_seal<T: AsRef<[u8]>>(seal: &[T]) -> Result<Self, Error> {
|
|
if seal.len() != 2 {
|
|
return Err(BlockError::InvalidSealArity(Mismatch {
|
|
expected: 2,
|
|
found: seal.len(),
|
|
})
|
|
.into());
|
|
}
|
|
|
|
let mix_hash = Rlp::new(seal[0].as_ref()).as_val::<H256>()?;
|
|
let nonce = Rlp::new(seal[1].as_ref()).as_val::<H64>()?;
|
|
let seal = Seal { mix_hash, nonce };
|
|
|
|
Ok(seal)
|
|
}
|
|
}
|
|
|
|
/// Ethash params.
|
|
#[derive(Debug, PartialEq)]
|
|
pub struct EthashParams {
|
|
/// Minimum difficulty.
|
|
pub minimum_difficulty: U256,
|
|
/// Difficulty bound divisor.
|
|
pub difficulty_bound_divisor: U256,
|
|
/// Difficulty increment divisor.
|
|
pub difficulty_increment_divisor: u64,
|
|
/// Metropolis difficulty increment divisor.
|
|
pub metropolis_difficulty_increment_divisor: u64,
|
|
/// Block duration.
|
|
pub duration_limit: u64,
|
|
/// Homestead transition block number.
|
|
pub homestead_transition: u64,
|
|
/// Transition block for a change of difficulty params (currently just bound_divisor).
|
|
pub difficulty_hardfork_transition: u64,
|
|
/// Difficulty param after the difficulty transition.
|
|
pub difficulty_hardfork_bound_divisor: U256,
|
|
/// Block on which there is no additional difficulty from the exponential bomb.
|
|
pub bomb_defuse_transition: u64,
|
|
/// Number of first block where EIP-100 rules begin.
|
|
pub eip100b_transition: u64,
|
|
/// Total block number for one ECIP-1017 era.
|
|
pub ecip1017_era_rounds: u64,
|
|
/// Block reward in base units.
|
|
pub block_reward: BTreeMap<BlockNumber, U256>,
|
|
/// EXPIP-2 block height
|
|
pub expip2_transition: u64,
|
|
/// EXPIP-2 duration limit
|
|
pub expip2_duration_limit: u64,
|
|
/// Block reward contract transition block.
|
|
pub block_reward_contract_transition: u64,
|
|
/// Block reward contract.
|
|
pub block_reward_contract: Option<BlockRewardContract>,
|
|
/// Difficulty bomb delays.
|
|
pub difficulty_bomb_delays: BTreeMap<BlockNumber, BlockNumber>,
|
|
/// Block to transition to progpow
|
|
pub progpow_transition: u64,
|
|
}
|
|
|
|
impl From<ethjson::spec::EthashParams> for EthashParams {
|
|
fn from(p: ethjson::spec::EthashParams) -> Self {
|
|
EthashParams {
|
|
minimum_difficulty: p.minimum_difficulty.into(),
|
|
difficulty_bound_divisor: p.difficulty_bound_divisor.into(),
|
|
difficulty_increment_divisor: p.difficulty_increment_divisor.map_or(10, Into::into),
|
|
metropolis_difficulty_increment_divisor: p
|
|
.metropolis_difficulty_increment_divisor
|
|
.map_or(9, Into::into),
|
|
duration_limit: p.duration_limit.map_or(0, Into::into),
|
|
homestead_transition: p.homestead_transition.map_or(0, Into::into),
|
|
difficulty_hardfork_transition: p
|
|
.difficulty_hardfork_transition
|
|
.map_or(u64::max_value(), Into::into),
|
|
difficulty_hardfork_bound_divisor: p
|
|
.difficulty_hardfork_bound_divisor
|
|
.map_or(p.difficulty_bound_divisor.into(), Into::into),
|
|
bomb_defuse_transition: p
|
|
.bomb_defuse_transition
|
|
.map_or(u64::max_value(), Into::into),
|
|
eip100b_transition: p.eip100b_transition.map_or(u64::max_value(), Into::into),
|
|
ecip1017_era_rounds: p.ecip1017_era_rounds.map_or(u64::max_value(), Into::into),
|
|
block_reward: p.block_reward.map_or_else(
|
|
|| {
|
|
let mut ret = BTreeMap::new();
|
|
ret.insert(0, U256::zero());
|
|
ret
|
|
},
|
|
|reward| match reward {
|
|
ethjson::spec::BlockReward::Single(reward) => {
|
|
let mut ret = BTreeMap::new();
|
|
ret.insert(0, reward.into());
|
|
ret
|
|
}
|
|
ethjson::spec::BlockReward::Multi(multi) => multi
|
|
.into_iter()
|
|
.map(|(block, reward)| (block.into(), reward.into()))
|
|
.collect(),
|
|
},
|
|
),
|
|
expip2_transition: p.expip2_transition.map_or(u64::max_value(), Into::into),
|
|
expip2_duration_limit: p.expip2_duration_limit.map_or(30, Into::into),
|
|
progpow_transition: p.progpow_transition.map_or(u64::max_value(), Into::into),
|
|
block_reward_contract_transition: p
|
|
.block_reward_contract_transition
|
|
.map_or(0, Into::into),
|
|
block_reward_contract: match (
|
|
p.block_reward_contract_code,
|
|
p.block_reward_contract_address,
|
|
) {
|
|
(Some(code), _) => Some(BlockRewardContract::new_from_code(Arc::new(code.into()))),
|
|
(_, Some(address)) => Some(BlockRewardContract::new_from_address(address.into())),
|
|
(None, None) => None,
|
|
},
|
|
difficulty_bomb_delays: p
|
|
.difficulty_bomb_delays
|
|
.unwrap_or_default()
|
|
.into_iter()
|
|
.map(|(block, delay)| (block.into(), delay.into()))
|
|
.collect(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Engine using Ethash proof-of-work consensus algorithm, suitable for Ethereum
|
|
/// mainnet chains in the Olympic, Frontier and Homestead eras.
|
|
pub struct Ethash {
|
|
ethash_params: EthashParams,
|
|
pow: EthashManager,
|
|
machine: EthereumMachine,
|
|
}
|
|
|
|
impl Ethash {
|
|
/// Create a new instance of Ethash engine
|
|
pub fn new<T: Into<Option<OptimizeFor>>>(
|
|
cache_dir: &Path,
|
|
ethash_params: EthashParams,
|
|
machine: EthereumMachine,
|
|
optimize_for: T,
|
|
) -> Arc<Self> {
|
|
let progpow_transition = ethash_params.progpow_transition;
|
|
|
|
Arc::new(Ethash {
|
|
ethash_params,
|
|
machine,
|
|
pow: EthashManager::new(cache_dir.as_ref(), optimize_for.into(), progpow_transition),
|
|
})
|
|
}
|
|
}
|
|
|
|
// TODO [rphmeier]
|
|
//
|
|
// for now, this is different than Ethash's own epochs, and signal
|
|
// "consensus epochs".
|
|
// in this sense, `Ethash` is epochless: the same `EpochVerifier` can be used
|
|
// for any block in the chain.
|
|
// in the future, we might move the Ethash epoch
|
|
// caching onto this mechanism as well.
|
|
impl engines::EpochVerifier<EthereumMachine> for Arc<Ethash> {
|
|
fn verify_light(&self, _header: &Header) -> Result<(), Error> {
|
|
Ok(())
|
|
}
|
|
fn verify_heavy(&self, header: &Header) -> Result<(), Error> {
|
|
self.verify_block_unordered(header)
|
|
}
|
|
}
|
|
|
|
impl Engine<EthereumMachine> for Arc<Ethash> {
|
|
fn name(&self) -> &str {
|
|
"Ethash"
|
|
}
|
|
fn machine(&self) -> &EthereumMachine {
|
|
&self.machine
|
|
}
|
|
|
|
// Two fields - nonce and mix.
|
|
fn seal_fields(&self, _header: &Header) -> usize {
|
|
2
|
|
}
|
|
|
|
/// Additional engine-specific information for the user/developer concerning `header`.
|
|
fn extra_info(&self, header: &Header) -> BTreeMap<String, String> {
|
|
match Seal::parse_seal(header.seal()) {
|
|
Ok(seal) => map![
|
|
"nonce".to_owned() => format!("0x{:x}", seal.nonce),
|
|
"mixHash".to_owned() => format!("0x{:x}", seal.mix_hash)
|
|
],
|
|
_ => BTreeMap::default(),
|
|
}
|
|
}
|
|
|
|
fn maximum_uncle_count(&self, _block: BlockNumber) -> usize {
|
|
2
|
|
}
|
|
|
|
fn maximum_gas_limit(&self) -> Option<U256> {
|
|
Some(0x7fff_ffff_ffff_ffffu64.into())
|
|
}
|
|
|
|
fn populate_from_parent(&self, header: &mut Header, parent: &Header) {
|
|
let difficulty = self.calculate_difficulty(header, parent);
|
|
header.set_difficulty(difficulty);
|
|
}
|
|
|
|
/// Apply the block reward on finalisation of the block.
|
|
/// This assumes that all uncles are valid uncles (i.e. of at least one generation before the current).
|
|
fn on_close_block(&self, block: &mut ExecutedBlock) -> Result<(), Error> {
|
|
use std::ops::Shr;
|
|
|
|
let author = *block.header.author();
|
|
let number = block.header.number();
|
|
|
|
let rewards = match self.ethash_params.block_reward_contract {
|
|
Some(ref c) if number >= self.ethash_params.block_reward_contract_transition => {
|
|
let mut beneficiaries = Vec::new();
|
|
|
|
beneficiaries.push((author, RewardKind::Author));
|
|
for u in &block.uncles {
|
|
let uncle_author = u.author();
|
|
beneficiaries.push((*uncle_author, RewardKind::uncle(number, u.number())));
|
|
}
|
|
|
|
let mut call = engines::default_system_or_code_call(&self.machine, block);
|
|
|
|
let rewards = c.reward(&beneficiaries, &mut call)?;
|
|
rewards
|
|
.into_iter()
|
|
.map(|(author, amount)| (author, RewardKind::External, amount))
|
|
.collect()
|
|
}
|
|
_ => {
|
|
let mut rewards = Vec::new();
|
|
|
|
let (_, reward) = self.ethash_params.block_reward.iter()
|
|
.rev()
|
|
.find(|&(block, _)| *block <= number)
|
|
.expect("Current block's reward is not found; this indicates a chain config error; qed");
|
|
let reward = *reward;
|
|
|
|
// Applies ECIP-1017 eras.
|
|
let eras_rounds = self.ethash_params.ecip1017_era_rounds;
|
|
let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, reward, number);
|
|
|
|
//let n_uncles = LiveBlock::uncles(&*block).len();
|
|
let n_uncles = block.uncles.len();
|
|
|
|
// Bestow block rewards.
|
|
let result_block_reward = reward + reward.shr(5) * U256::from(n_uncles);
|
|
|
|
rewards.push((author, RewardKind::Author, result_block_reward));
|
|
|
|
// Bestow uncle rewards.
|
|
for u in &block.uncles {
|
|
let uncle_author = u.author();
|
|
let result_uncle_reward = if eras == 0 {
|
|
(reward * U256::from(8 + u.number() - number)).shr(3)
|
|
} else {
|
|
reward.shr(5)
|
|
};
|
|
|
|
rewards.push((
|
|
*uncle_author,
|
|
RewardKind::uncle(number, u.number()),
|
|
result_uncle_reward,
|
|
));
|
|
}
|
|
|
|
rewards
|
|
}
|
|
};
|
|
|
|
block_reward::apply_block_rewards(&rewards, block, &self.machine)
|
|
}
|
|
|
|
#[cfg(not(feature = "miner-debug"))]
|
|
fn verify_local_seal(&self, header: &Header) -> Result<(), Error> {
|
|
self.verify_block_basic(header)
|
|
.and_then(|_| self.verify_block_unordered(header))
|
|
}
|
|
|
|
#[cfg(feature = "miner-debug")]
|
|
fn verify_local_seal(&self, _header: &Header) -> Result<(), Error> {
|
|
warn!("Skipping seal verification, running in miner testing mode.");
|
|
Ok(())
|
|
}
|
|
|
|
fn verify_block_basic(&self, header: &Header) -> Result<(), Error> {
|
|
// check the seal fields.
|
|
let seal = Seal::parse_seal(header.seal())?;
|
|
|
|
// TODO: consider removing these lines.
|
|
let min_difficulty = self.ethash_params.minimum_difficulty;
|
|
if header.difficulty() < &min_difficulty {
|
|
return Err(From::from(BlockError::DifficultyOutOfBounds(OutOfBounds {
|
|
min: Some(min_difficulty),
|
|
max: None,
|
|
found: header.difficulty().clone(),
|
|
})));
|
|
}
|
|
|
|
let difficulty = ethash::boundary_to_difficulty(&H256(quick_get_difficulty(
|
|
&header.bare_hash().0,
|
|
seal.nonce.low_u64(),
|
|
&seal.mix_hash.0,
|
|
header.number() >= self.ethash_params.progpow_transition,
|
|
)));
|
|
|
|
if &difficulty < header.difficulty() {
|
|
return Err(From::from(BlockError::InvalidProofOfWork(OutOfBounds {
|
|
min: Some(header.difficulty().clone()),
|
|
max: None,
|
|
found: difficulty,
|
|
})));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn verify_block_unordered(&self, header: &Header) -> Result<(), Error> {
|
|
let seal = Seal::parse_seal(header.seal())?;
|
|
|
|
let result = self.pow.compute_light(
|
|
header.number() as u64,
|
|
&header.bare_hash().0,
|
|
seal.nonce.low_u64(),
|
|
);
|
|
let mix = H256(result.mix_hash);
|
|
let difficulty = ethash::boundary_to_difficulty(&H256(result.value));
|
|
trace!(target: "miner", "num: {num}, seed: {seed}, h: {h}, non: {non}, mix: {mix}, res: {res}",
|
|
num = header.number() as u64,
|
|
seed = H256(slow_hash_block_number(header.number() as u64)),
|
|
h = header.bare_hash(),
|
|
non = seal.nonce.low_u64(),
|
|
mix = H256(result.mix_hash),
|
|
res = H256(result.value));
|
|
if mix != seal.mix_hash {
|
|
return Err(From::from(BlockError::MismatchedH256SealElement(
|
|
Mismatch {
|
|
expected: mix,
|
|
found: seal.mix_hash,
|
|
},
|
|
)));
|
|
}
|
|
if &difficulty < header.difficulty() {
|
|
return Err(From::from(BlockError::InvalidProofOfWork(OutOfBounds {
|
|
min: Some(header.difficulty().clone()),
|
|
max: None,
|
|
found: difficulty,
|
|
})));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn verify_block_family(&self, header: &Header, parent: &Header) -> Result<(), Error> {
|
|
// we should not calculate difficulty for genesis blocks
|
|
if header.number() == 0 {
|
|
return Err(From::from(BlockError::RidiculousNumber(OutOfBounds {
|
|
min: Some(1),
|
|
max: None,
|
|
found: header.number(),
|
|
})));
|
|
}
|
|
|
|
// Check difficulty is correct given the two timestamps.
|
|
let expected_difficulty = self.calculate_difficulty(header, parent);
|
|
if header.difficulty() != &expected_difficulty {
|
|
return Err(From::from(BlockError::InvalidDifficulty(Mismatch {
|
|
expected: expected_difficulty,
|
|
found: header.difficulty().clone(),
|
|
})));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn epoch_verifier<'a>(
|
|
&self,
|
|
_header: &Header,
|
|
_proof: &'a [u8],
|
|
) -> engines::ConstructedVerifier<'a, EthereumMachine> {
|
|
engines::ConstructedVerifier::Trusted(Box::new(self.clone()))
|
|
}
|
|
|
|
fn snapshot_components(&self) -> Option<Box<dyn crate::snapshot::SnapshotComponents>> {
|
|
Some(Box::new(::snapshot::PowSnapshot::new(
|
|
SNAPSHOT_BLOCKS,
|
|
MAX_SNAPSHOT_BLOCKS,
|
|
)))
|
|
}
|
|
|
|
fn fork_choice(&self, new: &ExtendedHeader, current: &ExtendedHeader) -> engines::ForkChoice {
|
|
engines::total_difficulty_fork_choice(new, current)
|
|
}
|
|
}
|
|
|
|
impl Ethash {
|
|
fn calculate_difficulty(&self, header: &Header, parent: &Header) -> U256 {
|
|
const EXP_DIFF_PERIOD: u64 = 100_000;
|
|
if header.number() == 0 {
|
|
panic!("Can't calculate genesis block difficulty");
|
|
}
|
|
|
|
let parent_has_uncles = parent.uncles_hash() != &KECCAK_EMPTY_LIST_RLP;
|
|
|
|
let min_difficulty = self.ethash_params.minimum_difficulty;
|
|
|
|
let difficulty_hardfork =
|
|
header.number() >= self.ethash_params.difficulty_hardfork_transition;
|
|
let difficulty_bound_divisor = if difficulty_hardfork {
|
|
self.ethash_params.difficulty_hardfork_bound_divisor
|
|
} else {
|
|
self.ethash_params.difficulty_bound_divisor
|
|
};
|
|
|
|
let expip2_hardfork = header.number() >= self.ethash_params.expip2_transition;
|
|
let duration_limit = if expip2_hardfork {
|
|
self.ethash_params.expip2_duration_limit
|
|
} else {
|
|
self.ethash_params.duration_limit
|
|
};
|
|
|
|
let frontier_limit = self.ethash_params.homestead_transition;
|
|
|
|
let mut target = if header.number() < frontier_limit {
|
|
if header.timestamp() >= parent.timestamp() + duration_limit {
|
|
*parent.difficulty() - (*parent.difficulty() / difficulty_bound_divisor)
|
|
} else {
|
|
*parent.difficulty() + (*parent.difficulty() / difficulty_bound_divisor)
|
|
}
|
|
} else {
|
|
trace!(target: "ethash", "Calculating difficulty parent.difficulty={}, header.timestamp={}, parent.timestamp={}", parent.difficulty(), header.timestamp(), parent.timestamp());
|
|
//block_diff = parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99)
|
|
let (increment_divisor, threshold) =
|
|
if header.number() < self.ethash_params.eip100b_transition {
|
|
(self.ethash_params.difficulty_increment_divisor, 1)
|
|
} else if parent_has_uncles {
|
|
(
|
|
self.ethash_params.metropolis_difficulty_increment_divisor,
|
|
2,
|
|
)
|
|
} else {
|
|
(
|
|
self.ethash_params.metropolis_difficulty_increment_divisor,
|
|
1,
|
|
)
|
|
};
|
|
|
|
let diff_inc = (header.timestamp() - parent.timestamp()) / increment_divisor;
|
|
if diff_inc <= threshold {
|
|
*parent.difficulty()
|
|
+ *parent.difficulty() / difficulty_bound_divisor
|
|
* U256::from(threshold - diff_inc)
|
|
} else {
|
|
let multiplier: U256 = cmp::min(diff_inc - threshold, 99).into();
|
|
parent
|
|
.difficulty()
|
|
.saturating_sub(*parent.difficulty() / difficulty_bound_divisor * multiplier)
|
|
}
|
|
};
|
|
target = cmp::max(min_difficulty, target);
|
|
if header.number() < self.ethash_params.bomb_defuse_transition {
|
|
let mut number = header.number();
|
|
let original_number = number;
|
|
for (block, delay) in &self.ethash_params.difficulty_bomb_delays {
|
|
if original_number >= *block {
|
|
number = number.saturating_sub(*delay);
|
|
}
|
|
}
|
|
let period = (number / EXP_DIFF_PERIOD) as usize;
|
|
if period > 1 {
|
|
target = cmp::max(min_difficulty, target + (U256::from(1) << (period - 2)));
|
|
}
|
|
}
|
|
target
|
|
}
|
|
}
|
|
|
|
fn ecip1017_eras_block_reward(era_rounds: u64, mut reward: U256, block_number: u64) -> (u64, U256) {
|
|
let eras = if block_number != 0 && block_number % era_rounds == 0 {
|
|
block_number / era_rounds - 1
|
|
} else {
|
|
block_number / era_rounds
|
|
};
|
|
let mut divi = U256::from(1);
|
|
for _ in 0..eras {
|
|
reward = reward * U256::from(4);
|
|
divi = divi * U256::from(5);
|
|
}
|
|
reward = reward / divi;
|
|
(eras, reward)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::{
|
|
super::{new_homestead_test_machine, new_mcip3_test, new_morden},
|
|
ecip1017_eras_block_reward, Ethash, EthashParams,
|
|
};
|
|
use block::*;
|
|
use engines::Engine;
|
|
use error::{BlockError, Error, ErrorKind};
|
|
use ethereum_types::{Address, H256, H64, U256};
|
|
use rlp;
|
|
use spec::Spec;
|
|
use std::{collections::BTreeMap, str::FromStr, sync::Arc};
|
|
use tempdir::TempDir;
|
|
use test_helpers::get_temp_state_db;
|
|
use types::header::Header;
|
|
|
|
fn test_spec() -> Spec {
|
|
let tempdir = TempDir::new("").unwrap();
|
|
new_morden(&tempdir.path())
|
|
}
|
|
|
|
fn get_default_ethash_params() -> EthashParams {
|
|
EthashParams {
|
|
minimum_difficulty: U256::from(131072),
|
|
difficulty_bound_divisor: U256::from(2048),
|
|
difficulty_increment_divisor: 10,
|
|
metropolis_difficulty_increment_divisor: 9,
|
|
homestead_transition: 1150000,
|
|
duration_limit: 13,
|
|
block_reward: {
|
|
let mut ret = BTreeMap::new();
|
|
ret.insert(0, 0.into());
|
|
ret
|
|
},
|
|
difficulty_hardfork_transition: u64::max_value(),
|
|
difficulty_hardfork_bound_divisor: U256::from(0),
|
|
bomb_defuse_transition: u64::max_value(),
|
|
eip100b_transition: u64::max_value(),
|
|
ecip1017_era_rounds: u64::max_value(),
|
|
expip2_transition: u64::max_value(),
|
|
expip2_duration_limit: 30,
|
|
block_reward_contract: None,
|
|
block_reward_contract_transition: 0,
|
|
difficulty_bomb_delays: BTreeMap::new(),
|
|
progpow_transition: u64::max_value(),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn on_close_block() {
|
|
let spec = test_spec();
|
|
let engine = &*spec.engine;
|
|
let genesis_header = spec.genesis_header();
|
|
let db = spec
|
|
.ensure_db_good(get_temp_state_db(), &Default::default())
|
|
.unwrap();
|
|
let last_hashes = Arc::new(vec![genesis_header.hash()]);
|
|
let b = OpenBlock::new(
|
|
engine,
|
|
Default::default(),
|
|
false,
|
|
db,
|
|
&genesis_header,
|
|
last_hashes,
|
|
Address::zero(),
|
|
(3141562.into(), 31415620.into()),
|
|
vec![],
|
|
false,
|
|
None,
|
|
)
|
|
.unwrap();
|
|
let b = b.close().unwrap();
|
|
assert_eq!(
|
|
b.state.balance(&Address::zero()).unwrap(),
|
|
U256::from_str("4563918244f40000").unwrap()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn has_valid_ecip1017_eras_block_reward() {
|
|
let eras_rounds = 5000000;
|
|
|
|
let start_reward: U256 = "4563918244F40000".parse().unwrap();
|
|
|
|
let block_number = 0;
|
|
let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
|
|
assert_eq!(0, eras);
|
|
assert_eq!(U256::from_str("4563918244F40000").unwrap(), reward);
|
|
|
|
let block_number = 5000000;
|
|
let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
|
|
assert_eq!(0, eras);
|
|
assert_eq!(U256::from_str("4563918244F40000").unwrap(), reward);
|
|
|
|
let block_number = 10000000;
|
|
let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
|
|
assert_eq!(1, eras);
|
|
assert_eq!(U256::from_str("3782DACE9D900000").unwrap(), reward);
|
|
|
|
let block_number = 20000000;
|
|
let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
|
|
assert_eq!(3, eras);
|
|
assert_eq!(U256::from_str("2386F26FC1000000").unwrap(), reward);
|
|
|
|
let block_number = 80000000;
|
|
let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
|
|
assert_eq!(15, eras);
|
|
assert_eq!(U256::from_str("271000000000000").unwrap(), reward);
|
|
|
|
let block_number = 250000000;
|
|
let (eras, reward) = ecip1017_eras_block_reward(eras_rounds, start_reward, block_number);
|
|
assert_eq!(49, eras);
|
|
assert_eq!(U256::from_str("51212FFBAF0A").unwrap(), reward);
|
|
}
|
|
|
|
#[test]
|
|
fn on_close_block_with_uncle() {
|
|
let spec = test_spec();
|
|
let engine = &*spec.engine;
|
|
let genesis_header = spec.genesis_header();
|
|
let db = spec
|
|
.ensure_db_good(get_temp_state_db(), &Default::default())
|
|
.unwrap();
|
|
let last_hashes = Arc::new(vec![genesis_header.hash()]);
|
|
let mut b = OpenBlock::new(
|
|
engine,
|
|
Default::default(),
|
|
false,
|
|
db,
|
|
&genesis_header,
|
|
last_hashes,
|
|
Address::zero(),
|
|
(3141562.into(), 31415620.into()),
|
|
vec![],
|
|
false,
|
|
None,
|
|
)
|
|
.unwrap();
|
|
let mut uncle = Header::new();
|
|
let uncle_author: Address = "ef2d6d194084c2de36e0dabfce45d046b37d1106".into();
|
|
uncle.set_author(uncle_author);
|
|
b.push_uncle(uncle).unwrap();
|
|
|
|
let b = b.close().unwrap();
|
|
assert_eq!(
|
|
b.state.balance(&Address::zero()).unwrap(),
|
|
"478eae0e571ba000".into()
|
|
);
|
|
assert_eq!(
|
|
b.state.balance(&uncle_author).unwrap(),
|
|
"3cb71f51fc558000".into()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn has_valid_mcip3_era_block_rewards() {
|
|
let spec = new_mcip3_test();
|
|
let engine = &*spec.engine;
|
|
let genesis_header = spec.genesis_header();
|
|
let db = spec
|
|
.ensure_db_good(get_temp_state_db(), &Default::default())
|
|
.unwrap();
|
|
let last_hashes = Arc::new(vec![genesis_header.hash()]);
|
|
let b = OpenBlock::new(
|
|
engine,
|
|
Default::default(),
|
|
false,
|
|
db,
|
|
&genesis_header,
|
|
last_hashes,
|
|
Address::zero(),
|
|
(3141562.into(), 31415620.into()),
|
|
vec![],
|
|
false,
|
|
None,
|
|
)
|
|
.unwrap();
|
|
let b = b.close().unwrap();
|
|
|
|
let ubi_contract: Address = "00efdd5883ec628983e9063c7d969fe268bbf310".into();
|
|
let dev_contract: Address = "00756cf8159095948496617f5fb17ed95059f536".into();
|
|
assert_eq!(
|
|
b.state.balance(&Address::zero()).unwrap(),
|
|
U256::from_str("d8d726b7177a80000").unwrap()
|
|
);
|
|
assert_eq!(
|
|
b.state.balance(&ubi_contract).unwrap(),
|
|
U256::from_str("2b5e3af16b1880000").unwrap()
|
|
);
|
|
assert_eq!(
|
|
b.state.balance(&dev_contract).unwrap(),
|
|
U256::from_str("c249fdd327780000").unwrap()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn has_valid_metadata() {
|
|
let engine = test_spec().engine;
|
|
assert!(!engine.name().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn can_return_schedule() {
|
|
let engine = test_spec().engine;
|
|
let schedule = engine.schedule(10000000);
|
|
assert!(schedule.stack_limit > 0);
|
|
|
|
let schedule = engine.schedule(100);
|
|
assert!(!schedule.have_delegate_call);
|
|
}
|
|
|
|
#[test]
|
|
fn can_do_seal_verification_fail() {
|
|
let engine = test_spec().engine;
|
|
let header: Header = Header::default();
|
|
|
|
let verify_result = engine.verify_block_basic(&header);
|
|
|
|
match verify_result {
|
|
Err(Error(ErrorKind::Block(BlockError::InvalidSealArity(_)), _)) => {}
|
|
Err(_) => {
|
|
panic!(
|
|
"should be block seal-arity mismatch error (got {:?})",
|
|
verify_result
|
|
);
|
|
}
|
|
_ => {
|
|
panic!("Should be error, got Ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn can_do_difficulty_verification_fail() {
|
|
let engine = test_spec().engine;
|
|
let mut header: Header = Header::default();
|
|
header.set_seal(vec![rlp::encode(&H256::zero()), rlp::encode(&H64::zero())]);
|
|
|
|
let verify_result = engine.verify_block_basic(&header);
|
|
|
|
match verify_result {
|
|
Err(Error(ErrorKind::Block(BlockError::DifficultyOutOfBounds(_)), _)) => {}
|
|
Err(_) => {
|
|
panic!("should be block difficulty error (got {:?})", verify_result);
|
|
}
|
|
_ => {
|
|
panic!("Should be error, got Ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn can_do_proof_of_work_verification_fail() {
|
|
let engine = test_spec().engine;
|
|
let mut header: Header = Header::default();
|
|
header.set_seal(vec![rlp::encode(&H256::zero()), rlp::encode(&H64::zero())]);
|
|
header.set_difficulty(
|
|
U256::from_str("ffffffffffffffffffffffffffffffffffffffffffffaaaaaaaaaaaaaaaaaaaa")
|
|
.unwrap(),
|
|
);
|
|
|
|
let verify_result = engine.verify_block_basic(&header);
|
|
|
|
match verify_result {
|
|
Err(Error(ErrorKind::Block(BlockError::InvalidProofOfWork(_)), _)) => {}
|
|
Err(_) => {
|
|
panic!(
|
|
"should be invalid proof of work error (got {:?})",
|
|
verify_result
|
|
);
|
|
}
|
|
_ => {
|
|
panic!("Should be error, got Ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn can_do_seal_unordered_verification_fail() {
|
|
let engine = test_spec().engine;
|
|
let header = Header::default();
|
|
|
|
let verify_result = engine.verify_block_unordered(&header);
|
|
|
|
match verify_result {
|
|
Err(Error(ErrorKind::Block(BlockError::InvalidSealArity(_)), _)) => {}
|
|
Err(_) => {
|
|
panic!(
|
|
"should be block seal-arity mismatch error (got {:?})",
|
|
verify_result
|
|
);
|
|
}
|
|
_ => {
|
|
panic!("Should be error, got Ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn can_do_seal_unordered_verification_fail2() {
|
|
let engine = test_spec().engine;
|
|
let mut header = Header::default();
|
|
header.set_seal(vec![vec![], vec![]]);
|
|
|
|
let verify_result = engine.verify_block_unordered(&header);
|
|
// rlp error, shouldn't panic
|
|
assert!(verify_result.is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn can_do_seal256_verification_fail() {
|
|
let engine = test_spec().engine;
|
|
let mut header: Header = Header::default();
|
|
header.set_seal(vec![rlp::encode(&H256::zero()), rlp::encode(&H64::zero())]);
|
|
let verify_result = engine.verify_block_unordered(&header);
|
|
|
|
match verify_result {
|
|
Err(Error(ErrorKind::Block(BlockError::MismatchedH256SealElement(_)), _)) => {}
|
|
Err(_) => {
|
|
panic!(
|
|
"should be invalid 256-bit seal fail (got {:?})",
|
|
verify_result
|
|
);
|
|
}
|
|
_ => {
|
|
panic!("Should be error, got Ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn can_do_proof_of_work_unordered_verification_fail() {
|
|
let engine = test_spec().engine;
|
|
let mut header: Header = Header::default();
|
|
header.set_seal(vec![
|
|
rlp::encode(&H256::from(
|
|
"b251bd2e0283d0658f2cadfdc8ca619b5de94eca5742725e2e757dd13ed7503d",
|
|
)),
|
|
rlp::encode(&H64::zero()),
|
|
]);
|
|
header.set_difficulty(
|
|
U256::from_str("ffffffffffffffffffffffffffffffffffffffffffffaaaaaaaaaaaaaaaaaaaa")
|
|
.unwrap(),
|
|
);
|
|
|
|
let verify_result = engine.verify_block_unordered(&header);
|
|
|
|
match verify_result {
|
|
Err(Error(ErrorKind::Block(BlockError::InvalidProofOfWork(_)), _)) => {}
|
|
Err(_) => {
|
|
panic!(
|
|
"should be invalid proof-of-work fail (got {:?})",
|
|
verify_result
|
|
);
|
|
}
|
|
_ => {
|
|
panic!("Should be error, got Ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn can_verify_block_family_genesis_fail() {
|
|
let engine = test_spec().engine;
|
|
let header: Header = Header::default();
|
|
let parent_header: Header = Header::default();
|
|
|
|
let verify_result = engine.verify_block_family(&header, &parent_header);
|
|
|
|
match verify_result {
|
|
Err(Error(ErrorKind::Block(BlockError::RidiculousNumber(_)), _)) => {}
|
|
Err(_) => {
|
|
panic!(
|
|
"should be invalid block number fail (got {:?})",
|
|
verify_result
|
|
);
|
|
}
|
|
_ => {
|
|
panic!("Should be error, got Ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn can_verify_block_family_difficulty_fail() {
|
|
let engine = test_spec().engine;
|
|
let mut header: Header = Header::default();
|
|
header.set_number(2);
|
|
let mut parent_header: Header = Header::default();
|
|
parent_header.set_number(1);
|
|
|
|
let verify_result = engine.verify_block_family(&header, &parent_header);
|
|
|
|
match verify_result {
|
|
Err(Error(ErrorKind::Block(BlockError::InvalidDifficulty(_)), _)) => {}
|
|
Err(_) => {
|
|
panic!(
|
|
"should be invalid difficulty fail (got {:?})",
|
|
verify_result
|
|
);
|
|
}
|
|
_ => {
|
|
panic!("Should be error, got Ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn difficulty_frontier() {
|
|
let machine = new_homestead_test_machine();
|
|
let ethparams = get_default_ethash_params();
|
|
let tempdir = TempDir::new("").unwrap();
|
|
let ethash = Ethash::new(tempdir.path(), ethparams, machine, None);
|
|
|
|
let mut parent_header = Header::default();
|
|
parent_header.set_number(1000000);
|
|
parent_header.set_difficulty(U256::from_str("b69de81a22b").unwrap());
|
|
parent_header.set_timestamp(1455404053);
|
|
let mut header = Header::default();
|
|
header.set_number(parent_header.number() + 1);
|
|
header.set_timestamp(1455404058);
|
|
|
|
let difficulty = ethash.calculate_difficulty(&header, &parent_header);
|
|
assert_eq!(U256::from_str("b6b4bbd735f").unwrap(), difficulty);
|
|
}
|
|
|
|
#[test]
|
|
fn difficulty_homestead() {
|
|
let machine = new_homestead_test_machine();
|
|
let ethparams = get_default_ethash_params();
|
|
let tempdir = TempDir::new("").unwrap();
|
|
let ethash = Ethash::new(tempdir.path(), ethparams, machine, None);
|
|
|
|
let mut parent_header = Header::default();
|
|
parent_header.set_number(1500000);
|
|
parent_header.set_difficulty(U256::from_str("1fd0fd70792b").unwrap());
|
|
parent_header.set_timestamp(1463003133);
|
|
let mut header = Header::default();
|
|
header.set_number(parent_header.number() + 1);
|
|
header.set_timestamp(1463003177);
|
|
|
|
let difficulty = ethash.calculate_difficulty(&header, &parent_header);
|
|
assert_eq!(U256::from_str("1fc50f118efe").unwrap(), difficulty);
|
|
}
|
|
|
|
#[test]
|
|
fn difficulty_max_timestamp() {
|
|
let machine = new_homestead_test_machine();
|
|
let ethparams = get_default_ethash_params();
|
|
let tempdir = TempDir::new("").unwrap();
|
|
let ethash = Ethash::new(tempdir.path(), ethparams, machine, None);
|
|
|
|
let mut parent_header = Header::default();
|
|
parent_header.set_number(1000000);
|
|
parent_header.set_difficulty(U256::from_str("b69de81a22b").unwrap());
|
|
parent_header.set_timestamp(1455404053);
|
|
let mut header = Header::default();
|
|
header.set_number(parent_header.number() + 1);
|
|
header.set_timestamp(u64::max_value());
|
|
|
|
let difficulty = ethash.calculate_difficulty(&header, &parent_header);
|
|
assert_eq!(U256::from(12543204905719u64), difficulty);
|
|
}
|
|
|
|
#[test]
|
|
fn test_extra_info() {
|
|
let machine = new_homestead_test_machine();
|
|
let ethparams = get_default_ethash_params();
|
|
let tempdir = TempDir::new("").unwrap();
|
|
let ethash = Ethash::new(tempdir.path(), ethparams, machine, None);
|
|
let mut header = Header::default();
|
|
header.set_seal(vec![
|
|
rlp::encode(&H256::from(
|
|
"b251bd2e0283d0658f2cadfdc8ca619b5de94eca5742725e2e757dd13ed7503d",
|
|
)),
|
|
rlp::encode(&H64::zero()),
|
|
]);
|
|
let info = ethash.extra_info(&header);
|
|
assert_eq!(info["nonce"], "0x0000000000000000");
|
|
assert_eq!(
|
|
info["mixHash"],
|
|
"0xb251bd2e0283d0658f2cadfdc8ca619b5de94eca5742725e2e757dd13ed7503d"
|
|
);
|
|
}
|
|
}
|