openethereum/crates/ethcore/src/tests/trace.rs
Dusan Stanivukovic 5e7086d54c
Sunce86/eip 1559 (#393)
* eip1559 hard fork activation

* eip1559 hard fork activation 2

* added new transaction type for eip1559

* added base fee field to block header

* fmt fix

* added base fee calculation. added block header validation against base fee

* fmt

* temporarily added modified transaction pool

* tx pool fix of PendingIterator

* tx pool fix of UnorderedIterator

* tx pool added test for set_scoring

* transaction pool changes

* added tests for eip1559 transaction and eip1559 receipt

* added test for eip1559 transaction execution

* block gas limit / block gas target handling

* base fee verification moved out of engine

* calculate_base_fee moved to EthereumMachine

* handling of base_fee_per_gas as part of seal

* handling of base_fee_per_gas changed. Different encoding/decoding of block header

* eip1559 transaction execution - gas price handling

* eip1559 transaction execution - verification, fee burning

* effectiveGasPrice removed from the receipt payload (specs)

* added support for 1559 txs in tx pool verification

* added Aleut test network configuration

* effective_tip_scaled replaced by typed_gas_price

* eip 3198 - Basefee opcode

* rpc - updated structs Block and Header

* rpc changes for 1559

* variable renaming according to spec

* - typed_gas_price renamed to effective_gas_price
- elasticity_multiplier definition moved to update_schedule()

* calculate_base_fee simplified

* Evm environment context temporary fix for gas limit

* fmt fix

* fixed fake_sign::sign_call

* temporary fix for GASLIMIT opcode to provide gas_target actually

* gas_target removed from block header according to spec change: https://github.com/ethereum/EIPs/pull/3566

* tx pool verification fix

* env_info base fee changed to Option

* fmt fix

* pretty format

* updated ethereum tests

* cache_pending refresh on each update of score

* code review fixes

* fmt fix

* code review fix - changed handling of eip1559_base_fee_max_change_denominator

* code review fix - modification.gas_price

* Skip gas_limit_bump for Aura

* gas_limit calculation changed to target ceil

* gas_limit calculation will target ceil on 1559 activation block

* transaction verification updated according spec: https://github.com/ethereum/EIPs/pull/3594

* updated json tests

* ethereum json tests fix for base_fee
2021-06-04 12:12:24 +02:00

257 lines
7.2 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/>.
//! Client tests of tracing
use block::*;
use client::{BlockChainClient, Client, ClientConfig, *};
use crypto::publickey::KeyPair;
use ethereum_types::{Address, U256};
use hash::keccak;
use io::*;
use miner::Miner;
use spec::*;
use std::{str::FromStr, sync::Arc};
use test_helpers::{self, get_temp_state_db};
use trace::{trace::Action::Reward, LocalizedTrace, RewardType};
use types::{
header::Header,
transaction::{Action, Transaction, TypedTransaction},
view,
views::BlockView,
};
use verification::queue::kind::blocks::Unverified;
#[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;
// 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
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 kp = KeyPair::from_secret_slice(keccak("").as_bytes()).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);
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(), spec.params().eip1559_transition).unwrap(),
) {
panic!(
"error importing block which is valid by definition: {:?}",
e
);
}
last_header =
view!(BlockView, &root_block.rlp_bytes()).header(spec.params().eip1559_transition);
let root_header = last_header.clone();
db = root_block.drain().state.drop().1;
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);
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(), spec.params().eip1559_transition).unwrap(),
) {
panic!(
"error importing block which is valid by definition: {:?}",
e
);
}
last_header =
view!(BlockView, &parent_block.rlp_bytes()).header(spec.params().eip1559_transition);
db = parent_block.drain().state.drop().1;
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);
let mut n = 0;
for _ in 0..1 {
block
.push_transaction(
TypedTransaction::Legacy(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::from_str("ef2d6d194084c2de36e0dabfce45d046b37d1106").unwrap();
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 res = client.import_block(
Unverified::from_rlp(block.rlp_bytes(), spec.params().eip1559_transition).unwrap(),
);
if res.is_err() {
panic!("error importing block: {:#?}", res.err().unwrap());
}
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,
};
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));
client.shutdown();
assert_eq!(traces.unwrap().len(), 3);
}