1ef9d5b52f
* WIP move errors, pod_account and state account to own crates * Sort out dependencies, fix broken code and tests Remove botched ethcore-error crate * remove template line * fix review feedback * Remove test-only AccountDBMut::new * Extract AccountDB to account-db * Move Substate to state-account – wip * Add lib.rs * cleanup * test failure * test failure 2 * third time's the charm * Add factories crate * Use new factories crate * Use factories crate * Extract trace * Fix tests * Sort out parity-util-mem and parking_lot * cleanup * WIP port over the rest of state from ethcore * Collect all impls for Machine * some notes * Rename pod-account to pod * Move PodState to pod crate * Use PodState from pod crate * Fix use clause for json tests * Sort out evmbin * Add missing code and use PodState * Move code that depends on Machine and Executive to own module * Sort out cloning errors, fix ethcore to use new state crate * Do without funky From impls * Fix ethcore tests * Fixes around the project to use new state crate * Add back the more specific impls of StateOrBlock From conversions * Move execute to freestanding function and remove it from trait Sort out the error handling in executive_state by moving the result types from state to ethcore Undo the verbose code added to work around the StateOrBlock From conversions * cleanup * Fix "error: enum variants on type aliases are experimental" * Bring back the state tests Fix whitespace * remove ethcore/state/mod.rs * cleanup * cleanup * Cleanup state-account errors * Fix more todos Add module docs * Add error.rs * Fixup Cargo.lock * Smaller ethcore API is fine * Add `to-pod-full` feature to state-account Fix evmbin * Fix a few more test failures * Fix RPC test build * Baptize the new trait * Remove resolved TODOs * Rename state-account to account-state * Do not re-export the trace crate * Don't export state_db from ethcore * Let private-tx use StateDB. :( * Remove ethcore/src/pod_state.rs * Inner type does not need to be pub/pub(crate) * optimise imports * Revert "Inner type does not need to be pub/pub(crate)" This reverts commit 2f839f8a0f72f71334da64620f57e6dd6039f06b. * Move DatabaseExtras to ethcore-blockchain * Add database_extra module to ethcore-blockchain * Remove to-pod-full feature * cosmetics * New crate: state-db * Add new crate * Move PreverifiedBlock and BlockError to types * Sort out the merge * Add missing `license` meta data keys * wip * wip client-traits * merge conflict * verification crate type checks * Move impls for CommonParams to common_types Fix misc stuff in ethcore * Fix tests * Implement VerifyingEngine for all engines except Ethash Temporarily sort out error handling Move more types to common_types * Split Engine in two and move code around * cleanup * verification: don't rexport common_types * Use error from common_types * Consolidate error types * VerifyingEngine use Errors from common_types * verification: Use error type from common_types * SnapshotError moved to common_types * Move more code from Engne to VerifyingEngine Add a VerifyingClient trait: BlockInfo + CallContract Whitespace * Add MAX_UNCLE_AGE const * Port over remaining code from ethcore/verification * Use errors from common_types * Fix the confusing "io" naming * Move more types into common_types * Add todos * Experiment with Engine trait outside ethcore * Hook up types from common_types in ethcore Don't use verification crate Don't use client-traits crate * Revert to impl Engine for Arc<Ethash> and add note to explain why Revert moving ClientIoMessage to common_types Fix build * Remove ClientIoMessage from common_types * Cleanup * More cleanup * Sort error handling changes in the rest of parity * Remove unused code * Remove WIP types * Cleanup todos not tackled here * remove cruft * Fix some whitespace and a merge error * ethcore tests * test failures * Restore Engine impls to master to make review a bit easier * cleanup * whitespace * applied review suggestions * types does not depend on rustc-hex * ethash engine moved to engine module * applied review suggestion
244 lines
8.1 KiB
Rust
244 lines
8.1 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/>.
|
|
|
|
//! A module with types for declaring block rewards and a client interface for interacting with a
|
|
//! block reward contract.
|
|
|
|
use ethabi;
|
|
use ethabi::ParamType;
|
|
use ethereum_types::{H160, Address, U256};
|
|
|
|
use std::sync::Arc;
|
|
use hash::keccak;
|
|
use machine::Machine;
|
|
use trace;
|
|
use types::{
|
|
BlockNumber,
|
|
errors::{EngineError, EthcoreError as Error},
|
|
};
|
|
use super::{SystemOrCodeCall, SystemOrCodeCallKind};
|
|
use trace::{Tracer, ExecutiveTracer, Tracing};
|
|
use block::ExecutedBlock;
|
|
|
|
use_contract!(block_reward_contract, "res/contracts/block_reward.json");
|
|
|
|
/// The kind of block reward.
|
|
/// Depending on the consensus engine the allocated block reward might have
|
|
/// different semantics which could lead e.g. to different reward values.
|
|
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
|
|
pub enum RewardKind {
|
|
/// Reward attributed to the block author.
|
|
Author,
|
|
/// Reward attributed to the author(s) of empty step(s) included in the block (AuthorityRound engine).
|
|
EmptyStep,
|
|
/// Reward attributed by an external protocol (e.g. block reward contract).
|
|
External,
|
|
/// Reward attributed to the block uncle(s) with given difference.
|
|
Uncle(u8),
|
|
}
|
|
|
|
impl RewardKind {
|
|
/// Create `RewardKind::Uncle` from given current block number and uncle block number.
|
|
pub fn uncle(number: BlockNumber, uncle: BlockNumber) -> Self {
|
|
RewardKind::Uncle(if number > uncle && number - uncle <= u8::max_value().into() { (number - uncle) as u8 } else { 0 })
|
|
}
|
|
}
|
|
|
|
impl From<RewardKind> for u16 {
|
|
fn from(reward_kind: RewardKind) -> Self {
|
|
match reward_kind {
|
|
RewardKind::Author => 0,
|
|
RewardKind::EmptyStep => 2,
|
|
RewardKind::External => 3,
|
|
|
|
RewardKind::Uncle(depth) => 100 + depth as u16,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Into<trace::RewardType> for RewardKind {
|
|
fn into(self) -> trace::RewardType {
|
|
match self {
|
|
RewardKind::Author => trace::RewardType::Block,
|
|
RewardKind::Uncle(_) => trace::RewardType::Uncle,
|
|
RewardKind::EmptyStep => trace::RewardType::EmptyStep,
|
|
RewardKind::External => trace::RewardType::External,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A client for the block reward contract.
|
|
#[derive(PartialEq, Debug)]
|
|
pub struct BlockRewardContract {
|
|
kind: SystemOrCodeCallKind,
|
|
}
|
|
|
|
impl BlockRewardContract {
|
|
/// Create a new block reward contract client targeting the system call kind.
|
|
pub fn new(kind: SystemOrCodeCallKind) -> BlockRewardContract {
|
|
BlockRewardContract {
|
|
kind,
|
|
}
|
|
}
|
|
|
|
/// Create a new block reward contract client targeting the contract address.
|
|
pub fn new_from_address(address: Address) -> BlockRewardContract {
|
|
Self::new(SystemOrCodeCallKind::Address(address))
|
|
}
|
|
|
|
/// Create a new block reward contract client targeting the given code.
|
|
pub fn new_from_code(code: Arc<Vec<u8>>) -> BlockRewardContract {
|
|
let code_hash = keccak(&code[..]);
|
|
|
|
Self::new(SystemOrCodeCallKind::Code(code, code_hash))
|
|
}
|
|
|
|
/// Calls the block reward contract with the given beneficiaries list (and associated reward kind)
|
|
/// and returns the reward allocation (address - value). The block reward contract *must* be
|
|
/// called by the system address so the `caller` must ensure that (e.g. using
|
|
/// `machine.execute_as_system`).
|
|
pub fn reward(
|
|
&self,
|
|
beneficiaries: &[(Address, RewardKind)],
|
|
caller: &mut SystemOrCodeCall,
|
|
) -> Result<Vec<(Address, U256)>, Error> {
|
|
let input = block_reward_contract::functions::reward::encode_input(
|
|
beneficiaries.iter().map(|&(address, _)| H160::from(address)),
|
|
beneficiaries.iter().map(|&(_, ref reward_kind)| u16::from(*reward_kind)),
|
|
);
|
|
|
|
let output = caller(self.kind.clone(), input)
|
|
.map_err(Into::into)
|
|
.map_err(EngineError::FailedSystemCall)?;
|
|
|
|
// since this is a non-constant call we can't use ethabi's function output
|
|
// deserialization, sadness ensues.
|
|
let types = &[
|
|
ParamType::Array(Box::new(ParamType::Address)),
|
|
ParamType::Array(Box::new(ParamType::Uint(256))),
|
|
];
|
|
|
|
let tokens = ethabi::decode(types, &output)
|
|
.map_err(|err| err.to_string())
|
|
.map_err(EngineError::FailedSystemCall)?;
|
|
|
|
assert!(tokens.len() == 2);
|
|
|
|
let addresses = tokens[0].clone().to_array().expect("type checked by ethabi::decode; qed");
|
|
let rewards = tokens[1].clone().to_array().expect("type checked by ethabi::decode; qed");
|
|
|
|
if addresses.len() != rewards.len() {
|
|
return Err(EngineError::FailedSystemCall(
|
|
"invalid data returned by reward contract: both arrays must have the same size".into()
|
|
).into());
|
|
}
|
|
|
|
let addresses = addresses.into_iter().map(|t| t.to_address().expect("type checked by ethabi::decode; qed"));
|
|
let rewards = rewards.into_iter().map(|t| t.to_uint().expect("type checked by ethabi::decode; qed"));
|
|
|
|
Ok(addresses.zip(rewards).collect())
|
|
}
|
|
}
|
|
|
|
/// Applies the given block rewards, i.e. adds the given balance to each beneficiary' address.
|
|
/// If tracing is enabled the operations are recorded.
|
|
pub fn apply_block_rewards(
|
|
rewards: &[(Address, RewardKind, U256)],
|
|
block: &mut ExecutedBlock,
|
|
machine: &Machine,
|
|
) -> Result<(), Error> {
|
|
for &(ref author, _, ref block_reward) in rewards {
|
|
machine.add_balance(block, author, block_reward)?;
|
|
}
|
|
|
|
if let Tracing::Enabled(ref mut traces) = *block.traces_mut() {
|
|
let mut tracer = ExecutiveTracer::default();
|
|
|
|
for &(address, reward_kind, amount) in rewards {
|
|
tracer.trace_reward(address, amount, reward_kind.into());
|
|
}
|
|
|
|
traces.push(tracer.drain().into());
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use std::str::FromStr;
|
|
use client::PrepareOpenBlock;
|
|
use ethereum_types::{U256, Address};
|
|
use spec::Spec;
|
|
use test_helpers::generate_dummy_client_with_spec;
|
|
|
|
use engines::SystemOrCodeCallKind;
|
|
use super::{BlockRewardContract, RewardKind};
|
|
|
|
#[test]
|
|
fn block_reward_contract() {
|
|
let client = generate_dummy_client_with_spec(Spec::new_test_round_block_reward_contract);
|
|
|
|
let machine = Spec::new_test_machine();
|
|
|
|
// the spec has a block reward contract defined at the given address
|
|
let block_reward_contract = BlockRewardContract::new_from_address(
|
|
Address::from_str("0000000000000000000000000000000000000042").unwrap(),
|
|
);
|
|
|
|
let mut call = |to, data| {
|
|
let mut block = client.prepare_open_block(
|
|
Address::from_str("0000000000000000000000000000000000000001").unwrap(),
|
|
(3141562.into(), 31415620.into()),
|
|
vec![],
|
|
).unwrap();
|
|
|
|
let result = match to {
|
|
SystemOrCodeCallKind::Address(to) => {
|
|
machine.execute_as_system(
|
|
block.block_mut(),
|
|
to,
|
|
U256::max_value(),
|
|
Some(data),
|
|
)
|
|
},
|
|
_ => panic!("Test reward contract is created by an address, we never reach this branch."),
|
|
};
|
|
|
|
result.map_err(|e| format!("{}", e))
|
|
};
|
|
|
|
// if no beneficiaries are given no rewards are attributed
|
|
assert!(block_reward_contract.reward(&vec![], &mut call).unwrap().is_empty());
|
|
|
|
// the contract rewards (1000 + kind) for each benefactor
|
|
let beneficiaries = vec![
|
|
(Address::from_str("0000000000000000000000000000000000000033").unwrap(), RewardKind::Author),
|
|
(Address::from_str("0000000000000000000000000000000000000034").unwrap(), RewardKind::Uncle(1)),
|
|
(Address::from_str("0000000000000000000000000000000000000035").unwrap(), RewardKind::EmptyStep),
|
|
];
|
|
|
|
let rewards = block_reward_contract.reward(&beneficiaries, &mut call).unwrap();
|
|
let expected = vec![
|
|
(Address::from_str("0000000000000000000000000000000000000033").unwrap(), U256::from(1000)),
|
|
(Address::from_str("0000000000000000000000000000000000000034").unwrap(), U256::from(1000 + 101)),
|
|
(Address::from_str("0000000000000000000000000000000000000035").unwrap(), U256::from(1000 + 2)),
|
|
];
|
|
|
|
assert_eq!(expected, rewards);
|
|
}
|
|
}
|