899 lines
32 KiB
Rust
899 lines
32 KiB
Rust
// Copyright 2015-2020 Parity Technologies (UK) Ltd.
|
|
// This file is part of OpenEthereum.
|
|
|
|
// OpenEthereum 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.
|
|
|
|
// OpenEthereum 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 OpenEthereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/// Validator set maintained in a contract, updated using `getValidators` method.
|
|
use std::{
|
|
collections::VecDeque,
|
|
sync::{Arc, Weak},
|
|
};
|
|
|
|
use bytes::Bytes;
|
|
use error::{Error as EthcoreError, ErrorKind as EthcoreErrorKind};
|
|
use ethabi::FunctionOutputDecoder;
|
|
use ethereum_types::{Address, Bloom, H256, U256};
|
|
use hash::keccak;
|
|
use kvdb::DBValue;
|
|
use memory_cache::MemoryLruCache;
|
|
use parking_lot::{Mutex, RwLock};
|
|
use rlp::{Rlp, RlpStream};
|
|
use types::{
|
|
header::Header, ids::BlockId, log_entry::LogEntry, receipt::TypedReceipt, transaction,
|
|
BlockNumber,
|
|
};
|
|
use unexpected::Mismatch;
|
|
|
|
use super::{simple_list::SimpleList, SystemCall, ValidatorSet};
|
|
use client::{traits::TransactionRequest, BlockChainClient, EngineClient};
|
|
use machine::{AuxiliaryData, AuxiliaryRequest, Call, EthereumMachine};
|
|
|
|
use_contract!(validator_set, "res/contracts/validator_set.json");
|
|
|
|
/// The maximum number of reports to keep queued.
|
|
const MAX_QUEUED_REPORTS: usize = 10;
|
|
/// The maximum number of malice reports to include when creating a new block.
|
|
const MAX_REPORTS_PER_BLOCK: usize = 10;
|
|
/// Don't re-send malice reports every block. Skip this many before retrying.
|
|
const REPORTS_SKIP_BLOCKS: u64 = 1;
|
|
|
|
const MEMOIZE_CAPACITY: usize = 500;
|
|
|
|
// TODO: ethabi should be able to generate this.
|
|
const EVENT_NAME: &'static [u8] = &*b"InitiateChange(bytes32,address[])";
|
|
|
|
lazy_static! {
|
|
static ref EVENT_NAME_HASH: H256 = keccak(EVENT_NAME);
|
|
}
|
|
|
|
// state-dependent proofs for the safe contract:
|
|
// only "first" proofs are such.
|
|
struct StateProof {
|
|
contract_address: Address,
|
|
header: Header,
|
|
}
|
|
|
|
impl ::engines::StateDependentProof<EthereumMachine> for StateProof {
|
|
fn generate_proof(&self, caller: &Call) -> Result<Vec<u8>, String> {
|
|
prove_initial(self.contract_address, &self.header, caller)
|
|
}
|
|
|
|
fn check_proof(&self, machine: &EthereumMachine, proof: &[u8]) -> Result<(), String> {
|
|
let (header, state_items) = decode_first_proof(&Rlp::new(proof))
|
|
.map_err(|e| format!("proof incorrectly encoded: {}", e))?;
|
|
if &header != &self.header {
|
|
return Err("wrong header in proof".into());
|
|
}
|
|
|
|
check_first_proof(machine, self.contract_address, header, &state_items).map(|_| ())
|
|
}
|
|
}
|
|
|
|
/// The validator contract should have the following interface:
|
|
pub struct ValidatorSafeContract {
|
|
contract_address: Address,
|
|
validators: RwLock<MemoryLruCache<H256, SimpleList>>,
|
|
client: RwLock<Option<Weak<dyn EngineClient>>>, // TODO [keorn]: remove
|
|
report_queue: Mutex<ReportQueue>,
|
|
/// The block number where we resent the queued reports last time.
|
|
resent_reports_in_block: Mutex<BlockNumber>,
|
|
/// If set, this is the block number at which the consensus engine switches from AuRa to AuRa
|
|
/// with POSDAO modifications.
|
|
posdao_transition: Option<BlockNumber>,
|
|
}
|
|
|
|
// first proof is just a state proof call of `getValidators` at header's state.
|
|
fn encode_first_proof(header: &Header, state_items: &[Vec<u8>]) -> Bytes {
|
|
let mut stream = RlpStream::new_list(2);
|
|
stream.append(header).begin_list(state_items.len());
|
|
for item in state_items {
|
|
stream.append(item);
|
|
}
|
|
|
|
stream.out()
|
|
}
|
|
|
|
// check a first proof: fetch the validator set at the given block.
|
|
fn check_first_proof(
|
|
machine: &EthereumMachine,
|
|
contract_address: Address,
|
|
old_header: Header,
|
|
state_items: &[DBValue],
|
|
) -> Result<Vec<Address>, String> {
|
|
use types::transaction::{Action, Transaction, TypedTransaction};
|
|
|
|
// TODO: match client contract_call_tx more cleanly without duplication.
|
|
const PROVIDED_GAS: u64 = 50_000_000;
|
|
|
|
let env_info = ::vm::EnvInfo {
|
|
number: old_header.number(),
|
|
author: *old_header.author(),
|
|
difficulty: *old_header.difficulty(),
|
|
gas_limit: PROVIDED_GAS.into(),
|
|
timestamp: old_header.timestamp(),
|
|
last_hashes: {
|
|
// this will break if we don't inclue all 256 last hashes.
|
|
let mut last_hashes: Vec<_> = (0..256).map(|_| H256::default()).collect();
|
|
last_hashes[255] = *old_header.parent_hash();
|
|
Arc::new(last_hashes)
|
|
},
|
|
gas_used: 0.into(),
|
|
};
|
|
|
|
// check state proof using given machine.
|
|
let number = old_header.number();
|
|
let (data, decoder) = validator_set::functions::get_validators::call();
|
|
|
|
let from = Address::default();
|
|
let tx = TypedTransaction::Legacy(Transaction {
|
|
nonce: machine.account_start_nonce(number),
|
|
action: Action::Call(contract_address),
|
|
gas: PROVIDED_GAS.into(),
|
|
gas_price: U256::default(),
|
|
value: U256::default(),
|
|
data,
|
|
})
|
|
.fake_sign(from);
|
|
|
|
let res = ::state::check_proof(
|
|
state_items,
|
|
*old_header.state_root(),
|
|
&tx,
|
|
machine,
|
|
&env_info,
|
|
);
|
|
|
|
match res {
|
|
::state::ProvedExecution::BadProof => Err("Bad proof".into()),
|
|
::state::ProvedExecution::Failed(e) => Err(format!("Failed call: {}", e)),
|
|
::state::ProvedExecution::Complete(e) => {
|
|
decoder.decode(&e.output).map_err(|e| e.to_string())
|
|
}
|
|
}
|
|
}
|
|
|
|
fn decode_first_proof(rlp: &Rlp) -> Result<(Header, Vec<DBValue>), ::error::Error> {
|
|
let header = rlp.val_at(0)?;
|
|
let state_items = rlp
|
|
.at(1)?
|
|
.iter()
|
|
.map(|x| {
|
|
let mut val = DBValue::new();
|
|
val.append_slice(x.data()?);
|
|
Ok(val)
|
|
})
|
|
.collect::<Result<_, ::error::Error>>()?;
|
|
|
|
Ok((header, state_items))
|
|
}
|
|
|
|
// inter-contract proofs are a header and receipts.
|
|
// checking will involve ensuring that the receipts match the header and
|
|
// extracting the validator set from the receipts.
|
|
fn encode_proof(header: &Header, receipts: &[TypedReceipt]) -> Bytes {
|
|
let mut stream = RlpStream::new_list(2);
|
|
stream.append(header);
|
|
TypedReceipt::rlp_append_list(&mut stream, receipts);
|
|
stream.drain()
|
|
}
|
|
|
|
fn decode_proof(rlp: &Rlp) -> Result<(Header, Vec<TypedReceipt>), ::error::Error> {
|
|
Ok((rlp.val_at(0)?, TypedReceipt::decode_rlp_list(&rlp.at(1)?)?))
|
|
}
|
|
|
|
// given a provider and caller, generate proof. this will just be a state proof
|
|
// of `getValidators`.
|
|
fn prove_initial(
|
|
contract_address: Address,
|
|
header: &Header,
|
|
caller: &Call,
|
|
) -> Result<Vec<u8>, String> {
|
|
use std::cell::RefCell;
|
|
|
|
let epoch_proof = RefCell::new(None);
|
|
let validators = {
|
|
let (data, decoder) = validator_set::functions::get_validators::call();
|
|
let (value, proof) = caller(contract_address, data)?;
|
|
*epoch_proof.borrow_mut() = Some(encode_first_proof(header, &proof));
|
|
decoder.decode(&value).map_err(|e| e.to_string())?
|
|
};
|
|
|
|
let proof = epoch_proof
|
|
.into_inner()
|
|
.expect("epoch_proof always set after call; qed");
|
|
|
|
trace!(target: "engine", "obtained proof for initial set: {} validators, {} bytes",
|
|
validators.len(), proof.len());
|
|
|
|
info!(target: "engine", "Signal for switch to contract-based validator set.");
|
|
info!(target: "engine", "Initial contract validators: {:?}", validators);
|
|
|
|
Ok(proof)
|
|
}
|
|
|
|
impl ValidatorSafeContract {
|
|
pub fn new(contract_address: Address, posdao_transition: Option<BlockNumber>) -> Self {
|
|
ValidatorSafeContract {
|
|
contract_address,
|
|
validators: RwLock::new(MemoryLruCache::new(MEMOIZE_CAPACITY)),
|
|
client: RwLock::new(None),
|
|
report_queue: Mutex::new(ReportQueue::default()),
|
|
resent_reports_in_block: Mutex::new(0),
|
|
posdao_transition,
|
|
}
|
|
}
|
|
|
|
fn transact(&self, data: Bytes, nonce: U256) -> Result<(), EthcoreError> {
|
|
let client = self
|
|
.client
|
|
.read()
|
|
.as_ref()
|
|
.and_then(Weak::upgrade)
|
|
.ok_or("No client!")?;
|
|
let full_client = client.as_full_client().ok_or("No full client!")?;
|
|
|
|
let tx_request = TransactionRequest::call(self.contract_address, data)
|
|
.gas_price(U256::zero())
|
|
.nonce(nonce);
|
|
match full_client.transact(tx_request) {
|
|
Ok(()) | Err(transaction::Error::AlreadyImported) => Ok(()),
|
|
Err(e) => Err(e)?,
|
|
}
|
|
}
|
|
|
|
/// Puts a malice report into the queue for later resending.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `addr` - The address of the misbehaving validator.
|
|
/// * `block` - The block number at which the misbehavior occurred.
|
|
/// * `data` - The call data for the `reportMalicious` contract call.
|
|
pub(crate) fn enqueue_report(&self, addr: Address, block: BlockNumber, data: Vec<u8>) {
|
|
// Skip the rest of the function unless there has been a transition to POSDAO AuRa.
|
|
if self
|
|
.posdao_transition
|
|
.map_or(true, |block_num| block < block_num)
|
|
{
|
|
trace!(target: "engine", "Skipping queueing a malicious behavior report");
|
|
return;
|
|
}
|
|
self.report_queue.lock().push(addr, block, data)
|
|
}
|
|
|
|
/// Queries the state and gets the set of validators.
|
|
fn get_list(&self, caller: &Call) -> Option<SimpleList> {
|
|
let contract_address = self.contract_address;
|
|
|
|
let (data, decoder) = validator_set::functions::get_validators::call();
|
|
let value = caller(contract_address, data)
|
|
.and_then(|x| decoder.decode(&x.0).map_err(|e| e.to_string()));
|
|
|
|
match value {
|
|
Ok(new) => {
|
|
debug!(target: "engine", "Set of validators obtained: {:?}", new);
|
|
Some(SimpleList::new(new))
|
|
}
|
|
Err(s) => {
|
|
debug!(target: "engine", "Set of validators could not be updated: {}", s);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
// Whether the header matches the expected bloom.
|
|
//
|
|
// The expected log should have 3 topics:
|
|
// 1. ETHABI-encoded log name.
|
|
// 2. the block's parent hash.
|
|
// 3. the "nonce": n for the nth transition in history.
|
|
//
|
|
// We can only search for the first 2, since we don't have the third
|
|
// just yet.
|
|
//
|
|
// The parent hash is included to prevent
|
|
// malicious actors from brute forcing other logs that would
|
|
// produce the same bloom.
|
|
//
|
|
// The log data is an array of all new validator addresses.
|
|
fn expected_bloom(&self, header: &Header) -> Bloom {
|
|
let topics = vec![*EVENT_NAME_HASH, *header.parent_hash()];
|
|
|
|
debug!(target: "engine", "Expected topics for header {}: {:?}",
|
|
header.hash(), topics);
|
|
|
|
LogEntry {
|
|
address: self.contract_address,
|
|
topics: topics,
|
|
data: Vec::new(), // irrelevant for bloom.
|
|
}
|
|
.bloom()
|
|
}
|
|
|
|
// check receipts for log event. bloom should be `expected_bloom` for the
|
|
// header the receipts correspond to.
|
|
fn extract_from_event(
|
|
&self,
|
|
bloom: Bloom,
|
|
header: &Header,
|
|
receipts: &[TypedReceipt],
|
|
) -> Option<SimpleList> {
|
|
let check_log = |log: &LogEntry| {
|
|
log.address == self.contract_address
|
|
&& log.topics.len() == 2
|
|
&& log.topics[0] == *EVENT_NAME_HASH
|
|
&& log.topics[1] == *header.parent_hash()
|
|
};
|
|
|
|
//// iterate in reverse because only the _last_ change in a given
|
|
//// block actually has any effect.
|
|
//// the contract should only increment the nonce once.
|
|
let mut decoded_events = receipts
|
|
.iter()
|
|
.rev()
|
|
.filter(|r| r.log_bloom.contains_bloom(&bloom))
|
|
.flat_map(|r| r.logs.iter())
|
|
.filter(move |l| check_log(l))
|
|
.filter_map(|log| {
|
|
validator_set::events::initiate_change::parse_log(
|
|
(log.topics.clone(), log.data.clone()).into(),
|
|
)
|
|
.ok()
|
|
});
|
|
|
|
// only last log is taken into account
|
|
decoded_events
|
|
.next()
|
|
.map(|matched_event| SimpleList::new(matched_event.new_set))
|
|
}
|
|
}
|
|
|
|
impl ValidatorSet for ValidatorSafeContract {
|
|
fn default_caller(&self, id: BlockId) -> Box<Call> {
|
|
let client = self.client.read().clone();
|
|
Box::new(move |addr, data| {
|
|
client
|
|
.as_ref()
|
|
.and_then(Weak::upgrade)
|
|
.ok_or_else(|| "No client!".into())
|
|
.and_then(|c| match c.as_full_client() {
|
|
Some(c) => c.call_contract(id, addr, data),
|
|
None => Err("No full client!".into()),
|
|
})
|
|
.map(|out| (out, Vec::new()))
|
|
}) // generate no proofs in general
|
|
}
|
|
|
|
fn generate_engine_transactions(
|
|
&self,
|
|
_first: bool,
|
|
header: &Header,
|
|
caller: &mut SystemCall,
|
|
) -> Result<Vec<(Address, Bytes)>, EthcoreError> {
|
|
// Skip the rest of the function unless there has been a transition to POSDAO AuRa.
|
|
if self
|
|
.posdao_transition
|
|
.map_or(true, |block_num| header.number() < block_num)
|
|
{
|
|
trace!(target: "engine", "Skipping a call to emitInitiateChange");
|
|
return Ok(Vec::new());
|
|
}
|
|
let mut transactions = Vec::new();
|
|
|
|
// Create the `InitiateChange` event if necessary.
|
|
let (data, decoder) = validator_set::functions::emit_initiate_change_callable::call();
|
|
let emit_initiate_change_callable = caller(self.contract_address, data)
|
|
.and_then(|x| {
|
|
decoder
|
|
.decode(&x)
|
|
.map_err(|x| format!("chain spec bug: could not decode: {:?}", x))
|
|
})
|
|
.map_err(::engines::EngineError::FailedSystemCall)?;
|
|
if !emit_initiate_change_callable {
|
|
trace!(target: "engine", "New block #{} issued ― no need to call emitInitiateChange()", header.number());
|
|
} else {
|
|
trace!(target: "engine", "New block issued #{} ― calling emitInitiateChange()", header.number());
|
|
let (data, _decoder) = validator_set::functions::emit_initiate_change::call();
|
|
transactions.push((self.contract_address, data));
|
|
}
|
|
|
|
let client = self
|
|
.client
|
|
.read()
|
|
.as_ref()
|
|
.and_then(Weak::upgrade)
|
|
.ok_or("No client!")?;
|
|
let client = client.as_full_client().ok_or("No full client!")?;
|
|
|
|
// Retry all pending reports.
|
|
let mut report_queue = self.report_queue.lock();
|
|
report_queue.filter(client, header.author(), self.contract_address);
|
|
for (_address, _block, data) in report_queue.iter().take(MAX_REPORTS_PER_BLOCK) {
|
|
transactions.push((self.contract_address, data.clone()))
|
|
}
|
|
|
|
Ok(transactions)
|
|
}
|
|
|
|
fn on_close_block(&self, header: &Header, our_address: &Address) -> Result<(), EthcoreError> {
|
|
// Skip the rest of the function unless there has been a transition to POSDAO AuRa.
|
|
if self
|
|
.posdao_transition
|
|
.map_or(true, |block_num| header.number() < block_num)
|
|
{
|
|
trace!(target: "engine", "Skipping resending of queued malicious behavior reports");
|
|
return Ok(());
|
|
}
|
|
|
|
let client = self
|
|
.client
|
|
.read()
|
|
.as_ref()
|
|
.and_then(Weak::upgrade)
|
|
.ok_or("No client!")?;
|
|
let client = client.as_full_client().ok_or("No full client!")?;
|
|
|
|
let mut report_queue = self.report_queue.lock();
|
|
report_queue.filter(client, our_address, self.contract_address);
|
|
report_queue.truncate();
|
|
|
|
let mut resent_reports_in_block = self.resent_reports_in_block.lock();
|
|
|
|
// Skip at least one block after sending malicious reports last time.
|
|
if header.number() > *resent_reports_in_block + REPORTS_SKIP_BLOCKS {
|
|
*resent_reports_in_block = header.number();
|
|
let mut nonce = client.latest_nonce(our_address);
|
|
for (address, block, data) in report_queue.iter() {
|
|
debug!(target: "engine", "Retrying to report validator {} for misbehavior on block {} with nonce {}.",
|
|
address, block, nonce);
|
|
while match self.transact(data.clone(), nonce) {
|
|
Ok(()) => false,
|
|
Err(EthcoreError(
|
|
EthcoreErrorKind::Transaction(transaction::Error::Old),
|
|
_,
|
|
)) => true,
|
|
Err(err) => {
|
|
warn!(target: "engine", "Cannot report validator {} for misbehavior on block {}: {}",
|
|
address, block, err);
|
|
false
|
|
}
|
|
} {
|
|
warn!(target: "engine", "Nonce {} already used. Incrementing.", nonce);
|
|
nonce += U256::from(1);
|
|
}
|
|
nonce += U256::from(1);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn on_epoch_begin(
|
|
&self,
|
|
_first: bool,
|
|
_header: &Header,
|
|
caller: &mut SystemCall,
|
|
) -> Result<(), ::error::Error> {
|
|
let data = validator_set::functions::finalize_change::encode_input();
|
|
caller(self.contract_address, data)
|
|
.map(|_| ())
|
|
.map_err(::engines::EngineError::FailedSystemCall)
|
|
.map_err(Into::into)
|
|
}
|
|
|
|
fn genesis_epoch_data(&self, header: &Header, call: &Call) -> Result<Vec<u8>, String> {
|
|
prove_initial(self.contract_address, header, call)
|
|
}
|
|
|
|
fn is_epoch_end(&self, _first: bool, _chain_head: &Header) -> Option<Vec<u8>> {
|
|
None // no immediate transitions to contract.
|
|
}
|
|
|
|
fn signals_epoch_end(
|
|
&self,
|
|
first: bool,
|
|
header: &Header,
|
|
aux: AuxiliaryData,
|
|
) -> ::engines::EpochChange<EthereumMachine> {
|
|
let receipts = aux.receipts;
|
|
|
|
// transition to the first block of a contract requires finality but has no log event.
|
|
if first {
|
|
debug!(target: "engine", "signalling transition to fresh contract.");
|
|
let state_proof = Arc::new(StateProof {
|
|
contract_address: self.contract_address,
|
|
header: header.clone(),
|
|
});
|
|
return ::engines::EpochChange::Yes(::engines::Proof::WithState(state_proof as Arc<_>));
|
|
}
|
|
|
|
// otherwise, we're checking for logs.
|
|
let bloom = self.expected_bloom(header);
|
|
let header_bloom = header.log_bloom();
|
|
|
|
if &bloom & header_bloom != bloom {
|
|
return ::engines::EpochChange::No;
|
|
}
|
|
|
|
trace!(target: "engine", "detected epoch change event bloom");
|
|
|
|
match receipts {
|
|
None => ::engines::EpochChange::Unsure(AuxiliaryRequest::Receipts),
|
|
Some(receipts) => match self.extract_from_event(bloom, header, receipts) {
|
|
None => ::engines::EpochChange::No,
|
|
Some(list) => {
|
|
info!(target: "engine", "Signal for transition within contract. New list: {:?}",
|
|
&*list);
|
|
|
|
let proof = encode_proof(&header, receipts);
|
|
::engines::EpochChange::Yes(::engines::Proof::Known(proof))
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
fn epoch_set(
|
|
&self,
|
|
first: bool,
|
|
machine: &EthereumMachine,
|
|
_number: ::types::BlockNumber,
|
|
proof: &[u8],
|
|
) -> Result<(SimpleList, Option<H256>), ::error::Error> {
|
|
let rlp = Rlp::new(proof);
|
|
|
|
if first {
|
|
trace!(target: "engine", "Recovering initial epoch set");
|
|
|
|
let (old_header, state_items) = decode_first_proof(&rlp)?;
|
|
let number = old_header.number();
|
|
let old_hash = old_header.hash();
|
|
let addresses =
|
|
check_first_proof(machine, self.contract_address, old_header, &state_items)
|
|
.map_err(::engines::EngineError::InsufficientProof)?;
|
|
|
|
trace!(target: "engine", "extracted epoch set at #{}: {} addresses",
|
|
number, addresses.len());
|
|
|
|
Ok((SimpleList::new(addresses), Some(old_hash)))
|
|
} else {
|
|
let (old_header, receipts) = decode_proof(&rlp)?;
|
|
|
|
// ensure receipts match header.
|
|
// TODO: optimize? these were just decoded.
|
|
let found_root = ::triehash::ordered_trie_root(receipts.iter().map(|r| r.encode()));
|
|
if found_root != *old_header.receipts_root() {
|
|
return Err(::error::BlockError::InvalidReceiptsRoot(Mismatch {
|
|
expected: *old_header.receipts_root(),
|
|
found: found_root,
|
|
})
|
|
.into());
|
|
}
|
|
|
|
let bloom = self.expected_bloom(&old_header);
|
|
|
|
match self.extract_from_event(bloom, &old_header, &receipts) {
|
|
Some(list) => Ok((list, Some(old_header.hash()))),
|
|
None => Err(::engines::EngineError::InsufficientProof(
|
|
"No log event in proof.".into(),
|
|
)
|
|
.into()),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn contains_with_caller(&self, block_hash: &H256, address: &Address, caller: &Call) -> bool {
|
|
let mut guard = self.validators.write();
|
|
let maybe_existing = guard
|
|
.get_mut(block_hash)
|
|
.map(|list| list.contains(block_hash, address));
|
|
maybe_existing.unwrap_or_else(|| {
|
|
self.get_list(caller).map_or(false, |list| {
|
|
let contains = list.contains(block_hash, address);
|
|
guard.insert(block_hash.clone(), list);
|
|
contains
|
|
})
|
|
})
|
|
}
|
|
|
|
fn get_with_caller(&self, block_hash: &H256, nonce: usize, caller: &Call) -> Address {
|
|
let mut guard = self.validators.write();
|
|
let maybe_existing = guard
|
|
.get_mut(block_hash)
|
|
.map(|list| list.get(block_hash, nonce));
|
|
maybe_existing.unwrap_or_else(|| {
|
|
self.get_list(caller).map_or_else(Default::default, |list| {
|
|
let address = list.get(block_hash, nonce);
|
|
guard.insert(block_hash.clone(), list);
|
|
address
|
|
})
|
|
})
|
|
}
|
|
|
|
fn count_with_caller(&self, block_hash: &H256, caller: &Call) -> usize {
|
|
let mut guard = self.validators.write();
|
|
let maybe_existing = guard.get_mut(block_hash).map(|list| list.count(block_hash));
|
|
maybe_existing.unwrap_or_else(|| {
|
|
self.get_list(caller).map_or_else(usize::max_value, |list| {
|
|
let address = list.count(block_hash);
|
|
guard.insert(block_hash.clone(), list);
|
|
address
|
|
})
|
|
})
|
|
}
|
|
|
|
fn register_client(&self, client: Weak<dyn EngineClient>) {
|
|
trace!(target: "engine", "Setting up contract caller.");
|
|
*self.client.write() = Some(client);
|
|
}
|
|
}
|
|
|
|
/// A queue containing pending reports of malicious validators.
|
|
#[derive(Debug, Default)]
|
|
struct ReportQueue(VecDeque<(Address, BlockNumber, Vec<u8>)>);
|
|
|
|
impl ReportQueue {
|
|
/// Pushes a report to the end of the queue.
|
|
fn push(&mut self, addr: Address, block: BlockNumber, data: Vec<u8>) {
|
|
self.0.push_back((addr, block, data));
|
|
}
|
|
|
|
/// Filters reports of validators that have already been reported or are banned.
|
|
fn filter(
|
|
&mut self,
|
|
client: &dyn BlockChainClient,
|
|
our_address: &Address,
|
|
contract_address: Address,
|
|
) {
|
|
self.0.retain(|&(malicious_validator_address, block, ref _data)| {
|
|
trace!(
|
|
target: "engine",
|
|
"Checking if report of malicious validator {} at block {} should be removed from cache",
|
|
malicious_validator_address,
|
|
block
|
|
);
|
|
// Check if the validator should be reported.
|
|
let (data, decoder) = validator_set::functions::should_validator_report::call(
|
|
*our_address, malicious_validator_address, block
|
|
);
|
|
match client.call_contract(BlockId::Latest, contract_address, data)
|
|
.and_then(|result| decoder.decode(&result[..]).map_err(|e| e.to_string()))
|
|
{
|
|
Ok(false) => {
|
|
trace!(target: "engine", "Successfully removed report from report cache");
|
|
false
|
|
}
|
|
Ok(true) => true,
|
|
Err(err) => {
|
|
warn!(target: "engine", "Failed to query report status {:?}, dropping pending report.", err);
|
|
false
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/// Returns an iterator over all transactions in the queue.
|
|
fn iter(&self) -> impl Iterator<Item = &(Address, BlockNumber, Vec<u8>)> {
|
|
self.0.iter()
|
|
}
|
|
|
|
/// Removes reports from the queue if it contains more than `MAX_QUEUED_REPORTS` entries.
|
|
fn truncate(&mut self) {
|
|
if self.0.len() > MAX_QUEUED_REPORTS {
|
|
warn!(
|
|
target: "engine",
|
|
"Removing {} reports from report cache, even though it has not been finalized",
|
|
self.0.len() - MAX_QUEUED_REPORTS
|
|
);
|
|
self.0.truncate(MAX_QUEUED_REPORTS);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::{super::ValidatorSet, ValidatorSafeContract, EVENT_NAME_HASH};
|
|
use accounts::AccountProvider;
|
|
use client::{
|
|
traits::{EngineClient, ForceUpdateSealing},
|
|
BlockInfo, ChainInfo, ImportBlock,
|
|
};
|
|
use crypto::publickey::Secret;
|
|
use ethereum_types::Address;
|
|
use hash::keccak;
|
|
use miner::{self, MinerService};
|
|
use rustc_hex::FromHex;
|
|
use spec::Spec;
|
|
use std::sync::Arc;
|
|
use test_helpers::generate_dummy_client_with_spec;
|
|
use types::{
|
|
ids::BlockId,
|
|
transaction::{Action, Transaction, TypedTransaction},
|
|
};
|
|
use verification::queue::kind::blocks::Unverified;
|
|
|
|
#[test]
|
|
fn fetches_validators() {
|
|
let client = generate_dummy_client_with_spec(Spec::new_validator_safe_contract);
|
|
let addr: Address = "0000000000000000000000000000000000000005".parse().unwrap();
|
|
let vc = Arc::new(ValidatorSafeContract::new(addr, None));
|
|
vc.register_client(Arc::downgrade(&client) as _);
|
|
let last_hash = client.best_block_header().hash();
|
|
assert!(vc.contains(
|
|
&last_hash,
|
|
&"7d577a597b2742b498cb5cf0c26cdcd726d39e6e"
|
|
.parse::<Address>()
|
|
.unwrap()
|
|
));
|
|
assert!(vc.contains(
|
|
&last_hash,
|
|
&"82a978b3f5962a5b0957d9ee9eef472ee55b42f1"
|
|
.parse::<Address>()
|
|
.unwrap()
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn knows_validators() {
|
|
let tap = Arc::new(AccountProvider::transient_provider());
|
|
let s0: Secret = keccak("1").into();
|
|
let v0 = tap.insert_account(s0.clone(), &"".into()).unwrap();
|
|
let v1 = tap.insert_account(keccak("0").into(), &"".into()).unwrap();
|
|
let chain_id = Spec::new_validator_safe_contract().chain_id();
|
|
let client = generate_dummy_client_with_spec(Spec::new_validator_safe_contract);
|
|
client
|
|
.engine()
|
|
.register_client(Arc::downgrade(&client) as _);
|
|
let validator_contract = "0000000000000000000000000000000000000005"
|
|
.parse::<Address>()
|
|
.unwrap();
|
|
let signer = Box::new((tap.clone(), v1, "".into()));
|
|
|
|
client.miner().set_author(miner::Author::Sealer(signer));
|
|
// Remove "1" validator.
|
|
let tx = TypedTransaction::Legacy(Transaction {
|
|
nonce: 0.into(),
|
|
gas_price: 0.into(),
|
|
gas: 500_000.into(),
|
|
action: Action::Call(validator_contract),
|
|
value: 0.into(),
|
|
data: "bfc708a000000000000000000000000082a978b3f5962a5b0957d9ee9eef472ee55b42f1"
|
|
.from_hex()
|
|
.unwrap(),
|
|
})
|
|
.sign(&s0, Some(chain_id));
|
|
client
|
|
.miner()
|
|
.import_own_transaction(client.as_ref(), tx.into())
|
|
.unwrap();
|
|
EngineClient::update_sealing(&*client, ForceUpdateSealing::No);
|
|
assert_eq!(client.chain_info().best_block_number, 1);
|
|
// Add "1" validator back in.
|
|
let tx = TypedTransaction::Legacy(Transaction {
|
|
nonce: 1.into(),
|
|
gas_price: 0.into(),
|
|
gas: 500_000.into(),
|
|
action: Action::Call(validator_contract),
|
|
value: 0.into(),
|
|
data: "4d238c8e00000000000000000000000082a978b3f5962a5b0957d9ee9eef472ee55b42f1"
|
|
.from_hex()
|
|
.unwrap(),
|
|
})
|
|
.sign(&s0, Some(chain_id));
|
|
client
|
|
.miner()
|
|
.import_own_transaction(client.as_ref(), tx.into())
|
|
.unwrap();
|
|
EngineClient::update_sealing(&*client, ForceUpdateSealing::No);
|
|
// The transaction is not yet included so still unable to seal.
|
|
assert_eq!(client.chain_info().best_block_number, 1);
|
|
|
|
// Switch to the validator that is still there.
|
|
let signer = Box::new((tap.clone(), v0, "".into()));
|
|
client.miner().set_author(miner::Author::Sealer(signer));
|
|
EngineClient::update_sealing(&*client, ForceUpdateSealing::No);
|
|
assert_eq!(client.chain_info().best_block_number, 2);
|
|
// Switch back to the added validator, since the state is updated.
|
|
let signer = Box::new((tap.clone(), v1, "".into()));
|
|
client.miner().set_author(miner::Author::Sealer(signer));
|
|
let tx = TypedTransaction::Legacy(Transaction {
|
|
nonce: 2.into(),
|
|
gas_price: 0.into(),
|
|
gas: 21000.into(),
|
|
action: Action::Call(Address::default()),
|
|
value: 0.into(),
|
|
data: Vec::new(),
|
|
})
|
|
.sign(&s0, Some(chain_id));
|
|
client
|
|
.miner()
|
|
.import_own_transaction(client.as_ref(), tx.into())
|
|
.unwrap();
|
|
EngineClient::update_sealing(&*client, ForceUpdateSealing::No);
|
|
// Able to seal again.
|
|
assert_eq!(client.chain_info().best_block_number, 3);
|
|
|
|
// Check syncing.
|
|
let sync_client = generate_dummy_client_with_spec(Spec::new_validator_safe_contract);
|
|
sync_client
|
|
.engine()
|
|
.register_client(Arc::downgrade(&sync_client) as _);
|
|
for i in 1..4 {
|
|
sync_client
|
|
.import_block(
|
|
Unverified::from_rlp(client.block(BlockId::Number(i)).unwrap().into_inner())
|
|
.unwrap(),
|
|
)
|
|
.unwrap();
|
|
}
|
|
sync_client.flush_queue();
|
|
assert_eq!(sync_client.chain_info().best_block_number, 3);
|
|
}
|
|
|
|
#[test]
|
|
fn detects_bloom() {
|
|
use engines::EpochChange;
|
|
use machine::AuxiliaryRequest;
|
|
use types::{header::Header, log_entry::LogEntry};
|
|
|
|
let client = generate_dummy_client_with_spec(Spec::new_validator_safe_contract);
|
|
let engine = client.engine().clone();
|
|
let validator_contract = "0000000000000000000000000000000000000005"
|
|
.parse::<Address>()
|
|
.unwrap();
|
|
|
|
let last_hash = client.best_block_header().hash();
|
|
let mut new_header = Header::default();
|
|
new_header.set_parent_hash(last_hash);
|
|
new_header.set_number(1); // so the validator set looks for a log.
|
|
|
|
// first, try without the parent hash.
|
|
let mut event = LogEntry {
|
|
address: validator_contract,
|
|
topics: vec![*EVENT_NAME_HASH],
|
|
data: Vec::new(),
|
|
};
|
|
|
|
new_header.set_log_bloom(event.bloom());
|
|
match engine.signals_epoch_end(&new_header, Default::default()) {
|
|
EpochChange::No => {}
|
|
_ => panic!("Expected bloom to be unrecognized."),
|
|
};
|
|
|
|
// with the last hash, it should need the receipts.
|
|
event.topics.push(last_hash);
|
|
new_header.set_log_bloom(event.bloom());
|
|
|
|
match engine.signals_epoch_end(&new_header, Default::default()) {
|
|
EpochChange::Unsure(AuxiliaryRequest::Receipts) => {}
|
|
_ => panic!("Expected bloom to be recognized."),
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn initial_contract_is_signal() {
|
|
use engines::{EpochChange, Proof};
|
|
use types::header::Header;
|
|
|
|
let client = generate_dummy_client_with_spec(Spec::new_validator_safe_contract);
|
|
let engine = client.engine().clone();
|
|
|
|
let mut new_header = Header::default();
|
|
new_header.set_number(0); // so the validator set doesn't look for a log
|
|
|
|
match engine.signals_epoch_end(&new_header, Default::default()) {
|
|
EpochChange::Yes(Proof::WithState(_)) => {}
|
|
_ => panic!("Expected state to be required to prove initial signal"),
|
|
};
|
|
}
|
|
}
|