185 lines
6.0 KiB
Rust
185 lines
6.0 KiB
Rust
// Copyright 2015-2018 Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity.
|
|
|
|
// Parity 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 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. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
use ethabi;
|
|
use ethabi::ParamType;
|
|
use ethereum_types::{H160, Address, U256};
|
|
|
|
use block::ExecutedBlock;
|
|
use error::Error;
|
|
use machine::EthereumMachine;
|
|
use super::SystemCall;
|
|
|
|
use_contract!(block_reward_contract, "BlockReward", "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.
|
|
#[repr(u8)]
|
|
#[derive(PartialEq, Eq, Clone, Copy, Debug)]
|
|
pub enum RewardKind {
|
|
/// Reward attributed to the block author.
|
|
Author = 0,
|
|
/// Reward attributed to the block uncle(s).
|
|
Uncle = 1,
|
|
/// Reward attributed to the author(s) of empty step(s) included in the block (AuthorityRound engine).
|
|
EmptyStep = 2,
|
|
}
|
|
|
|
impl From<RewardKind> for u16 {
|
|
fn from(reward_kind: RewardKind) -> Self {
|
|
reward_kind as u16
|
|
}
|
|
}
|
|
|
|
/// A client for the block reward contract.
|
|
pub struct BlockRewardContract {
|
|
/// Address of the contract.
|
|
address: Address,
|
|
block_reward_contract: block_reward_contract::BlockReward,
|
|
}
|
|
|
|
impl BlockRewardContract {
|
|
/// Create a new block reward contract client targeting the given address.
|
|
pub fn new(address: Address) -> BlockRewardContract {
|
|
BlockRewardContract {
|
|
address,
|
|
block_reward_contract: block_reward_contract::BlockReward::default(),
|
|
}
|
|
}
|
|
|
|
/// Calls the block reward contract with the given benefactors 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,
|
|
benefactors: &[(Address, RewardKind)],
|
|
caller: &mut SystemCall,
|
|
) -> Result<Vec<(Address, U256)>, Error> {
|
|
let reward = self.block_reward_contract.functions().reward();
|
|
|
|
let input = reward.input(
|
|
benefactors.iter().map(|&(address, _)| H160::from(address)),
|
|
benefactors.iter().map(|&(_, ref reward_kind)| u16::from(*reward_kind)),
|
|
);
|
|
|
|
let output = caller(self.address, input)
|
|
.map_err(Into::into)
|
|
.map_err(::engines::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(::engines::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(::engines::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 benefactors' address.
|
|
/// If tracing is enabled the operations are recorded.
|
|
pub fn apply_block_rewards(rewards: &[(Address, U256)], block: &mut ExecutedBlock, machine: &EthereumMachine) -> Result<(), Error> {
|
|
use parity_machine::WithBalances;
|
|
|
|
for &(ref author, ref block_reward) in rewards {
|
|
machine.add_balance(block, author, block_reward)?;
|
|
}
|
|
|
|
machine.note_rewards(block, &rewards, &[])
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use client::PrepareOpenBlock;
|
|
use ethereum_types::U256;
|
|
use spec::Spec;
|
|
use test_helpers::generate_dummy_client_with_spec_and_accounts;
|
|
|
|
use super::{BlockRewardContract, RewardKind};
|
|
|
|
#[test]
|
|
fn block_reward_contract() {
|
|
let client = generate_dummy_client_with_spec_and_accounts(
|
|
Spec::new_test_round_block_reward_contract,
|
|
None,
|
|
);
|
|
|
|
let machine = Spec::new_test_machine();
|
|
|
|
// the spec has a block reward contract defined at the given address
|
|
let block_reward_contract = BlockRewardContract::new(
|
|
"0000000000000000000000000000000000000042".into(),
|
|
);
|
|
|
|
let mut call = |to, data| {
|
|
let mut block = client.prepare_open_block(
|
|
"0000000000000000000000000000000000000001".into(),
|
|
(3141562.into(), 31415620.into()),
|
|
vec![],
|
|
);
|
|
|
|
let result = machine.execute_as_system(
|
|
block.block_mut(),
|
|
to,
|
|
U256::max_value(),
|
|
Some(data),
|
|
);
|
|
|
|
result.map_err(|e| format!("{}", e))
|
|
};
|
|
|
|
// if no benefactors 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 benefactors = vec![
|
|
("0000000000000000000000000000000000000033".into(), RewardKind::Author),
|
|
("0000000000000000000000000000000000000034".into(), RewardKind::Uncle),
|
|
("0000000000000000000000000000000000000035".into(), RewardKind::EmptyStep),
|
|
];
|
|
|
|
let rewards = block_reward_contract.reward(&benefactors, &mut call).unwrap();
|
|
let expected = vec![
|
|
("0000000000000000000000000000000000000033".into(), U256::from(1000)),
|
|
("0000000000000000000000000000000000000034".into(), U256::from(1000 + 1)),
|
|
("0000000000000000000000000000000000000035".into(), U256::from(1000 + 2)),
|
|
];
|
|
|
|
assert_eq!(expected, rewards);
|
|
}
|
|
}
|