Reformat the source code
This commit is contained in:
Artem Vorotnikov
@@ -17,44 +17,43 @@
|
||||
use blockchain::BlockProvider;
|
||||
|
||||
use test_helpers::{
|
||||
generate_dummy_blockchain,
|
||||
generate_dummy_blockchain_with_extra,
|
||||
generate_dummy_empty_blockchain,
|
||||
generate_dummy_blockchain, generate_dummy_blockchain_with_extra,
|
||||
generate_dummy_empty_blockchain,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn can_contain_arbitrary_block_sequence() {
|
||||
let bc = generate_dummy_blockchain(50);
|
||||
assert_eq!(bc.best_block_number(), 49);
|
||||
let bc = generate_dummy_blockchain(50);
|
||||
assert_eq!(bc.best_block_number(), 49);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_collect_garbage() {
|
||||
let bc = generate_dummy_blockchain(3000);
|
||||
let bc = generate_dummy_blockchain(3000);
|
||||
|
||||
assert_eq!(bc.best_block_number(), 2999);
|
||||
let best_hash = bc.best_block_hash();
|
||||
let mut block_header = bc.block_header_data(&best_hash);
|
||||
assert_eq!(bc.best_block_number(), 2999);
|
||||
let best_hash = bc.best_block_hash();
|
||||
let mut block_header = bc.block_header_data(&best_hash);
|
||||
|
||||
while !block_header.is_none() {
|
||||
block_header = bc.block_header_data(&block_header.unwrap().parent_hash());
|
||||
}
|
||||
assert!(bc.cache_size().blocks > 1024 * 1024);
|
||||
while !block_header.is_none() {
|
||||
block_header = bc.block_header_data(&block_header.unwrap().parent_hash());
|
||||
}
|
||||
assert!(bc.cache_size().blocks > 1024 * 1024);
|
||||
|
||||
for _ in 0..2 {
|
||||
bc.collect_garbage();
|
||||
}
|
||||
assert!(bc.cache_size().blocks < 1024 * 1024);
|
||||
for _ in 0..2 {
|
||||
bc.collect_garbage();
|
||||
}
|
||||
assert!(bc.cache_size().blocks < 1024 * 1024);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_contain_arbitrary_block_sequence_with_extra() {
|
||||
let bc = generate_dummy_blockchain_with_extra(25);
|
||||
assert_eq!(bc.best_block_number(), 24);
|
||||
let bc = generate_dummy_blockchain_with_extra(25);
|
||||
assert_eq!(bc.best_block_number(), 24);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_contain_only_genesis_block() {
|
||||
let bc = generate_dummy_empty_blockchain();
|
||||
assert_eq!(bc.best_block_number(), 0);
|
||||
let bc = generate_dummy_empty_blockchain();
|
||||
assert_eq!(bc.best_block_number(), 0);
|
||||
}
|
||||
|
||||
@@ -14,460 +14,580 @@
|
||||
// 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::str::{FromStr, from_utf8};
|
||||
use std::sync::Arc;
|
||||
use std::{
|
||||
str::{from_utf8, FromStr},
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
use ethereum_types::{U256, Address};
|
||||
use client::{
|
||||
traits::{
|
||||
BlockChainClient, BlockChainReset, BlockInfo, ChainInfo, ImportBlock, ImportExportBlocks,
|
||||
},
|
||||
Client, ClientConfig, ImportSealedBlock, PrepareOpenBlock,
|
||||
};
|
||||
use ethereum;
|
||||
use ethereum_types::{Address, U256};
|
||||
use ethkey::KeyPair;
|
||||
use executive::{Executive, TransactOptions};
|
||||
use hash::keccak;
|
||||
use io::IoChannel;
|
||||
use miner::{Miner, MinerService, PendingOrdering};
|
||||
use rustc_hex::ToHex;
|
||||
use spec::{self, Spec};
|
||||
use state::{self, CleanupMode, State, StateInfo};
|
||||
use tempdir::TempDir;
|
||||
use test_helpers::{
|
||||
self, generate_dummy_client, generate_dummy_client_with_data, get_bad_state_dummy_block,
|
||||
get_good_dummy_block, get_good_dummy_block_seq, get_test_client_with_blocks,
|
||||
push_blocks_to_client,
|
||||
};
|
||||
use types::{
|
||||
data_format::DataFormat,
|
||||
ids::BlockId,
|
||||
transaction::{PendingTransaction, Transaction, Action, Condition},
|
||||
filter::Filter,
|
||||
view,
|
||||
views::BlockView,
|
||||
data_format::DataFormat,
|
||||
filter::Filter,
|
||||
ids::BlockId,
|
||||
transaction::{Action, Condition, PendingTransaction, Transaction},
|
||||
view,
|
||||
views::BlockView,
|
||||
};
|
||||
use verification::queue::kind::blocks::Unverified;
|
||||
use client::{Client, ClientConfig, PrepareOpenBlock, ImportSealedBlock};
|
||||
use client::traits::{
|
||||
BlockInfo, BlockChainClient, BlockChainReset, ChainInfo,
|
||||
ImportExportBlocks, ImportBlock
|
||||
};
|
||||
use spec;
|
||||
use ethereum;
|
||||
use executive::{Executive, TransactOptions};
|
||||
use miner::{Miner, PendingOrdering, MinerService};
|
||||
use spec::Spec;
|
||||
use state::{self, State, CleanupMode, StateInfo};
|
||||
use test_helpers::{
|
||||
self,
|
||||
generate_dummy_client, push_blocks_to_client, get_test_client_with_blocks, get_good_dummy_block_seq,
|
||||
generate_dummy_client_with_data, get_good_dummy_block, get_bad_state_dummy_block
|
||||
};
|
||||
use rustc_hex::ToHex;
|
||||
|
||||
#[test]
|
||||
fn imports_from_empty() {
|
||||
let db = test_helpers::new_db();
|
||||
let spec = Spec::new_test();
|
||||
let db = test_helpers::new_db();
|
||||
let spec = Spec::new_test();
|
||||
|
||||
let client = Client::new(
|
||||
ClientConfig::default(),
|
||||
&spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
).unwrap();
|
||||
client.import_verified_blocks();
|
||||
client.flush_queue();
|
||||
let client = Client::new(
|
||||
ClientConfig::default(),
|
||||
&spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
)
|
||||
.unwrap();
|
||||
client.import_verified_blocks();
|
||||
client.flush_queue();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn should_return_registrar() {
|
||||
let db = test_helpers::new_db();
|
||||
let tempdir = TempDir::new("").unwrap();
|
||||
let spec = ethereum::new_morden(&tempdir.path().to_owned());
|
||||
let db = test_helpers::new_db();
|
||||
let tempdir = TempDir::new("").unwrap();
|
||||
let spec = ethereum::new_morden(&tempdir.path().to_owned());
|
||||
|
||||
let client = Client::new(
|
||||
ClientConfig::default(),
|
||||
&spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
).unwrap();
|
||||
let params = client.additional_params();
|
||||
let address = ¶ms["registrar"];
|
||||
let client = Client::new(
|
||||
ClientConfig::default(),
|
||||
&spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
)
|
||||
.unwrap();
|
||||
let params = client.additional_params();
|
||||
let address = ¶ms["registrar"];
|
||||
|
||||
assert_eq!(address.len(), 40);
|
||||
assert!(U256::from_str(address).is_ok());
|
||||
assert_eq!(address.len(), 40);
|
||||
assert!(U256::from_str(address).is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_state_root_basic() {
|
||||
let client = generate_dummy_client(6);
|
||||
let test_spec = Spec::new_test();
|
||||
let genesis_header = test_spec.genesis_header();
|
||||
let client = generate_dummy_client(6);
|
||||
let test_spec = Spec::new_test();
|
||||
let genesis_header = test_spec.genesis_header();
|
||||
|
||||
assert!(client.state_data(genesis_header.state_root()).is_some());
|
||||
assert!(client.state_data(genesis_header.state_root()).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn imports_good_block() {
|
||||
let db = test_helpers::new_db();
|
||||
let spec = Spec::new_test();
|
||||
let db = test_helpers::new_db();
|
||||
let spec = Spec::new_test();
|
||||
|
||||
let client = Client::new(
|
||||
ClientConfig::default(),
|
||||
&spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
).unwrap();
|
||||
let good_block = get_good_dummy_block();
|
||||
if client.import_block(Unverified::from_rlp(good_block).unwrap()).is_err() {
|
||||
panic!("error importing block being good by definition");
|
||||
}
|
||||
client.flush_queue();
|
||||
client.import_verified_blocks();
|
||||
let client = Client::new(
|
||||
ClientConfig::default(),
|
||||
&spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
)
|
||||
.unwrap();
|
||||
let good_block = get_good_dummy_block();
|
||||
if client
|
||||
.import_block(Unverified::from_rlp(good_block).unwrap())
|
||||
.is_err()
|
||||
{
|
||||
panic!("error importing block being good by definition");
|
||||
}
|
||||
client.flush_queue();
|
||||
client.import_verified_blocks();
|
||||
|
||||
let block = client.block_header(BlockId::Number(1)).unwrap();
|
||||
assert!(!block.into_inner().is_empty());
|
||||
let block = client.block_header(BlockId::Number(1)).unwrap();
|
||||
assert!(!block.into_inner().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn query_none_block() {
|
||||
let db = test_helpers::new_db();
|
||||
let spec = Spec::new_test();
|
||||
let db = test_helpers::new_db();
|
||||
let spec = Spec::new_test();
|
||||
|
||||
let client = Client::new(
|
||||
ClientConfig::default(),
|
||||
&spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
).unwrap();
|
||||
let non_existant = client.block_header(BlockId::Number(188));
|
||||
assert!(non_existant.is_none());
|
||||
let client = Client::new(
|
||||
ClientConfig::default(),
|
||||
&spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
)
|
||||
.unwrap();
|
||||
let non_existant = client.block_header(BlockId::Number(188));
|
||||
assert!(non_existant.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn query_bad_block() {
|
||||
let client = get_test_client_with_blocks(vec![get_bad_state_dummy_block()]);
|
||||
let bad_block: Option<_> = client.block_header(BlockId::Number(1));
|
||||
let client = get_test_client_with_blocks(vec![get_bad_state_dummy_block()]);
|
||||
let bad_block: Option<_> = client.block_header(BlockId::Number(1));
|
||||
|
||||
assert!(bad_block.is_none());
|
||||
assert!(bad_block.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_chain_info() {
|
||||
let dummy_block = get_good_dummy_block();
|
||||
let client = get_test_client_with_blocks(vec![dummy_block.clone()]);
|
||||
let block = view!(BlockView, &dummy_block);
|
||||
let info = client.chain_info();
|
||||
assert_eq!(info.best_block_hash, block.header().hash());
|
||||
let dummy_block = get_good_dummy_block();
|
||||
let client = get_test_client_with_blocks(vec![dummy_block.clone()]);
|
||||
let block = view!(BlockView, &dummy_block);
|
||||
let info = client.chain_info();
|
||||
assert_eq!(info.best_block_hash, block.header().hash());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_logs() {
|
||||
let dummy_block = get_good_dummy_block();
|
||||
let client = get_test_client_with_blocks(vec![dummy_block.clone()]);
|
||||
let logs = client.logs(Filter {
|
||||
from_block: BlockId::Earliest,
|
||||
to_block: BlockId::Latest,
|
||||
address: None,
|
||||
topics: vec![],
|
||||
limit: None,
|
||||
}).unwrap();
|
||||
assert_eq!(logs.len(), 0);
|
||||
let dummy_block = get_good_dummy_block();
|
||||
let client = get_test_client_with_blocks(vec![dummy_block.clone()]);
|
||||
let logs = client
|
||||
.logs(Filter {
|
||||
from_block: BlockId::Earliest,
|
||||
to_block: BlockId::Latest,
|
||||
address: None,
|
||||
topics: vec![],
|
||||
limit: None,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(logs.len(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_logs_with_limit() {
|
||||
let dummy_block = get_good_dummy_block();
|
||||
let client = get_test_client_with_blocks(vec![dummy_block.clone()]);
|
||||
let logs = client.logs(Filter {
|
||||
from_block: BlockId::Earliest,
|
||||
to_block: BlockId::Latest,
|
||||
address: None,
|
||||
topics: vec![],
|
||||
limit: None,
|
||||
}).unwrap();
|
||||
assert_eq!(logs.len(), 0);
|
||||
let dummy_block = get_good_dummy_block();
|
||||
let client = get_test_client_with_blocks(vec![dummy_block.clone()]);
|
||||
let logs = client
|
||||
.logs(Filter {
|
||||
from_block: BlockId::Earliest,
|
||||
to_block: BlockId::Latest,
|
||||
address: None,
|
||||
topics: vec![],
|
||||
limit: None,
|
||||
})
|
||||
.unwrap();
|
||||
assert_eq!(logs.len(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_block_body() {
|
||||
let dummy_block = get_good_dummy_block();
|
||||
let client = get_test_client_with_blocks(vec![dummy_block.clone()]);
|
||||
let block = view!(BlockView, &dummy_block);
|
||||
let body = client.block_body(BlockId::Hash(block.header().hash())).unwrap();
|
||||
let body = body.rlp();
|
||||
assert_eq!(body.item_count().unwrap(), 2);
|
||||
assert_eq!(body.at(0).unwrap().as_raw()[..], block.rlp().at(1).as_raw()[..]);
|
||||
assert_eq!(body.at(1).unwrap().as_raw()[..], block.rlp().at(2).as_raw()[..]);
|
||||
let dummy_block = get_good_dummy_block();
|
||||
let client = get_test_client_with_blocks(vec![dummy_block.clone()]);
|
||||
let block = view!(BlockView, &dummy_block);
|
||||
let body = client
|
||||
.block_body(BlockId::Hash(block.header().hash()))
|
||||
.unwrap();
|
||||
let body = body.rlp();
|
||||
assert_eq!(body.item_count().unwrap(), 2);
|
||||
assert_eq!(
|
||||
body.at(0).unwrap().as_raw()[..],
|
||||
block.rlp().at(1).as_raw()[..]
|
||||
);
|
||||
assert_eq!(
|
||||
body.at(1).unwrap().as_raw()[..],
|
||||
block.rlp().at(2).as_raw()[..]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn imports_block_sequence() {
|
||||
let client = generate_dummy_client(6);
|
||||
let block = client.block_header(BlockId::Number(5)).unwrap();
|
||||
let client = generate_dummy_client(6);
|
||||
let block = client.block_header(BlockId::Number(5)).unwrap();
|
||||
|
||||
assert!(!block.into_inner().is_empty());
|
||||
assert!(!block.into_inner().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_collect_garbage() {
|
||||
let client = generate_dummy_client(100);
|
||||
client.tick(true);
|
||||
assert!(client.blockchain_cache_info().blocks < 100 * 1024);
|
||||
let client = generate_dummy_client(100);
|
||||
client.tick(true);
|
||||
assert!(client.blockchain_cache_info().blocks < 100 * 1024);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_generate_gas_price_median() {
|
||||
let client = generate_dummy_client_with_data(3, 1, slice_into![1, 2, 3]);
|
||||
assert_eq!(Some(&U256::from(2)), client.gas_price_corpus(3).median());
|
||||
let client = generate_dummy_client_with_data(3, 1, slice_into![1, 2, 3]);
|
||||
assert_eq!(Some(&U256::from(2)), client.gas_price_corpus(3).median());
|
||||
|
||||
let client = generate_dummy_client_with_data(4, 1, slice_into![1, 4, 3, 2]);
|
||||
assert_eq!(Some(&U256::from(3)), client.gas_price_corpus(3).median());
|
||||
let client = generate_dummy_client_with_data(4, 1, slice_into![1, 4, 3, 2]);
|
||||
assert_eq!(Some(&U256::from(3)), client.gas_price_corpus(3).median());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_generate_gas_price_histogram() {
|
||||
let client = generate_dummy_client_with_data(20, 1, slice_into![6354,8593,6065,4842,7845,7002,689,4958,4250,6098,5804,4320,643,8895,2296,8589,7145,2000,2512,1408]);
|
||||
let client = generate_dummy_client_with_data(
|
||||
20,
|
||||
1,
|
||||
slice_into![
|
||||
6354, 8593, 6065, 4842, 7845, 7002, 689, 4958, 4250, 6098, 5804, 4320, 643, 8895, 2296,
|
||||
8589, 7145, 2000, 2512, 1408
|
||||
],
|
||||
);
|
||||
|
||||
let hist = client.gas_price_corpus(20).histogram(5).unwrap();
|
||||
let correct_hist = ::stats::Histogram { bucket_bounds: vec_into![643, 2294, 3945, 5596, 7247, 8898], counts: vec![4,2,4,6,4] };
|
||||
assert_eq!(hist, correct_hist);
|
||||
let hist = client.gas_price_corpus(20).histogram(5).unwrap();
|
||||
let correct_hist = ::stats::Histogram {
|
||||
bucket_bounds: vec_into![643, 2294, 3945, 5596, 7247, 8898],
|
||||
counts: vec![4, 2, 4, 6, 4],
|
||||
};
|
||||
assert_eq!(hist, correct_hist);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn empty_gas_price_histogram() {
|
||||
let client = generate_dummy_client_with_data(20, 0, slice_into![]);
|
||||
let client = generate_dummy_client_with_data(20, 0, slice_into![]);
|
||||
|
||||
assert!(client.gas_price_corpus(20).histogram(5).is_none());
|
||||
assert!(client.gas_price_corpus(20).histogram(5).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn corpus_is_sorted() {
|
||||
let client = generate_dummy_client_with_data(2, 1, slice_into![U256::from_str("11426908979").unwrap(), U256::from_str("50426908979").unwrap()]);
|
||||
let corpus = client.gas_price_corpus(20);
|
||||
assert!(corpus[0] < corpus[1]);
|
||||
let client = generate_dummy_client_with_data(
|
||||
2,
|
||||
1,
|
||||
slice_into![
|
||||
U256::from_str("11426908979").unwrap(),
|
||||
U256::from_str("50426908979").unwrap()
|
||||
],
|
||||
);
|
||||
let corpus = client.gas_price_corpus(20);
|
||||
assert!(corpus[0] < corpus[1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_handle_long_fork() {
|
||||
let client = generate_dummy_client(1200);
|
||||
for _ in 0..20 {
|
||||
client.import_verified_blocks();
|
||||
}
|
||||
assert_eq!(1200, client.chain_info().best_block_number);
|
||||
let client = generate_dummy_client(1200);
|
||||
for _ in 0..20 {
|
||||
client.import_verified_blocks();
|
||||
}
|
||||
assert_eq!(1200, client.chain_info().best_block_number);
|
||||
|
||||
push_blocks_to_client(&client, 45, 1201, 800);
|
||||
push_blocks_to_client(&client, 49, 1201, 800);
|
||||
push_blocks_to_client(&client, 53, 1201, 600);
|
||||
push_blocks_to_client(&client, 45, 1201, 800);
|
||||
push_blocks_to_client(&client, 49, 1201, 800);
|
||||
push_blocks_to_client(&client, 53, 1201, 600);
|
||||
|
||||
for _ in 0..400 {
|
||||
client.import_verified_blocks();
|
||||
}
|
||||
assert_eq!(2000, client.chain_info().best_block_number);
|
||||
for _ in 0..400 {
|
||||
client.import_verified_blocks();
|
||||
}
|
||||
assert_eq!(2000, client.chain_info().best_block_number);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn can_mine() {
|
||||
let dummy_blocks = get_good_dummy_block_seq(2);
|
||||
let client = get_test_client_with_blocks(vec![dummy_blocks[0].clone()]);
|
||||
let dummy_blocks = get_good_dummy_block_seq(2);
|
||||
let client = get_test_client_with_blocks(vec![dummy_blocks[0].clone()]);
|
||||
|
||||
let b = client.prepare_open_block(Address::default(), (3141562.into(), 31415620.into()), vec![]).unwrap().close().unwrap();
|
||||
let b = client
|
||||
.prepare_open_block(
|
||||
Address::default(),
|
||||
(3141562.into(), 31415620.into()),
|
||||
vec![],
|
||||
)
|
||||
.unwrap()
|
||||
.close()
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(*b.header.parent_hash(), view!(BlockView, &dummy_blocks[0]).header_view().hash());
|
||||
assert_eq!(
|
||||
*b.header.parent_hash(),
|
||||
view!(BlockView, &dummy_blocks[0]).header_view().hash()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn change_history_size() {
|
||||
let db = test_helpers::new_db();
|
||||
let test_spec = Spec::new_null();
|
||||
let mut config = ClientConfig::default();
|
||||
let db = test_helpers::new_db();
|
||||
let test_spec = Spec::new_null();
|
||||
let mut config = ClientConfig::default();
|
||||
|
||||
config.history = 2;
|
||||
let address = Address::random();
|
||||
{
|
||||
let client = Client::new(
|
||||
ClientConfig::default(),
|
||||
&test_spec,
|
||||
db.clone(),
|
||||
Arc::new(Miner::new_for_tests(&test_spec, None)),
|
||||
IoChannel::disconnected()
|
||||
).unwrap();
|
||||
config.history = 2;
|
||||
let address = Address::random();
|
||||
{
|
||||
let client = Client::new(
|
||||
ClientConfig::default(),
|
||||
&test_spec,
|
||||
db.clone(),
|
||||
Arc::new(Miner::new_for_tests(&test_spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
for _ in 0..20 {
|
||||
let mut b = client.prepare_open_block(Address::default(), (3141562.into(), 31415620.into()), vec![]).unwrap();
|
||||
b.block_mut().state_mut().add_balance(&address, &5.into(), CleanupMode::NoEmpty).unwrap();
|
||||
b.block_mut().state_mut().commit().unwrap();
|
||||
let b = b.close_and_lock().unwrap().seal(&*test_spec.engine, vec![]).unwrap();
|
||||
client.import_sealed_block(b).unwrap(); // account change is in the journal overlay
|
||||
}
|
||||
}
|
||||
let mut config = ClientConfig::default();
|
||||
config.history = 10;
|
||||
let client = Client::new(
|
||||
config,
|
||||
&test_spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&test_spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
).unwrap();
|
||||
assert_eq!(client.state().balance(&address).unwrap(), 100.into());
|
||||
for _ in 0..20 {
|
||||
let mut b = client
|
||||
.prepare_open_block(
|
||||
Address::default(),
|
||||
(3141562.into(), 31415620.into()),
|
||||
vec![],
|
||||
)
|
||||
.unwrap();
|
||||
b.block_mut()
|
||||
.state_mut()
|
||||
.add_balance(&address, &5.into(), CleanupMode::NoEmpty)
|
||||
.unwrap();
|
||||
b.block_mut().state_mut().commit().unwrap();
|
||||
let b = b
|
||||
.close_and_lock()
|
||||
.unwrap()
|
||||
.seal(&*test_spec.engine, vec![])
|
||||
.unwrap();
|
||||
client.import_sealed_block(b).unwrap(); // account change is in the journal overlay
|
||||
}
|
||||
}
|
||||
let mut config = ClientConfig::default();
|
||||
config.history = 10;
|
||||
let client = Client::new(
|
||||
config,
|
||||
&test_spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&test_spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(client.state().balance(&address).unwrap(), 100.into());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn does_not_propagate_delayed_transactions() {
|
||||
let key = KeyPair::from_secret(keccak("test").into()).unwrap();
|
||||
let secret = key.secret();
|
||||
let tx0 = PendingTransaction::new(Transaction {
|
||||
nonce: 0.into(),
|
||||
gas_price: 0.into(),
|
||||
gas: 21000.into(),
|
||||
action: Action::Call(Address::default()),
|
||||
value: 0.into(),
|
||||
data: Vec::new(),
|
||||
}.sign(secret, None), Some(Condition::Number(2)));
|
||||
let tx1 = PendingTransaction::new(Transaction {
|
||||
nonce: 1.into(),
|
||||
gas_price: 0.into(),
|
||||
gas: 21000.into(),
|
||||
action: Action::Call(Address::default()),
|
||||
value: 0.into(),
|
||||
data: Vec::new(),
|
||||
}.sign(secret, None), None);
|
||||
let client = generate_dummy_client(1);
|
||||
let key = KeyPair::from_secret(keccak("test").into()).unwrap();
|
||||
let secret = key.secret();
|
||||
let tx0 = PendingTransaction::new(
|
||||
Transaction {
|
||||
nonce: 0.into(),
|
||||
gas_price: 0.into(),
|
||||
gas: 21000.into(),
|
||||
action: Action::Call(Address::default()),
|
||||
value: 0.into(),
|
||||
data: Vec::new(),
|
||||
}
|
||||
.sign(secret, None),
|
||||
Some(Condition::Number(2)),
|
||||
);
|
||||
let tx1 = PendingTransaction::new(
|
||||
Transaction {
|
||||
nonce: 1.into(),
|
||||
gas_price: 0.into(),
|
||||
gas: 21000.into(),
|
||||
action: Action::Call(Address::default()),
|
||||
value: 0.into(),
|
||||
data: Vec::new(),
|
||||
}
|
||||
.sign(secret, None),
|
||||
None,
|
||||
);
|
||||
let client = generate_dummy_client(1);
|
||||
|
||||
client.miner().import_own_transaction(&*client, tx0).unwrap();
|
||||
client.miner().import_own_transaction(&*client, tx1).unwrap();
|
||||
assert_eq!(0, client.transactions_to_propagate().len());
|
||||
assert_eq!(0, client.miner().ready_transactions(&*client, 10, PendingOrdering::Priority).len());
|
||||
push_blocks_to_client(&client, 53, 2, 2);
|
||||
client.flush_queue();
|
||||
assert_eq!(2, client.transactions_to_propagate().len());
|
||||
assert_eq!(2, client.miner().ready_transactions(&*client, 10, PendingOrdering::Priority).len());
|
||||
client
|
||||
.miner()
|
||||
.import_own_transaction(&*client, tx0)
|
||||
.unwrap();
|
||||
client
|
||||
.miner()
|
||||
.import_own_transaction(&*client, tx1)
|
||||
.unwrap();
|
||||
assert_eq!(0, client.transactions_to_propagate().len());
|
||||
assert_eq!(
|
||||
0,
|
||||
client
|
||||
.miner()
|
||||
.ready_transactions(&*client, 10, PendingOrdering::Priority)
|
||||
.len()
|
||||
);
|
||||
push_blocks_to_client(&client, 53, 2, 2);
|
||||
client.flush_queue();
|
||||
assert_eq!(2, client.transactions_to_propagate().len());
|
||||
assert_eq!(
|
||||
2,
|
||||
client
|
||||
.miner()
|
||||
.ready_transactions(&*client, 10, PendingOrdering::Priority)
|
||||
.len()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transaction_proof() {
|
||||
use ::client::ProvingBlockChainClient;
|
||||
use client::ProvingBlockChainClient;
|
||||
|
||||
let client = generate_dummy_client(0);
|
||||
let address = Address::random();
|
||||
let test_spec = Spec::new_test();
|
||||
for _ in 0..20 {
|
||||
let mut b = client.prepare_open_block(Address::default(), (3141562.into(), 31415620.into()), vec![]).unwrap();
|
||||
b.block_mut().state_mut().add_balance(&address, &5.into(), CleanupMode::NoEmpty).unwrap();
|
||||
b.block_mut().state_mut().commit().unwrap();
|
||||
let b = b.close_and_lock().unwrap().seal(&*test_spec.engine, vec![]).unwrap();
|
||||
client.import_sealed_block(b).unwrap(); // account change is in the journal overlay
|
||||
}
|
||||
let client = generate_dummy_client(0);
|
||||
let address = Address::random();
|
||||
let test_spec = Spec::new_test();
|
||||
for _ in 0..20 {
|
||||
let mut b = client
|
||||
.prepare_open_block(
|
||||
Address::default(),
|
||||
(3141562.into(), 31415620.into()),
|
||||
vec![],
|
||||
)
|
||||
.unwrap();
|
||||
b.block_mut()
|
||||
.state_mut()
|
||||
.add_balance(&address, &5.into(), CleanupMode::NoEmpty)
|
||||
.unwrap();
|
||||
b.block_mut().state_mut().commit().unwrap();
|
||||
let b = b
|
||||
.close_and_lock()
|
||||
.unwrap()
|
||||
.seal(&*test_spec.engine, vec![])
|
||||
.unwrap();
|
||||
client.import_sealed_block(b).unwrap(); // account change is in the journal overlay
|
||||
}
|
||||
|
||||
let transaction = Transaction {
|
||||
nonce: 0.into(),
|
||||
gas_price: 0.into(),
|
||||
gas: 21000.into(),
|
||||
action: Action::Call(Address::default()),
|
||||
value: 5.into(),
|
||||
data: Vec::new(),
|
||||
}.fake_sign(address);
|
||||
let transaction = Transaction {
|
||||
nonce: 0.into(),
|
||||
gas_price: 0.into(),
|
||||
gas: 21000.into(),
|
||||
action: Action::Call(Address::default()),
|
||||
value: 5.into(),
|
||||
data: Vec::new(),
|
||||
}
|
||||
.fake_sign(address);
|
||||
|
||||
let proof = client.prove_transaction(transaction.clone(), BlockId::Latest).unwrap().1;
|
||||
let backend = state::backend::ProofCheck::new(&proof);
|
||||
let proof = client
|
||||
.prove_transaction(transaction.clone(), BlockId::Latest)
|
||||
.unwrap()
|
||||
.1;
|
||||
let backend = state::backend::ProofCheck::new(&proof);
|
||||
|
||||
let mut factories = ::factory::Factories::default();
|
||||
factories.accountdb = ::account_db::Factory::Plain; // raw state values, no mangled keys.
|
||||
let root = *client.best_block_header().state_root();
|
||||
let mut factories = ::factory::Factories::default();
|
||||
factories.accountdb = ::account_db::Factory::Plain; // raw state values, no mangled keys.
|
||||
let root = *client.best_block_header().state_root();
|
||||
|
||||
let machine = test_spec.engine.machine();
|
||||
let env_info = client.latest_env_info();
|
||||
let schedule = machine.schedule(env_info.number);
|
||||
let mut state = State::from_existing(backend, root, 0.into(), factories.clone()).unwrap();
|
||||
Executive::new(&mut state, &env_info, &machine, &schedule)
|
||||
.transact(&transaction, TransactOptions::with_no_tracing().dont_check_nonce()).unwrap();
|
||||
let machine = test_spec.engine.machine();
|
||||
let env_info = client.latest_env_info();
|
||||
let schedule = machine.schedule(env_info.number);
|
||||
let mut state = State::from_existing(backend, root, 0.into(), factories.clone()).unwrap();
|
||||
Executive::new(&mut state, &env_info, &machine, &schedule)
|
||||
.transact(
|
||||
&transaction,
|
||||
TransactOptions::with_no_tracing().dont_check_nonce(),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
assert_eq!(state.balance(&Address::default()).unwrap(), 5.into());
|
||||
assert_eq!(state.balance(&address).unwrap(), 95.into());
|
||||
assert_eq!(state.balance(&Address::default()).unwrap(), 5.into());
|
||||
assert_eq!(state.balance(&address).unwrap(), 95.into());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reset_blockchain() {
|
||||
let client = get_test_client_with_blocks(get_good_dummy_block_seq(19));
|
||||
// 19 + genesis block
|
||||
assert!(client.block_header(BlockId::Number(20)).is_some());
|
||||
assert_eq!(client.block_header(BlockId::Number(20)).unwrap().hash(), client.best_block_header().hash());
|
||||
let client = get_test_client_with_blocks(get_good_dummy_block_seq(19));
|
||||
// 19 + genesis block
|
||||
assert!(client.block_header(BlockId::Number(20)).is_some());
|
||||
assert_eq!(
|
||||
client.block_header(BlockId::Number(20)).unwrap().hash(),
|
||||
client.best_block_header().hash()
|
||||
);
|
||||
|
||||
assert!(client.reset(5).is_ok());
|
||||
assert!(client.reset(5).is_ok());
|
||||
|
||||
client.chain().clear_cache();
|
||||
client.chain().clear_cache();
|
||||
|
||||
assert!(client.block_header(BlockId::Number(20)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(19)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(18)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(17)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(16)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(20)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(19)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(18)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(17)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(16)).is_none());
|
||||
|
||||
assert!(client.block_header(BlockId::Number(15)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(15)).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn import_export_hex() {
|
||||
let client = get_test_client_with_blocks(get_good_dummy_block_seq(19));
|
||||
let block_rlps = (15..20)
|
||||
.filter_map(|num| client.block(BlockId::Number(num)))
|
||||
.map(|header| {
|
||||
header.raw().to_hex()
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
let client = get_test_client_with_blocks(get_good_dummy_block_seq(19));
|
||||
let block_rlps = (15..20)
|
||||
.filter_map(|num| client.block(BlockId::Number(num)))
|
||||
.map(|header| header.raw().to_hex())
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
let mut out = Vec::new();
|
||||
let mut out = Vec::new();
|
||||
|
||||
client.export_blocks(
|
||||
Box::new(&mut out),
|
||||
BlockId::Number(15),
|
||||
BlockId::Number(20),
|
||||
Some(DataFormat::Hex)
|
||||
).unwrap();
|
||||
client
|
||||
.export_blocks(
|
||||
Box::new(&mut out),
|
||||
BlockId::Number(15),
|
||||
BlockId::Number(20),
|
||||
Some(DataFormat::Hex),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let written = from_utf8(&out)
|
||||
.unwrap()
|
||||
.split("\n")
|
||||
// last line is empty, ignore it.
|
||||
.take(5)
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(block_rlps, written);
|
||||
let written = from_utf8(&out)
|
||||
.unwrap()
|
||||
.split("\n")
|
||||
// last line is empty, ignore it.
|
||||
.take(5)
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(block_rlps, written);
|
||||
|
||||
assert!(client.reset(5).is_ok());
|
||||
client.chain().clear_cache();
|
||||
assert!(client.reset(5).is_ok());
|
||||
client.chain().clear_cache();
|
||||
|
||||
assert!(client.block_header(BlockId::Number(20)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(19)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(18)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(17)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(16)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(20)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(19)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(18)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(17)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(16)).is_none());
|
||||
|
||||
client.import_blocks(Box::new(&*out), Some(DataFormat::Hex)).unwrap();
|
||||
client
|
||||
.import_blocks(Box::new(&*out), Some(DataFormat::Hex))
|
||||
.unwrap();
|
||||
|
||||
assert!(client.block_header(BlockId::Number(20)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(19)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(18)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(17)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(16)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(20)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(19)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(18)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(17)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(16)).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn import_export_binary() {
|
||||
let client = get_test_client_with_blocks(get_good_dummy_block_seq(19));
|
||||
let client = get_test_client_with_blocks(get_good_dummy_block_seq(19));
|
||||
|
||||
let mut out = Vec::new();
|
||||
let mut out = Vec::new();
|
||||
|
||||
client.export_blocks(
|
||||
Box::new(&mut out),
|
||||
BlockId::Number(15),
|
||||
BlockId::Number(20),
|
||||
Some(DataFormat::Binary)
|
||||
).unwrap();
|
||||
client
|
||||
.export_blocks(
|
||||
Box::new(&mut out),
|
||||
BlockId::Number(15),
|
||||
BlockId::Number(20),
|
||||
Some(DataFormat::Binary),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
assert!(client.reset(5).is_ok());
|
||||
client.chain().clear_cache();
|
||||
assert!(client.reset(5).is_ok());
|
||||
client.chain().clear_cache();
|
||||
|
||||
assert!(client.block_header(BlockId::Number(20)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(19)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(18)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(17)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(16)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(20)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(19)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(18)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(17)).is_none());
|
||||
assert!(client.block_header(BlockId::Number(16)).is_none());
|
||||
|
||||
client.import_blocks(Box::new(&*out), Some(DataFormat::Binary)).unwrap();
|
||||
client
|
||||
.import_blocks(Box::new(&*out), Some(DataFormat::Binary))
|
||||
.unwrap();
|
||||
|
||||
assert!(client.block_header(BlockId::Number(19)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(18)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(20)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(17)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(16)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(19)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(18)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(20)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(17)).is_some());
|
||||
assert!(client.block_header(BlockId::Number(16)).is_some());
|
||||
}
|
||||
|
||||
@@ -16,83 +16,85 @@
|
||||
|
||||
//! Tests of EVM integration with transaction execution.
|
||||
|
||||
use std::sync::Arc;
|
||||
use hash::keccak;
|
||||
use vm::{EnvInfo, ActionParams, ActionValue, CallType, ParamsType};
|
||||
use evm::{Factory, VMType};
|
||||
use executive::Executive;
|
||||
use hash::keccak;
|
||||
use state::Substate;
|
||||
use std::sync::Arc;
|
||||
use test_helpers::get_temp_state_with_factory;
|
||||
use trace::{NoopVMTracer, NoopTracer};
|
||||
use trace::{NoopTracer, NoopVMTracer};
|
||||
use types::transaction::SYSTEM_ADDRESS;
|
||||
use vm::{ActionParams, ActionValue, CallType, EnvInfo, ParamsType};
|
||||
|
||||
use rustc_hex::FromHex;
|
||||
|
||||
use ethereum_types::{H256, Address};
|
||||
use ethereum_types::{Address, H256};
|
||||
|
||||
evm_test!{test_blockhash_eip210: test_blockhash_eip210_int}
|
||||
evm_test! {test_blockhash_eip210: test_blockhash_eip210_int}
|
||||
fn test_blockhash_eip210(factory: Factory) {
|
||||
let get_prev_hash_code = Arc::new("600143034060205260206020f3".from_hex().unwrap()); // this returns previous block hash
|
||||
let get_prev_hash_code_hash = keccak(get_prev_hash_code.as_ref());
|
||||
// This is same as DEFAULT_BLOCKHASH_CONTRACT except for metropolis transition block check removed.
|
||||
let test_blockhash_contract = "73fffffffffffffffffffffffffffffffffffffffe33141561007a57600143036020526000356101006020510755600061010060205107141561005057600035610100610100602051050761010001555b6000620100006020510714156100755760003561010062010000602051050761020001555b61014a565b4360003512151561009057600060405260206040f35b610100600035430312156100b357610100600035075460605260206060f3610149565b62010000600035430312156100d157600061010060003507146100d4565b60005b156100f6576101006101006000350507610100015460805260206080f3610148565b630100000060003543031215610116576000620100006000350714610119565b60005b1561013c57610100620100006000350507610200015460a052602060a0f3610147565b600060c052602060c0f35b5b5b5b5b";
|
||||
let blockhash_contract_code = Arc::new(test_blockhash_contract.from_hex().unwrap());
|
||||
let blockhash_contract_code_hash = keccak(blockhash_contract_code.as_ref());
|
||||
let machine = ::ethereum::new_eip210_test_machine();
|
||||
let mut env_info = EnvInfo::default();
|
||||
let get_prev_hash_code = Arc::new("600143034060205260206020f3".from_hex().unwrap()); // this returns previous block hash
|
||||
let get_prev_hash_code_hash = keccak(get_prev_hash_code.as_ref());
|
||||
// This is same as DEFAULT_BLOCKHASH_CONTRACT except for metropolis transition block check removed.
|
||||
let test_blockhash_contract = "73fffffffffffffffffffffffffffffffffffffffe33141561007a57600143036020526000356101006020510755600061010060205107141561005057600035610100610100602051050761010001555b6000620100006020510714156100755760003561010062010000602051050761020001555b61014a565b4360003512151561009057600060405260206040f35b610100600035430312156100b357610100600035075460605260206060f3610149565b62010000600035430312156100d157600061010060003507146100d4565b60005b156100f6576101006101006000350507610100015460805260206080f3610148565b630100000060003543031215610116576000620100006000350714610119565b60005b1561013c57610100620100006000350507610200015460a052602060a0f3610147565b600060c052602060c0f35b5b5b5b5b";
|
||||
let blockhash_contract_code = Arc::new(test_blockhash_contract.from_hex().unwrap());
|
||||
let blockhash_contract_code_hash = keccak(blockhash_contract_code.as_ref());
|
||||
let machine = ::ethereum::new_eip210_test_machine();
|
||||
let mut env_info = EnvInfo::default();
|
||||
|
||||
// populate state with 256 last hashes
|
||||
let mut state = get_temp_state_with_factory(factory);
|
||||
let contract_address: Address = 0xf0.into();
|
||||
state.init_code(&contract_address, (*blockhash_contract_code).clone()).unwrap();
|
||||
for i in 1 .. 257 {
|
||||
env_info.number = i.into();
|
||||
let params = ActionParams {
|
||||
code_address: contract_address.clone(),
|
||||
address: contract_address,
|
||||
sender: SYSTEM_ADDRESS.clone(),
|
||||
origin: SYSTEM_ADDRESS.clone(),
|
||||
gas: 100000.into(),
|
||||
gas_price: 0.into(),
|
||||
value: ActionValue::Transfer(0.into()),
|
||||
code: Some(blockhash_contract_code.clone()),
|
||||
code_hash: Some(blockhash_contract_code_hash),
|
||||
data: Some(H256::from(i - 1).to_vec()),
|
||||
call_type: CallType::Call,
|
||||
params_type: ParamsType::Separate,
|
||||
};
|
||||
let schedule = machine.schedule(env_info.number);
|
||||
let mut ex = Executive::new(&mut state, &env_info, &machine, &schedule);
|
||||
let mut substate = Substate::new();
|
||||
if let Err(e) = ex.call(params, &mut substate, &mut NoopTracer, &mut NoopVMTracer) {
|
||||
panic!("Encountered error on updating last hashes: {}", e);
|
||||
}
|
||||
}
|
||||
// populate state with 256 last hashes
|
||||
let mut state = get_temp_state_with_factory(factory);
|
||||
let contract_address: Address = 0xf0.into();
|
||||
state
|
||||
.init_code(&contract_address, (*blockhash_contract_code).clone())
|
||||
.unwrap();
|
||||
for i in 1..257 {
|
||||
env_info.number = i.into();
|
||||
let params = ActionParams {
|
||||
code_address: contract_address.clone(),
|
||||
address: contract_address,
|
||||
sender: SYSTEM_ADDRESS.clone(),
|
||||
origin: SYSTEM_ADDRESS.clone(),
|
||||
gas: 100000.into(),
|
||||
gas_price: 0.into(),
|
||||
value: ActionValue::Transfer(0.into()),
|
||||
code: Some(blockhash_contract_code.clone()),
|
||||
code_hash: Some(blockhash_contract_code_hash),
|
||||
data: Some(H256::from(i - 1).to_vec()),
|
||||
call_type: CallType::Call,
|
||||
params_type: ParamsType::Separate,
|
||||
};
|
||||
let schedule = machine.schedule(env_info.number);
|
||||
let mut ex = Executive::new(&mut state, &env_info, &machine, &schedule);
|
||||
let mut substate = Substate::new();
|
||||
if let Err(e) = ex.call(params, &mut substate, &mut NoopTracer, &mut NoopVMTracer) {
|
||||
panic!("Encountered error on updating last hashes: {}", e);
|
||||
}
|
||||
}
|
||||
|
||||
env_info.number = 256;
|
||||
let params = ActionParams {
|
||||
code_address: Address::new(),
|
||||
address: Address::new(),
|
||||
sender: Address::new(),
|
||||
origin: Address::new(),
|
||||
gas: 100000.into(),
|
||||
gas_price: 0.into(),
|
||||
value: ActionValue::Transfer(0.into()),
|
||||
code: Some(get_prev_hash_code),
|
||||
code_hash: Some(get_prev_hash_code_hash),
|
||||
data: None,
|
||||
call_type: CallType::Call,
|
||||
params_type: ParamsType::Separate,
|
||||
};
|
||||
let schedule = machine.schedule(env_info.number);
|
||||
let mut ex = Executive::new(&mut state, &env_info, &machine, &schedule);
|
||||
let mut substate = Substate::new();
|
||||
let res = ex.call(params, &mut substate, &mut NoopTracer, &mut NoopVMTracer);
|
||||
let output = match res {
|
||||
Ok(res) => H256::from(&res.return_data[..32]),
|
||||
Err(e) => {
|
||||
panic!("Encountered error on getting last hash: {}", e);
|
||||
},
|
||||
};
|
||||
assert_eq!(output, 255.into());
|
||||
env_info.number = 256;
|
||||
let params = ActionParams {
|
||||
code_address: Address::new(),
|
||||
address: Address::new(),
|
||||
sender: Address::new(),
|
||||
origin: Address::new(),
|
||||
gas: 100000.into(),
|
||||
gas_price: 0.into(),
|
||||
value: ActionValue::Transfer(0.into()),
|
||||
code: Some(get_prev_hash_code),
|
||||
code_hash: Some(get_prev_hash_code_hash),
|
||||
data: None,
|
||||
call_type: CallType::Call,
|
||||
params_type: ParamsType::Separate,
|
||||
};
|
||||
let schedule = machine.schedule(env_info.number);
|
||||
let mut ex = Executive::new(&mut state, &env_info, &machine, &schedule);
|
||||
let mut substate = Substate::new();
|
||||
let res = ex.call(params, &mut substate, &mut NoopTracer, &mut NoopVMTracer);
|
||||
let output = match res {
|
||||
Ok(res) => H256::from(&res.return_data[..32]),
|
||||
Err(e) => {
|
||||
panic!("Encountered error on getting last hash: {}", e);
|
||||
}
|
||||
};
|
||||
assert_eq!(output, 255.into());
|
||||
}
|
||||
|
||||
@@ -14,7 +14,7 @@
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with Parity Ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
mod client;
|
||||
mod blockchain;
|
||||
mod client;
|
||||
mod evm;
|
||||
mod trace;
|
||||
|
||||
@@ -16,195 +16,232 @@
|
||||
|
||||
//! Client tests of tracing
|
||||
|
||||
use block::*;
|
||||
use client::{BlockChainClient, Client, ClientConfig, *};
|
||||
use ethereum_types::{Address, U256};
|
||||
use ethkey::KeyPair;
|
||||
use hash::keccak;
|
||||
use block::*;
|
||||
use ethereum_types::{U256, Address};
|
||||
use io::*;
|
||||
use spec::*;
|
||||
use client::*;
|
||||
use test_helpers::get_temp_state_db;
|
||||
use client::{BlockChainClient, Client, ClientConfig};
|
||||
use std::sync::Arc;
|
||||
use miner::Miner;
|
||||
use types::transaction::{Action, Transaction};
|
||||
use trace::{RewardType, LocalizedTrace};
|
||||
use trace::trace::Action::Reward;
|
||||
use test_helpers;
|
||||
use spec::*;
|
||||
use std::sync::Arc;
|
||||
use test_helpers::{self, get_temp_state_db};
|
||||
use trace::{trace::Action::Reward, LocalizedTrace, RewardType};
|
||||
use types::{
|
||||
header::Header,
|
||||
transaction::{Action, Transaction},
|
||||
view,
|
||||
views::BlockView,
|
||||
};
|
||||
use verification::queue::kind::blocks::Unverified;
|
||||
use types::header::Header;
|
||||
use types::view;
|
||||
use types::views::BlockView;
|
||||
|
||||
#[test]
|
||||
fn can_trace_block_and_uncle_reward() {
|
||||
let db = test_helpers::new_db();
|
||||
let spec = Spec::new_test_with_reward();
|
||||
let engine = &*spec.engine;
|
||||
let db = test_helpers::new_db();
|
||||
let spec = Spec::new_test_with_reward();
|
||||
let engine = &*spec.engine;
|
||||
|
||||
// Create client
|
||||
let mut client_config = ClientConfig::default();
|
||||
client_config.tracing.enabled = true;
|
||||
let client = Client::new(
|
||||
client_config,
|
||||
&spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
).unwrap();
|
||||
// Create client
|
||||
let mut client_config = ClientConfig::default();
|
||||
client_config.tracing.enabled = true;
|
||||
let client = Client::new(
|
||||
client_config,
|
||||
&spec,
|
||||
db,
|
||||
Arc::new(Miner::new_for_tests(&spec, None)),
|
||||
IoChannel::disconnected(),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
// Create test data:
|
||||
// genesis
|
||||
// |
|
||||
// root_block
|
||||
// |
|
||||
// parent_block
|
||||
// |
|
||||
// block with transaction and uncle
|
||||
// Create test data:
|
||||
// genesis
|
||||
// |
|
||||
// root_block
|
||||
// |
|
||||
// parent_block
|
||||
// |
|
||||
// block with transaction and uncle
|
||||
|
||||
let genesis_header = spec.genesis_header();
|
||||
let genesis_gas = genesis_header.gas_limit().clone();
|
||||
let genesis_header = spec.genesis_header();
|
||||
let genesis_gas = genesis_header.gas_limit().clone();
|
||||
|
||||
let mut db = spec.ensure_db_good(get_temp_state_db(), &Default::default()).unwrap();
|
||||
let mut rolling_timestamp = 40;
|
||||
let mut last_hashes = vec![];
|
||||
let mut last_header = genesis_header.clone();
|
||||
last_hashes.push(last_header.hash());
|
||||
let mut db = spec
|
||||
.ensure_db_good(get_temp_state_db(), &Default::default())
|
||||
.unwrap();
|
||||
let mut rolling_timestamp = 40;
|
||||
let mut last_hashes = vec![];
|
||||
let mut last_header = genesis_header.clone();
|
||||
last_hashes.push(last_header.hash());
|
||||
|
||||
let kp = KeyPair::from_secret_slice(&keccak("")).unwrap();
|
||||
let author = kp.address();
|
||||
let kp = KeyPair::from_secret_slice(&keccak("")).unwrap();
|
||||
let author = kp.address();
|
||||
|
||||
// Add root block first
|
||||
let mut root_block = OpenBlock::new(
|
||||
engine,
|
||||
Default::default(),
|
||||
false,
|
||||
db,
|
||||
&last_header,
|
||||
Arc::new(last_hashes.clone()),
|
||||
author.clone(),
|
||||
(3141562.into(), 31415620.into()),
|
||||
vec![],
|
||||
false,
|
||||
None,
|
||||
).unwrap();
|
||||
rolling_timestamp += 10;
|
||||
root_block.set_timestamp(rolling_timestamp);
|
||||
// Add root block first
|
||||
let mut root_block = OpenBlock::new(
|
||||
engine,
|
||||
Default::default(),
|
||||
false,
|
||||
db,
|
||||
&last_header,
|
||||
Arc::new(last_hashes.clone()),
|
||||
author.clone(),
|
||||
(3141562.into(), 31415620.into()),
|
||||
vec![],
|
||||
false,
|
||||
None,
|
||||
)
|
||||
.unwrap();
|
||||
rolling_timestamp += 10;
|
||||
root_block.set_timestamp(rolling_timestamp);
|
||||
|
||||
let root_block = root_block.close_and_lock().unwrap().seal(engine, vec![]).unwrap();
|
||||
let root_block = root_block
|
||||
.close_and_lock()
|
||||
.unwrap()
|
||||
.seal(engine, vec![])
|
||||
.unwrap();
|
||||
|
||||
if let Err(e) = client.import_block(Unverified::from_rlp(root_block.rlp_bytes()).unwrap()) {
|
||||
panic!("error importing block which is valid by definition: {:?}", e);
|
||||
}
|
||||
if let Err(e) = client.import_block(Unverified::from_rlp(root_block.rlp_bytes()).unwrap()) {
|
||||
panic!(
|
||||
"error importing block which is valid by definition: {:?}",
|
||||
e
|
||||
);
|
||||
}
|
||||
|
||||
last_header = view!(BlockView, &root_block.rlp_bytes()).header();
|
||||
let root_header = last_header.clone();
|
||||
db = root_block.drain().state.drop().1;
|
||||
last_header = view!(BlockView, &root_block.rlp_bytes()).header();
|
||||
let root_header = last_header.clone();
|
||||
db = root_block.drain().state.drop().1;
|
||||
|
||||
last_hashes.push(last_header.hash());
|
||||
last_hashes.push(last_header.hash());
|
||||
|
||||
// Add parent block
|
||||
let mut parent_block = OpenBlock::new(
|
||||
engine,
|
||||
Default::default(),
|
||||
false,
|
||||
db,
|
||||
&last_header,
|
||||
Arc::new(last_hashes.clone()),
|
||||
author.clone(),
|
||||
(3141562.into(), 31415620.into()),
|
||||
vec![],
|
||||
false,
|
||||
None,
|
||||
).unwrap();
|
||||
rolling_timestamp += 10;
|
||||
parent_block.set_timestamp(rolling_timestamp);
|
||||
// Add parent block
|
||||
let mut parent_block = OpenBlock::new(
|
||||
engine,
|
||||
Default::default(),
|
||||
false,
|
||||
db,
|
||||
&last_header,
|
||||
Arc::new(last_hashes.clone()),
|
||||
author.clone(),
|
||||
(3141562.into(), 31415620.into()),
|
||||
vec![],
|
||||
false,
|
||||
None,
|
||||
)
|
||||
.unwrap();
|
||||
rolling_timestamp += 10;
|
||||
parent_block.set_timestamp(rolling_timestamp);
|
||||
|
||||
let parent_block = parent_block.close_and_lock().unwrap().seal(engine, vec![]).unwrap();
|
||||
let parent_block = parent_block
|
||||
.close_and_lock()
|
||||
.unwrap()
|
||||
.seal(engine, vec![])
|
||||
.unwrap();
|
||||
|
||||
if let Err(e) = client.import_block(Unverified::from_rlp(parent_block.rlp_bytes()).unwrap()) {
|
||||
panic!("error importing block which is valid by definition: {:?}", e);
|
||||
}
|
||||
if let Err(e) = client.import_block(Unverified::from_rlp(parent_block.rlp_bytes()).unwrap()) {
|
||||
panic!(
|
||||
"error importing block which is valid by definition: {:?}",
|
||||
e
|
||||
);
|
||||
}
|
||||
|
||||
last_header = view!(BlockView,&parent_block.rlp_bytes()).header();
|
||||
db = parent_block.drain().state.drop().1;
|
||||
last_header = view!(BlockView, &parent_block.rlp_bytes()).header();
|
||||
db = parent_block.drain().state.drop().1;
|
||||
|
||||
last_hashes.push(last_header.hash());
|
||||
last_hashes.push(last_header.hash());
|
||||
|
||||
// Add testing block with transaction and uncle
|
||||
let mut block = OpenBlock::new(
|
||||
engine,
|
||||
Default::default(),
|
||||
true,
|
||||
db,
|
||||
&last_header,
|
||||
Arc::new(last_hashes.clone()),
|
||||
author.clone(),
|
||||
(3141562.into(), 31415620.into()),
|
||||
vec![],
|
||||
false,
|
||||
None,
|
||||
).unwrap();
|
||||
rolling_timestamp += 10;
|
||||
block.set_timestamp(rolling_timestamp);
|
||||
// Add testing block with transaction and uncle
|
||||
let mut block = OpenBlock::new(
|
||||
engine,
|
||||
Default::default(),
|
||||
true,
|
||||
db,
|
||||
&last_header,
|
||||
Arc::new(last_hashes.clone()),
|
||||
author.clone(),
|
||||
(3141562.into(), 31415620.into()),
|
||||
vec![],
|
||||
false,
|
||||
None,
|
||||
)
|
||||
.unwrap();
|
||||
rolling_timestamp += 10;
|
||||
block.set_timestamp(rolling_timestamp);
|
||||
|
||||
let mut n = 0;
|
||||
for _ in 0..1 {
|
||||
block.push_transaction(Transaction {
|
||||
nonce: n.into(),
|
||||
gas_price: 10000.into(),
|
||||
gas: 100000.into(),
|
||||
action: Action::Create,
|
||||
data: vec![],
|
||||
value: U256::zero(),
|
||||
}.sign(kp.secret(), Some(spec.network_id())), None).unwrap();
|
||||
n += 1;
|
||||
}
|
||||
let mut n = 0;
|
||||
for _ in 0..1 {
|
||||
block
|
||||
.push_transaction(
|
||||
Transaction {
|
||||
nonce: n.into(),
|
||||
gas_price: 10000.into(),
|
||||
gas: 100000.into(),
|
||||
action: Action::Create,
|
||||
data: vec![],
|
||||
value: U256::zero(),
|
||||
}
|
||||
.sign(kp.secret(), Some(spec.network_id())),
|
||||
None,
|
||||
)
|
||||
.unwrap();
|
||||
n += 1;
|
||||
}
|
||||
|
||||
let mut uncle = Header::new();
|
||||
let uncle_author: Address = "ef2d6d194084c2de36e0dabfce45d046b37d1106".into();
|
||||
uncle.set_author(uncle_author);
|
||||
uncle.set_parent_hash(root_header.hash());
|
||||
uncle.set_gas_limit(genesis_gas);
|
||||
uncle.set_number(root_header.number() + 1);
|
||||
uncle.set_timestamp(rolling_timestamp);
|
||||
block.push_uncle(uncle).unwrap();
|
||||
let mut uncle = Header::new();
|
||||
let uncle_author: Address = "ef2d6d194084c2de36e0dabfce45d046b37d1106".into();
|
||||
uncle.set_author(uncle_author);
|
||||
uncle.set_parent_hash(root_header.hash());
|
||||
uncle.set_gas_limit(genesis_gas);
|
||||
uncle.set_number(root_header.number() + 1);
|
||||
uncle.set_timestamp(rolling_timestamp);
|
||||
block.push_uncle(uncle).unwrap();
|
||||
|
||||
let block = block.close_and_lock().unwrap().seal(engine, vec![]).unwrap();
|
||||
let block = block
|
||||
.close_and_lock()
|
||||
.unwrap()
|
||||
.seal(engine, vec![])
|
||||
.unwrap();
|
||||
|
||||
let res = client.import_block(Unverified::from_rlp(block.rlp_bytes()).unwrap());
|
||||
if res.is_err() {
|
||||
panic!("error importing block: {:#?}", res.err().unwrap());
|
||||
}
|
||||
let res = client.import_block(Unverified::from_rlp(block.rlp_bytes()).unwrap());
|
||||
if res.is_err() {
|
||||
panic!("error importing block: {:#?}", res.err().unwrap());
|
||||
}
|
||||
|
||||
block.drain();
|
||||
client.flush_queue();
|
||||
client.import_verified_blocks();
|
||||
block.drain();
|
||||
client.flush_queue();
|
||||
client.import_verified_blocks();
|
||||
|
||||
// Test0. Check overall filter
|
||||
let filter = TraceFilter {
|
||||
range: (BlockId::Number(1)..BlockId::Number(3)),
|
||||
from_address: vec![],
|
||||
to_address: vec![],
|
||||
after: None,
|
||||
count: None,
|
||||
};
|
||||
// Test0. Check overall filter
|
||||
let filter = TraceFilter {
|
||||
range: (BlockId::Number(1)..BlockId::Number(3)),
|
||||
from_address: vec![],
|
||||
to_address: vec![],
|
||||
after: None,
|
||||
count: None,
|
||||
};
|
||||
|
||||
let traces = client.filter_traces(filter);
|
||||
assert!(traces.is_some(), "Filtered traces should be present");
|
||||
let traces_vec = traces.unwrap();
|
||||
let block_reward_traces: Vec<LocalizedTrace> = traces_vec.clone().into_iter().filter(|trace| match (trace).action {
|
||||
Reward(ref a) => a.reward_type == RewardType::Block,
|
||||
_ => false,
|
||||
}).collect();
|
||||
assert_eq!(block_reward_traces.len(), 3);
|
||||
let uncle_reward_traces: Vec<LocalizedTrace> = traces_vec.clone().into_iter().filter(|trace| match (trace).action {
|
||||
Reward(ref a) => a.reward_type == RewardType::Uncle,
|
||||
_ => false,
|
||||
}).collect();
|
||||
assert_eq!(uncle_reward_traces.len(), 1);
|
||||
let traces = client.filter_traces(filter);
|
||||
assert!(traces.is_some(), "Filtered traces should be present");
|
||||
let traces_vec = traces.unwrap();
|
||||
let block_reward_traces: Vec<LocalizedTrace> = traces_vec
|
||||
.clone()
|
||||
.into_iter()
|
||||
.filter(|trace| match (trace).action {
|
||||
Reward(ref a) => a.reward_type == RewardType::Block,
|
||||
_ => false,
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(block_reward_traces.len(), 3);
|
||||
let uncle_reward_traces: Vec<LocalizedTrace> = traces_vec
|
||||
.clone()
|
||||
.into_iter()
|
||||
.filter(|trace| match (trace).action {
|
||||
Reward(ref a) => a.reward_type == RewardType::Uncle,
|
||||
_ => false,
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(uncle_reward_traces.len(), 1);
|
||||
|
||||
// Test1. Check block filter
|
||||
let traces = client.block_traces(BlockId::Number(3));
|
||||
assert_eq!(traces.unwrap().len(), 3);
|
||||
// Test1. Check block filter
|
||||
let traces = client.block_traces(BlockId::Number(3));
|
||||
assert_eq!(traces.unwrap().len(), 3);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user