1184 lines
38 KiB
Rust
1184 lines
38 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/>.
|
|
|
|
//! Test client.
|
|
|
|
use std::{
|
|
collections::{BTreeMap, HashMap},
|
|
str::FromStr,
|
|
sync::{
|
|
atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrder},
|
|
Arc,
|
|
},
|
|
};
|
|
|
|
use blockchain::{BlockReceipts, TreeRoute};
|
|
use bytes::Bytes;
|
|
use crypto::publickey::{Generator, Random};
|
|
use db::{COL_STATE, NUM_COLUMNS};
|
|
use ethcore_miner::pool::VerifiedTransaction;
|
|
use ethereum_types::{Address, H256, U256};
|
|
use ethtrie;
|
|
use hash::keccak;
|
|
use itertools::Itertools;
|
|
use kvdb::DBValue;
|
|
use parking_lot::RwLock;
|
|
use rlp::RlpStream;
|
|
use rustc_hex::FromHex;
|
|
use types::{
|
|
basic_account::BasicAccount,
|
|
encoded,
|
|
filter::Filter,
|
|
header::Header,
|
|
log_entry::LocalizedLogEntry,
|
|
pruning_info::PruningInfo,
|
|
receipt::{LegacyReceipt, LocalizedReceipt, TransactionOutcome, TypedReceipt},
|
|
transaction::{
|
|
self, Action, LocalizedTransaction, SignedTransaction, Transaction, TypedTransaction,
|
|
TypedTxId,
|
|
},
|
|
view,
|
|
views::BlockView,
|
|
BlockNumber,
|
|
};
|
|
use vm::Schedule;
|
|
|
|
use block::{ClosedBlock, OpenBlock, SealedBlock};
|
|
use call_contract::{CallContract, RegistryInfo};
|
|
use client::{
|
|
traits::{ForceUpdateSealing, TransactionRequest},
|
|
AccountData, BadBlocks, Balance, BlockChain, BlockChainClient, BlockChainInfo, BlockId,
|
|
BlockInfo, BlockProducer, BlockStatus, BroadcastProposalBlock, Call, CallAnalytics, ChainInfo,
|
|
EngineInfo, ImportBlock, ImportSealedBlock, IoClient, LastHashes, Mode, Nonce,
|
|
PrepareOpenBlock, ProvingBlockChainClient, ReopenBlock, ScheduleInfo, SealedBlockImporter,
|
|
StateClient, StateOrBlock, TraceFilter, TraceId, TransactionId, TransactionInfo, UncleId,
|
|
};
|
|
use engines::EthEngine;
|
|
use error::{Error, EthcoreResult};
|
|
use executed::CallError;
|
|
use executive::Executed;
|
|
use journaldb;
|
|
use miner::{self, Miner, MinerService};
|
|
use spec::Spec;
|
|
use state::StateInfo;
|
|
use state_db::StateDB;
|
|
use stats::{PrometheusMetrics, PrometheusRegistry};
|
|
use trace::LocalizedTrace;
|
|
use verification::queue::{kind::blocks::Unverified, QueueInfo};
|
|
|
|
/// Test client.
|
|
pub struct TestBlockChainClient {
|
|
/// Blocks.
|
|
pub blocks: RwLock<HashMap<H256, Bytes>>,
|
|
/// Mapping of numbers to hashes.
|
|
pub numbers: RwLock<HashMap<usize, H256>>,
|
|
/// Genesis block hash.
|
|
pub genesis_hash: H256,
|
|
/// Last block hash.
|
|
pub last_hash: RwLock<H256>,
|
|
/// Extra data do set for each block
|
|
pub extra_data: Bytes,
|
|
/// Difficulty.
|
|
pub difficulty: RwLock<U256>,
|
|
/// Balances.
|
|
pub balances: RwLock<HashMap<Address, U256>>,
|
|
/// Nonces.
|
|
pub nonces: RwLock<HashMap<Address, U256>>,
|
|
/// Storage.
|
|
pub storage: RwLock<HashMap<(Address, H256), H256>>,
|
|
/// Code.
|
|
pub code: RwLock<HashMap<Address, Bytes>>,
|
|
/// Execution result.
|
|
pub execution_result: RwLock<Option<Result<Executed, CallError>>>,
|
|
/// Transaction receipts.
|
|
pub receipts: RwLock<HashMap<TransactionId, LocalizedReceipt>>,
|
|
/// Logs
|
|
pub logs: RwLock<Vec<LocalizedLogEntry>>,
|
|
/// Should return errors on logs.
|
|
pub error_on_logs: RwLock<Option<BlockId>>,
|
|
/// Block queue size.
|
|
pub queue_size: AtomicUsize,
|
|
/// Miner
|
|
pub miner: Arc<Miner>,
|
|
/// Spec
|
|
pub spec: Spec,
|
|
/// Timestamp assigned to latest sealed block
|
|
pub latest_block_timestamp: RwLock<u64>,
|
|
/// Ancient block info.
|
|
pub ancient_block: RwLock<Option<(H256, u64)>>,
|
|
/// First block info.
|
|
pub first_block: RwLock<Option<(H256, u64)>>,
|
|
/// Traces to return
|
|
pub traces: RwLock<Option<Vec<LocalizedTrace>>>,
|
|
/// Pruning history size to report.
|
|
pub history: RwLock<Option<u64>>,
|
|
/// Is disabled
|
|
pub disabled: AtomicBool,
|
|
}
|
|
|
|
/// Used for generating test client blocks.
|
|
#[derive(Clone, Copy)]
|
|
pub enum EachBlockWith {
|
|
/// Plain block.
|
|
Nothing,
|
|
/// Block with an uncle.
|
|
Uncle,
|
|
/// Block with a transaction.
|
|
Transaction,
|
|
/// Block with multiple transactions.
|
|
Transactions(usize),
|
|
/// Block with an uncle and transaction.
|
|
UncleAndTransaction,
|
|
}
|
|
|
|
impl Default for TestBlockChainClient {
|
|
fn default() -> Self {
|
|
TestBlockChainClient::new()
|
|
}
|
|
}
|
|
|
|
impl TestBlockChainClient {
|
|
/// Creates new test client.
|
|
pub fn new() -> Self {
|
|
Self::new_with_extra_data(Bytes::new())
|
|
}
|
|
|
|
/// Creates new test client with specified extra data for each block
|
|
pub fn new_with_extra_data(extra_data: Bytes) -> Self {
|
|
let spec = Spec::new_test();
|
|
TestBlockChainClient::new_with_spec_and_extra(spec, extra_data)
|
|
}
|
|
|
|
/// Create test client with custom spec.
|
|
pub fn new_with_spec(spec: Spec) -> Self {
|
|
TestBlockChainClient::new_with_spec_and_extra(spec, Bytes::new())
|
|
}
|
|
|
|
/// Create test client with custom spec and extra data.
|
|
pub fn new_with_spec_and_extra(spec: Spec, extra_data: Bytes) -> Self {
|
|
let genesis_block = spec.genesis_block();
|
|
let genesis_hash = spec.genesis_header().hash();
|
|
|
|
let mut client = TestBlockChainClient {
|
|
blocks: RwLock::new(HashMap::new()),
|
|
numbers: RwLock::new(HashMap::new()),
|
|
genesis_hash: H256::default(),
|
|
extra_data: extra_data,
|
|
last_hash: RwLock::new(H256::default()),
|
|
difficulty: RwLock::new(spec.genesis_header().difficulty().clone()),
|
|
balances: RwLock::new(HashMap::new()),
|
|
nonces: RwLock::new(HashMap::new()),
|
|
storage: RwLock::new(HashMap::new()),
|
|
code: RwLock::new(HashMap::new()),
|
|
execution_result: RwLock::new(None),
|
|
receipts: RwLock::new(HashMap::new()),
|
|
logs: RwLock::new(Vec::new()),
|
|
queue_size: AtomicUsize::new(0),
|
|
miner: Arc::new(Miner::new_for_tests(&spec, None)),
|
|
spec: spec,
|
|
latest_block_timestamp: RwLock::new(10_000_000),
|
|
ancient_block: RwLock::new(None),
|
|
first_block: RwLock::new(None),
|
|
traces: RwLock::new(None),
|
|
history: RwLock::new(None),
|
|
disabled: AtomicBool::new(false),
|
|
error_on_logs: RwLock::new(None),
|
|
};
|
|
|
|
// insert genesis hash.
|
|
client.blocks.get_mut().insert(genesis_hash, genesis_block);
|
|
client.numbers.get_mut().insert(0, genesis_hash);
|
|
*client.last_hash.get_mut() = genesis_hash;
|
|
client.genesis_hash = genesis_hash;
|
|
client
|
|
}
|
|
|
|
/// Set the transaction receipt result
|
|
pub fn set_transaction_receipt(&self, id: TransactionId, receipt: LocalizedReceipt) {
|
|
self.receipts.write().insert(id, receipt);
|
|
}
|
|
|
|
/// Set the execution result.
|
|
pub fn set_execution_result(&self, result: Result<Executed, CallError>) {
|
|
*self.execution_result.write() = Some(result);
|
|
}
|
|
|
|
/// Set the balance of account `address` to `balance`.
|
|
pub fn set_balance(&self, address: Address, balance: U256) {
|
|
self.balances.write().insert(address, balance);
|
|
}
|
|
|
|
/// Set nonce of account `address` to `nonce`.
|
|
pub fn set_nonce(&self, address: Address, nonce: U256) {
|
|
self.nonces.write().insert(address, nonce);
|
|
}
|
|
|
|
/// Set `code` at `address`.
|
|
pub fn set_code(&self, address: Address, code: Bytes) {
|
|
self.code.write().insert(address, code);
|
|
}
|
|
|
|
/// Set storage `position` to `value` for account `address`.
|
|
pub fn set_storage(&self, address: Address, position: H256, value: H256) {
|
|
self.storage.write().insert((address, position), value);
|
|
}
|
|
|
|
/// Set block queue size for testing
|
|
pub fn set_queue_size(&self, size: usize) {
|
|
self.queue_size.store(size, AtomicOrder::SeqCst);
|
|
}
|
|
|
|
/// Set timestamp assigned to latest sealed block
|
|
pub fn set_latest_block_timestamp(&self, ts: u64) {
|
|
*self.latest_block_timestamp.write() = ts;
|
|
}
|
|
|
|
/// Set logs to return for each logs call.
|
|
pub fn set_logs(&self, logs: Vec<LocalizedLogEntry>) {
|
|
*self.logs.write() = logs;
|
|
}
|
|
|
|
/// Set return errors on logs.
|
|
pub fn set_error_on_logs(&self, val: Option<BlockId>) {
|
|
*self.error_on_logs.write() = val;
|
|
}
|
|
|
|
/// Add a block to test client.
|
|
pub fn add_block<F>(&self, with: EachBlockWith, hook: F)
|
|
where
|
|
F: Fn(Header) -> Header,
|
|
{
|
|
let n = self.numbers.read().len();
|
|
|
|
let mut header = Header::new();
|
|
header.set_difficulty(From::from(n));
|
|
header.set_parent_hash(self.last_hash.read().clone());
|
|
header.set_number(n as BlockNumber);
|
|
header.set_gas_limit(U256::from(1_000_000));
|
|
header.set_extra_data(self.extra_data.clone());
|
|
|
|
header = hook(header);
|
|
|
|
let uncles = match with {
|
|
EachBlockWith::Uncle | EachBlockWith::UncleAndTransaction => {
|
|
let mut uncles = RlpStream::new_list(1);
|
|
let mut uncle_header = Header::new();
|
|
uncle_header.set_difficulty(From::from(n));
|
|
uncle_header.set_parent_hash(self.last_hash.read().clone());
|
|
uncle_header.set_number(n as BlockNumber);
|
|
uncles.append(&uncle_header);
|
|
header.set_uncles_hash(keccak(uncles.as_raw()));
|
|
uncles
|
|
}
|
|
_ => RlpStream::new_list(0),
|
|
};
|
|
let txs = match with {
|
|
EachBlockWith::Transaction
|
|
| EachBlockWith::UncleAndTransaction
|
|
| EachBlockWith::Transactions(_) => {
|
|
let num_transactions = match with {
|
|
EachBlockWith::Transactions(num) => num,
|
|
_ => 1,
|
|
};
|
|
let mut txs = RlpStream::new_list(num_transactions);
|
|
let keypair = Random.generate();
|
|
let mut nonce = U256::zero();
|
|
|
|
for _ in 0..num_transactions {
|
|
// Update nonces value
|
|
let tx = TypedTransaction::Legacy(Transaction {
|
|
action: Action::Create,
|
|
value: U256::from(100),
|
|
data: "3331600055".from_hex().unwrap(),
|
|
gas: U256::from(100_000),
|
|
gas_price: U256::from(200_000_000_000u64),
|
|
nonce: nonce,
|
|
});
|
|
let signed_tx = tx.sign(keypair.secret(), None);
|
|
signed_tx.rlp_append(&mut txs);
|
|
nonce += U256::one();
|
|
}
|
|
|
|
self.nonces.write().insert(keypair.address(), nonce);
|
|
txs.out()
|
|
}
|
|
_ => ::rlp::EMPTY_LIST_RLP.to_vec(),
|
|
};
|
|
|
|
let mut rlp = RlpStream::new_list(3);
|
|
rlp.append(&header);
|
|
rlp.append_raw(&txs, 1);
|
|
rlp.append_raw(uncles.as_raw(), 1);
|
|
let unverified = Unverified::from_rlp(rlp.out(), BlockNumber::max_value()).unwrap();
|
|
self.import_block(unverified).unwrap();
|
|
}
|
|
|
|
/// Add a sequence of blocks to test client.
|
|
pub fn add_blocks(&self, count: usize, with: EachBlockWith) {
|
|
for _ in 0..count {
|
|
self.add_block(with, |header| header);
|
|
}
|
|
}
|
|
|
|
/// Make a bad block by setting invalid parent hash.
|
|
pub fn corrupt_block_parent(&self, n: BlockNumber) {
|
|
let hash = self.block_hash(BlockId::Number(n)).unwrap();
|
|
let mut header: Header = self
|
|
.block_header(BlockId::Number(n))
|
|
.unwrap()
|
|
.decode(BlockNumber::max_value())
|
|
.expect("decoding failed");
|
|
header.set_parent_hash(H256::from_low_u64_be(42));
|
|
let mut rlp = RlpStream::new_list(3);
|
|
rlp.append(&header);
|
|
rlp.append_raw(&::rlp::NULL_RLP, 1);
|
|
rlp.append_raw(&::rlp::NULL_RLP, 1);
|
|
self.blocks.write().insert(hash, rlp.out());
|
|
}
|
|
|
|
/// Get block hash with `delta` as offset from the most recent blocks.
|
|
pub fn block_hash_delta_minus(&mut self, delta: usize) -> H256 {
|
|
let blocks_read = self.numbers.read();
|
|
let index = blocks_read.len() - delta;
|
|
blocks_read[&index].clone()
|
|
}
|
|
|
|
fn block_hash(&self, id: BlockId) -> Option<H256> {
|
|
match id {
|
|
BlockId::Hash(hash) => Some(hash),
|
|
BlockId::Number(n) => self.numbers.read().get(&(n as usize)).cloned(),
|
|
BlockId::Earliest => self.numbers.read().get(&0).cloned(),
|
|
BlockId::Latest => self
|
|
.numbers
|
|
.read()
|
|
.get(&(self.numbers.read().len() - 1))
|
|
.cloned(),
|
|
}
|
|
}
|
|
|
|
/// Inserts a transaction with given gas price to miners transactions queue.
|
|
pub fn insert_transaction_with_gas_price_to_queue(&self, gas_price: U256) -> H256 {
|
|
let keypair = Random.generate();
|
|
let tx = TypedTransaction::Legacy(Transaction {
|
|
action: Action::Create,
|
|
value: U256::from(100),
|
|
data: "3331600055".from_hex().unwrap(),
|
|
gas: U256::from(100_000),
|
|
gas_price: gas_price,
|
|
nonce: U256::zero(),
|
|
});
|
|
let signed_tx = tx.sign(keypair.secret(), None);
|
|
self.set_balance(signed_tx.sender(), 10_000_000_000_000_000_000u64.into());
|
|
let hash = signed_tx.hash();
|
|
let res = self
|
|
.miner
|
|
.import_external_transactions(self, vec![signed_tx.into()]);
|
|
let res = res.into_iter().next().unwrap();
|
|
assert!(res.is_ok());
|
|
hash
|
|
}
|
|
|
|
/// Inserts a transaction to miners transactions queue.
|
|
pub fn insert_transaction_to_queue(&self) -> H256 {
|
|
self.insert_transaction_with_gas_price_to_queue(U256::from(20_000_000_000u64))
|
|
}
|
|
|
|
/// Set reported history size.
|
|
pub fn set_history(&self, h: Option<u64>) {
|
|
*self.history.write() = h;
|
|
}
|
|
|
|
/// Returns true if the client has been disabled.
|
|
pub fn is_disabled(&self) -> bool {
|
|
self.disabled.load(AtomicOrder::SeqCst)
|
|
}
|
|
}
|
|
|
|
/// Get temporary db state1
|
|
pub fn get_temp_state_db() -> StateDB {
|
|
let db = ethcore_db::InMemoryWithMetrics::create(NUM_COLUMNS.unwrap_or(0));
|
|
let journal_db = journaldb::new(Arc::new(db), journaldb::Algorithm::EarlyMerge, COL_STATE);
|
|
StateDB::new(journal_db, 1024 * 1024)
|
|
}
|
|
|
|
impl ReopenBlock for TestBlockChainClient {
|
|
fn reopen_block(&self, block: ClosedBlock) -> OpenBlock {
|
|
block.reopen(&*self.spec.engine)
|
|
}
|
|
}
|
|
|
|
impl PrepareOpenBlock for TestBlockChainClient {
|
|
fn prepare_open_block(
|
|
&self,
|
|
author: Address,
|
|
gas_range_target: (U256, U256),
|
|
extra_data: Bytes,
|
|
) -> Result<OpenBlock, Error> {
|
|
let engine = &*self.spec.engine;
|
|
let genesis_header = self.spec.genesis_header();
|
|
let db = self
|
|
.spec
|
|
.ensure_db_good(get_temp_state_db(), &Default::default())
|
|
.unwrap();
|
|
|
|
let last_hashes = vec![genesis_header.hash()];
|
|
let mut open_block = OpenBlock::new(
|
|
engine,
|
|
Default::default(),
|
|
false,
|
|
db,
|
|
&genesis_header,
|
|
Arc::new(last_hashes),
|
|
author,
|
|
gas_range_target,
|
|
extra_data,
|
|
false,
|
|
None,
|
|
)?;
|
|
// TODO [todr] Override timestamp for predictability
|
|
open_block.set_timestamp(*self.latest_block_timestamp.read());
|
|
Ok(open_block)
|
|
}
|
|
}
|
|
|
|
impl ScheduleInfo for TestBlockChainClient {
|
|
fn latest_schedule(&self) -> Schedule {
|
|
Schedule::new_post_eip150(24576, true, true, true)
|
|
}
|
|
}
|
|
|
|
impl ImportSealedBlock for TestBlockChainClient {
|
|
fn import_sealed_block(&self, _block: SealedBlock) -> EthcoreResult<H256> {
|
|
Ok(H256::default())
|
|
}
|
|
}
|
|
|
|
impl BlockProducer for TestBlockChainClient {}
|
|
|
|
impl BroadcastProposalBlock for TestBlockChainClient {
|
|
fn broadcast_proposal_block(&self, _block: SealedBlock) {}
|
|
}
|
|
|
|
impl SealedBlockImporter for TestBlockChainClient {}
|
|
|
|
impl ::miner::TransactionVerifierClient for TestBlockChainClient {}
|
|
impl ::miner::BlockChainClient for TestBlockChainClient {}
|
|
|
|
impl Nonce for TestBlockChainClient {
|
|
fn nonce(&self, address: &Address, id: BlockId) -> Option<U256> {
|
|
match id {
|
|
BlockId::Latest => Some(
|
|
self.nonces
|
|
.read()
|
|
.get(address)
|
|
.cloned()
|
|
.unwrap_or(self.spec.params().account_start_nonce),
|
|
),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn latest_nonce(&self, address: &Address) -> U256 {
|
|
self.nonce(address, BlockId::Latest).unwrap()
|
|
}
|
|
}
|
|
|
|
impl Balance for TestBlockChainClient {
|
|
fn balance(&self, address: &Address, state: StateOrBlock) -> Option<U256> {
|
|
match state {
|
|
StateOrBlock::Block(BlockId::Latest) | StateOrBlock::State(_) => Some(
|
|
self.balances
|
|
.read()
|
|
.get(address)
|
|
.cloned()
|
|
.unwrap_or_else(U256::zero),
|
|
),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn latest_balance(&self, address: &Address) -> U256 {
|
|
self.balance(address, BlockId::Latest.into()).unwrap()
|
|
}
|
|
}
|
|
|
|
impl AccountData for TestBlockChainClient {}
|
|
|
|
impl ChainInfo for TestBlockChainClient {
|
|
fn chain_info(&self) -> BlockChainInfo {
|
|
let number = self.blocks.read().len() as BlockNumber - 1;
|
|
BlockChainInfo {
|
|
total_difficulty: *self.difficulty.read(),
|
|
pending_total_difficulty: *self.difficulty.read(),
|
|
genesis_hash: self.genesis_hash.clone(),
|
|
best_block_hash: self.last_hash.read().clone(),
|
|
best_block_number: number,
|
|
best_block_timestamp: number,
|
|
first_block_hash: self.first_block.read().as_ref().map(|x| x.0),
|
|
first_block_number: self.first_block.read().as_ref().map(|x| x.1),
|
|
ancient_block_hash: self.ancient_block.read().as_ref().map(|x| x.0),
|
|
ancient_block_number: self.ancient_block.read().as_ref().map(|x| x.1),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl BlockInfo for TestBlockChainClient {
|
|
fn block_header(&self, id: BlockId) -> Option<encoded::Header> {
|
|
self.block_hash(id)
|
|
.and_then(|hash| {
|
|
self.blocks
|
|
.read()
|
|
.get(&hash)
|
|
.map(|r| view!(BlockView, r).header_rlp().as_raw().to_vec())
|
|
})
|
|
.map(encoded::Header::new)
|
|
}
|
|
|
|
fn best_block_header(&self) -> Header {
|
|
self.block_header(BlockId::Hash(self.chain_info().best_block_hash))
|
|
.expect("Best block always has header.")
|
|
.decode(BlockNumber::max_value())
|
|
.expect("decoding failed")
|
|
}
|
|
|
|
fn block(&self, id: BlockId) -> Option<encoded::Block> {
|
|
self.block_hash(id)
|
|
.and_then(|hash| self.blocks.read().get(&hash).cloned())
|
|
.map(encoded::Block::new)
|
|
}
|
|
|
|
fn code_hash(&self, address: &Address, id: BlockId) -> Option<H256> {
|
|
match id {
|
|
BlockId::Latest => self.code.read().get(address).map(|c| keccak(&c)),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl CallContract for TestBlockChainClient {
|
|
fn call_contract(
|
|
&self,
|
|
_id: BlockId,
|
|
_address: Address,
|
|
_data: Bytes,
|
|
) -> Result<Bytes, String> {
|
|
Ok(vec![])
|
|
}
|
|
}
|
|
|
|
impl TransactionInfo for TestBlockChainClient {
|
|
fn transaction_block(&self, _id: TransactionId) -> Option<H256> {
|
|
None // Simple default.
|
|
}
|
|
}
|
|
|
|
impl BlockChain for TestBlockChainClient {}
|
|
|
|
impl RegistryInfo for TestBlockChainClient {
|
|
fn registry_address(&self, _name: String, _block: BlockId) -> Option<Address> {
|
|
None
|
|
}
|
|
}
|
|
|
|
impl ImportBlock for TestBlockChainClient {
|
|
fn import_block(&self, unverified: Unverified) -> EthcoreResult<H256> {
|
|
let header = unverified.header;
|
|
let h = header.hash();
|
|
let number: usize = header.number() as usize;
|
|
if number > self.blocks.read().len() {
|
|
panic!(
|
|
"Unexpected block number. Expected {}, got {}",
|
|
self.blocks.read().len(),
|
|
number
|
|
);
|
|
}
|
|
if number > 0 {
|
|
match self.blocks.read().get(header.parent_hash()) {
|
|
Some(parent) => {
|
|
let parent = view!(BlockView, parent).header(BlockNumber::max_value());
|
|
if parent.number() != (header.number() - 1) {
|
|
panic!("Unexpected block parent");
|
|
}
|
|
}
|
|
None => {
|
|
panic!(
|
|
"Unknown block parent {:?} for block {}",
|
|
header.parent_hash(),
|
|
number
|
|
);
|
|
}
|
|
}
|
|
}
|
|
let len = self.numbers.read().len();
|
|
if number == len {
|
|
{
|
|
let mut difficulty = self.difficulty.write();
|
|
*difficulty = *difficulty + header.difficulty().clone();
|
|
}
|
|
*self.last_hash.write() = h.clone();
|
|
self.blocks.write().insert(h.clone(), unverified.bytes);
|
|
self.numbers.write().insert(number, h.clone());
|
|
let mut parent_hash = header.parent_hash().clone();
|
|
if number > 0 {
|
|
let mut n = number - 1;
|
|
while n > 0 && self.numbers.read()[&n] != parent_hash {
|
|
*self.numbers.write().get_mut(&n).unwrap() = parent_hash.clone();
|
|
n -= 1;
|
|
parent_hash = view!(BlockView, &self.blocks.read()[&parent_hash])
|
|
.header(BlockNumber::max_value())
|
|
.parent_hash()
|
|
.clone();
|
|
}
|
|
}
|
|
} else {
|
|
self.blocks.write().insert(h.clone(), unverified.bytes);
|
|
}
|
|
Ok(h)
|
|
}
|
|
}
|
|
|
|
impl Call for TestBlockChainClient {
|
|
// State will not be used by test client anyway, since all methods that accept state are mocked
|
|
type State = TestState;
|
|
|
|
fn call(
|
|
&self,
|
|
_t: &SignedTransaction,
|
|
_analytics: CallAnalytics,
|
|
_state: &mut Self::State,
|
|
_header: &Header,
|
|
) -> Result<Executed, CallError> {
|
|
self.execution_result.read().clone().unwrap()
|
|
}
|
|
|
|
fn call_many(
|
|
&self,
|
|
txs: &[(SignedTransaction, CallAnalytics)],
|
|
state: &mut Self::State,
|
|
header: &Header,
|
|
) -> Result<Vec<Executed>, CallError> {
|
|
let mut res = Vec::with_capacity(txs.len());
|
|
for &(ref tx, analytics) in txs {
|
|
res.push(self.call(tx, analytics, state, header)?);
|
|
}
|
|
Ok(res)
|
|
}
|
|
|
|
fn estimate_gas(
|
|
&self,
|
|
_t: &SignedTransaction,
|
|
_state: &Self::State,
|
|
_header: &Header,
|
|
) -> Result<U256, CallError> {
|
|
Ok(21000.into())
|
|
}
|
|
}
|
|
|
|
/// NewType wrapper around `()` to impersonate `State` in trait impls. State will not be used by
|
|
/// test client, since all methods that accept state are mocked.
|
|
pub struct TestState;
|
|
impl StateInfo for TestState {
|
|
fn nonce(&self, _address: &Address) -> ethtrie::Result<U256> {
|
|
unimplemented!()
|
|
}
|
|
fn balance(&self, _address: &Address) -> ethtrie::Result<U256> {
|
|
unimplemented!()
|
|
}
|
|
fn storage_at(&self, _address: &Address, _key: &H256) -> ethtrie::Result<H256> {
|
|
unimplemented!()
|
|
}
|
|
fn code(&self, _address: &Address) -> ethtrie::Result<Option<Arc<Bytes>>> {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
|
|
impl StateClient for TestBlockChainClient {
|
|
// State will not be used by test client anyway, since all methods that accept state are mocked
|
|
type State = TestState;
|
|
|
|
fn latest_state_and_header(&self) -> (Self::State, Header) {
|
|
(TestState, self.best_block_header())
|
|
}
|
|
|
|
fn state_at(&self, _id: BlockId) -> Option<Self::State> {
|
|
Some(TestState)
|
|
}
|
|
}
|
|
|
|
impl EngineInfo for TestBlockChainClient {
|
|
fn engine(&self) -> &dyn EthEngine {
|
|
&*self.spec.engine
|
|
}
|
|
}
|
|
|
|
impl BadBlocks for TestBlockChainClient {
|
|
fn bad_blocks(&self) -> Vec<(Unverified, String)> {
|
|
vec![(
|
|
Unverified {
|
|
header: Default::default(),
|
|
transactions: vec![],
|
|
uncles: vec![],
|
|
bytes: vec![1, 2, 3],
|
|
},
|
|
"Invalid block".into(),
|
|
)]
|
|
}
|
|
}
|
|
|
|
impl BlockChainClient for TestBlockChainClient {
|
|
fn replay(&self, _id: TransactionId, _analytics: CallAnalytics) -> Result<Executed, CallError> {
|
|
self.execution_result.read().clone().unwrap()
|
|
}
|
|
|
|
fn replay_block_transactions(
|
|
&self,
|
|
_block: BlockId,
|
|
_analytics: CallAnalytics,
|
|
) -> Result<Box<dyn Iterator<Item = (H256, Executed)>>, CallError> {
|
|
Ok(Box::new(
|
|
self.traces
|
|
.read()
|
|
.clone()
|
|
.unwrap()
|
|
.into_iter()
|
|
.map(|t| t.transaction_hash.unwrap_or(H256::default()))
|
|
.zip(self.execution_result.read().clone().unwrap().into_iter()),
|
|
))
|
|
}
|
|
|
|
fn block_total_difficulty(&self, _id: BlockId) -> Option<U256> {
|
|
Some(U256::zero())
|
|
}
|
|
|
|
fn block_hash(&self, id: BlockId) -> Option<H256> {
|
|
Self::block_hash(self, id)
|
|
}
|
|
|
|
fn storage_root(&self, _address: &Address, _id: BlockId) -> Option<H256> {
|
|
None
|
|
}
|
|
|
|
fn code(&self, address: &Address, state: StateOrBlock) -> Option<Option<Bytes>> {
|
|
match state {
|
|
StateOrBlock::Block(BlockId::Latest) => Some(self.code.read().get(address).cloned()),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn storage_at(&self, address: &Address, position: &H256, state: StateOrBlock) -> Option<H256> {
|
|
match state {
|
|
StateOrBlock::Block(BlockId::Latest) => Some(
|
|
self.storage
|
|
.read()
|
|
.get(&(address.clone(), position.clone()))
|
|
.cloned()
|
|
.unwrap_or_else(H256::default),
|
|
),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn list_accounts(
|
|
&self,
|
|
_id: BlockId,
|
|
_after: Option<&Address>,
|
|
_count: u64,
|
|
) -> Option<Vec<Address>> {
|
|
None
|
|
}
|
|
|
|
fn list_storage(
|
|
&self,
|
|
_id: BlockId,
|
|
_account: &Address,
|
|
_after: Option<&H256>,
|
|
_count: u64,
|
|
) -> Option<Vec<H256>> {
|
|
None
|
|
}
|
|
fn block_transaction(&self, _id: TransactionId) -> Option<LocalizedTransaction> {
|
|
None // Simple default.
|
|
}
|
|
fn queued_transaction(&self, _hash: H256) -> Option<Arc<VerifiedTransaction>> {
|
|
None
|
|
}
|
|
|
|
fn uncle(&self, _id: UncleId) -> Option<encoded::Header> {
|
|
None // Simple default.
|
|
}
|
|
|
|
fn uncle_extra_info(&self, _id: UncleId) -> Option<BTreeMap<String, String>> {
|
|
None
|
|
}
|
|
|
|
fn transaction_receipt(&self, id: TransactionId) -> Option<LocalizedReceipt> {
|
|
self.receipts.read().get(&id).cloned()
|
|
}
|
|
|
|
fn localized_block_receipts(&self, _id: BlockId) -> Option<Vec<LocalizedReceipt>> {
|
|
Some(self.receipts.read().values().cloned().collect())
|
|
}
|
|
|
|
fn logs(&self, filter: Filter) -> Result<Vec<LocalizedLogEntry>, BlockId> {
|
|
match self.error_on_logs.read().as_ref() {
|
|
Some(id) => return Err(id.clone()),
|
|
None => (),
|
|
}
|
|
|
|
let mut logs = self.logs.read().clone();
|
|
let len = logs.len();
|
|
Ok(match filter.limit {
|
|
Some(limit) if limit <= len => logs.split_off(len - limit),
|
|
_ => logs,
|
|
})
|
|
}
|
|
|
|
fn last_hashes(&self) -> LastHashes {
|
|
unimplemented!();
|
|
}
|
|
|
|
fn is_canon(&self, _hash: &H256) -> bool {
|
|
unimplemented!()
|
|
}
|
|
|
|
fn block_number(&self, id: BlockId) -> Option<BlockNumber> {
|
|
match id {
|
|
BlockId::Number(number) => Some(number),
|
|
BlockId::Earliest => Some(0),
|
|
BlockId::Latest => Some(self.chain_info().best_block_number),
|
|
BlockId::Hash(ref h) => self
|
|
.numbers
|
|
.read()
|
|
.iter()
|
|
.find(|&(_, hash)| hash == h)
|
|
.map(|e| *e.0 as u64),
|
|
}
|
|
}
|
|
|
|
fn block_body(&self, id: BlockId) -> Option<encoded::Body> {
|
|
self.block_hash(id).and_then(|hash| {
|
|
self.blocks.read().get(&hash).map(|r| {
|
|
let block = view!(BlockView, r);
|
|
let mut stream = RlpStream::new_list(2);
|
|
stream.append_raw(block.transactions_rlp().as_raw(), 1);
|
|
stream.append_raw(block.uncles_rlp().as_raw(), 1);
|
|
encoded::Body::new(stream.out())
|
|
})
|
|
})
|
|
}
|
|
|
|
fn block_extra_info(&self, id: BlockId) -> Option<BTreeMap<String, String>> {
|
|
self.block(id)
|
|
.map(|block| block.view().header(BlockNumber::max_value()))
|
|
.map(|header| self.spec.engine.extra_info(&header))
|
|
}
|
|
|
|
fn block_status(&self, id: BlockId) -> BlockStatus {
|
|
match id {
|
|
BlockId::Number(number) if (number as usize) < self.blocks.read().len() => {
|
|
BlockStatus::InChain
|
|
}
|
|
BlockId::Hash(ref hash) if self.blocks.read().get(hash).is_some() => {
|
|
BlockStatus::InChain
|
|
}
|
|
BlockId::Latest | BlockId::Earliest => BlockStatus::InChain,
|
|
_ => BlockStatus::Unknown,
|
|
}
|
|
}
|
|
|
|
fn is_processing_fork(&self) -> bool {
|
|
false
|
|
}
|
|
|
|
// works only if blocks are one after another 1 -> 2 -> 3
|
|
fn tree_route(&self, from: &H256, to: &H256) -> Option<TreeRoute> {
|
|
Some(TreeRoute {
|
|
ancestor: H256::default(),
|
|
index: 0,
|
|
blocks: {
|
|
let numbers_read = self.numbers.read();
|
|
let mut adding = false;
|
|
|
|
let mut blocks = Vec::new();
|
|
for (_, hash) in numbers_read
|
|
.iter()
|
|
.sorted_by(|tuple1, tuple2| tuple1.0.cmp(tuple2.0))
|
|
{
|
|
if hash == to {
|
|
if adding {
|
|
blocks.push(hash.clone());
|
|
}
|
|
adding = false;
|
|
break;
|
|
}
|
|
if hash == from {
|
|
adding = true;
|
|
}
|
|
if adding {
|
|
blocks.push(hash.clone());
|
|
}
|
|
}
|
|
if adding {
|
|
Vec::new()
|
|
} else {
|
|
blocks
|
|
}
|
|
},
|
|
is_from_route_finalized: false,
|
|
})
|
|
}
|
|
|
|
fn find_uncles(&self, _hash: &H256) -> Option<Vec<H256>> {
|
|
None
|
|
}
|
|
|
|
fn block_receipts(&self, hash: &H256) -> Option<BlockReceipts> {
|
|
// starts with 'f' ?
|
|
if *hash
|
|
> H256::from_str("f000000000000000000000000000000000000000000000000000000000000000")
|
|
.unwrap()
|
|
{
|
|
let receipt = BlockReceipts::new(vec![TypedReceipt::new(
|
|
TypedTxId::Legacy,
|
|
LegacyReceipt::new(
|
|
TransactionOutcome::StateRoot(H256::zero()),
|
|
U256::zero(),
|
|
vec![],
|
|
),
|
|
)]);
|
|
return Some(receipt);
|
|
}
|
|
None
|
|
}
|
|
|
|
fn queue_info(&self) -> QueueInfo {
|
|
QueueInfo {
|
|
verified_queue_size: self.queue_size.load(AtomicOrder::SeqCst),
|
|
unverified_queue_size: 0,
|
|
verifying_queue_size: 0,
|
|
max_queue_size: 0,
|
|
max_mem_use: 0,
|
|
mem_used: 0,
|
|
}
|
|
}
|
|
|
|
fn clear_queue(&self) {}
|
|
|
|
fn additional_params(&self) -> BTreeMap<String, String> {
|
|
Default::default()
|
|
}
|
|
|
|
fn filter_traces(&self, _filter: TraceFilter) -> Option<Vec<LocalizedTrace>> {
|
|
self.traces.read().clone()
|
|
}
|
|
|
|
fn trace(&self, _trace: TraceId) -> Option<LocalizedTrace> {
|
|
self.traces
|
|
.read()
|
|
.clone()
|
|
.and_then(|vec| vec.into_iter().next())
|
|
}
|
|
|
|
fn transaction_traces(&self, _trace: TransactionId) -> Option<Vec<LocalizedTrace>> {
|
|
self.traces.read().clone()
|
|
}
|
|
|
|
fn block_traces(&self, _trace: BlockId) -> Option<Vec<LocalizedTrace>> {
|
|
self.traces.read().clone()
|
|
}
|
|
|
|
fn transactions_to_propagate(&self) -> Vec<Arc<VerifiedTransaction>> {
|
|
self.miner
|
|
.ready_transactions(self, 4096, miner::PendingOrdering::Priority)
|
|
}
|
|
|
|
fn signing_chain_id(&self) -> Option<u64> {
|
|
None
|
|
}
|
|
|
|
fn mode(&self) -> Mode {
|
|
Mode::Active
|
|
}
|
|
|
|
fn set_mode(&self, _: Mode) {
|
|
unimplemented!();
|
|
}
|
|
|
|
fn spec_name(&self) -> String {
|
|
"foundation".into()
|
|
}
|
|
|
|
fn set_spec_name(&self, _: String) -> Result<(), ()> {
|
|
unimplemented!();
|
|
}
|
|
|
|
fn disable(&self) {
|
|
self.disabled.store(true, AtomicOrder::SeqCst);
|
|
}
|
|
|
|
fn pruning_info(&self) -> PruningInfo {
|
|
let best_num = self.chain_info().best_block_number;
|
|
PruningInfo {
|
|
earliest_chain: 1,
|
|
earliest_state: self
|
|
.history
|
|
.read()
|
|
.as_ref()
|
|
.map(|x| best_num - x)
|
|
.unwrap_or(0),
|
|
}
|
|
}
|
|
|
|
fn create_transaction(
|
|
&self,
|
|
TransactionRequest {
|
|
action,
|
|
data,
|
|
gas,
|
|
gas_price,
|
|
nonce,
|
|
}: TransactionRequest,
|
|
) -> Result<SignedTransaction, transaction::Error> {
|
|
let transaction = TypedTransaction::Legacy(Transaction {
|
|
nonce: nonce
|
|
.unwrap_or_else(|| self.latest_nonce(&self.miner.authoring_params().author)),
|
|
action,
|
|
gas: gas.unwrap_or(self.spec.gas_limit),
|
|
gas_price: gas_price.unwrap_or_else(U256::zero),
|
|
value: U256::default(),
|
|
data: data,
|
|
});
|
|
let chain_id = Some(self.spec.chain_id());
|
|
let sig = self
|
|
.spec
|
|
.engine
|
|
.sign(transaction.signature_hash(chain_id))
|
|
.unwrap();
|
|
Ok(SignedTransaction::new(transaction.with_signature(sig, chain_id)).unwrap())
|
|
}
|
|
|
|
fn transact(&self, tx_request: TransactionRequest) -> Result<(), transaction::Error> {
|
|
let signed = self.create_transaction(tx_request)?;
|
|
self.miner.import_own_transaction(self, signed.into())
|
|
}
|
|
|
|
fn registrar_address(&self) -> Option<Address> {
|
|
None
|
|
}
|
|
|
|
fn state_data(&self, hash: &H256) -> Option<Bytes> {
|
|
let begins_with_f =
|
|
H256::from_str("f000000000000000000000000000000000000000000000000000000000000000")
|
|
.unwrap();
|
|
if *hash > begins_with_f {
|
|
let mut rlp = RlpStream::new();
|
|
rlp.append(&hash.clone());
|
|
return Some(rlp.out());
|
|
} else if *hash
|
|
== H256::from_str("000000000000000000000000000000000000000000000000000000000000000a")
|
|
.unwrap()
|
|
{
|
|
// for basic `return_node_data` tests
|
|
return Some(vec![0xaa, 0xaa]);
|
|
} else if *hash
|
|
== H256::from_str("000000000000000000000000000000000000000000000000000000000000000c")
|
|
.unwrap()
|
|
{
|
|
return Some(vec![0xcc]);
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
impl IoClient for TestBlockChainClient {
|
|
fn queue_transactions(&self, transactions: Vec<Bytes>, _peer_id: usize) {
|
|
// import right here
|
|
let txs = transactions
|
|
.into_iter()
|
|
.filter_map(|bytes| TypedTransaction::decode(&bytes).ok())
|
|
.collect();
|
|
self.miner.import_external_transactions(self, txs);
|
|
}
|
|
|
|
fn ancient_block_queue_fullness(&self) -> f32 {
|
|
0.0
|
|
}
|
|
|
|
fn queue_ancient_block(&self, unverified: Unverified, _r: Bytes) -> EthcoreResult<H256> {
|
|
self.import_block(unverified)
|
|
}
|
|
|
|
fn queue_consensus_message(&self, message: Bytes) {
|
|
self.spec.engine.handle_message(&message).unwrap();
|
|
}
|
|
}
|
|
|
|
impl ProvingBlockChainClient for TestBlockChainClient {
|
|
fn prove_storage(&self, _: H256, _: H256, _: BlockId) -> Option<(Vec<Bytes>, H256)> {
|
|
None
|
|
}
|
|
|
|
fn prove_account(&self, _: H256, _: BlockId) -> Option<(Vec<Bytes>, BasicAccount)> {
|
|
None
|
|
}
|
|
|
|
fn prove_transaction(&self, _: SignedTransaction, _: BlockId) -> Option<(Bytes, Vec<DBValue>)> {
|
|
None
|
|
}
|
|
|
|
fn epoch_signal(&self, _: H256) -> Option<Vec<u8>> {
|
|
None
|
|
}
|
|
}
|
|
|
|
impl super::traits::EngineClient for TestBlockChainClient {
|
|
fn update_sealing(&self, force: ForceUpdateSealing) {
|
|
self.miner.update_sealing(self, force)
|
|
}
|
|
|
|
fn submit_seal(&self, block_hash: H256, seal: Vec<Bytes>) {
|
|
let import = self
|
|
.miner
|
|
.submit_seal(block_hash, seal)
|
|
.and_then(|block| self.import_sealed_block(block));
|
|
if let Err(err) = import {
|
|
warn!(target: "poa", "Wrong internal seal submission! {:?}", err);
|
|
}
|
|
}
|
|
|
|
fn broadcast_consensus_message(&self, _message: Bytes) {}
|
|
|
|
fn epoch_transition_for(&self, _block_hash: H256) -> Option<::engines::EpochTransition> {
|
|
None
|
|
}
|
|
|
|
fn as_full_client(&self) -> Option<&dyn BlockChainClient> {
|
|
Some(self)
|
|
}
|
|
|
|
fn block_number(&self, id: BlockId) -> Option<BlockNumber> {
|
|
<dyn BlockChainClient>::block_number(self, id)
|
|
}
|
|
|
|
fn block_header(&self, id: BlockId) -> Option<encoded::Header> {
|
|
<dyn BlockChainClient>::block_header(self, id)
|
|
}
|
|
}
|
|
|
|
impl PrometheusMetrics for TestBlockChainClient {
|
|
fn prometheus_metrics(&self, _r: &mut PrometheusRegistry) {}
|
|
}
|