501 lines
16 KiB
Rust
501 lines
16 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/>.
|
|
|
|
//! OpenEthereum EVM interpreter binary.
|
|
|
|
#![warn(missing_docs)]
|
|
|
|
extern crate common_types as types;
|
|
extern crate ethcore;
|
|
extern crate ethjson;
|
|
extern crate rustc_hex;
|
|
extern crate serde;
|
|
#[macro_use]
|
|
extern crate serde_derive;
|
|
#[macro_use]
|
|
extern crate serde_json;
|
|
extern crate docopt;
|
|
extern crate env_logger;
|
|
extern crate ethereum_types;
|
|
extern crate evm;
|
|
extern crate panic_hook;
|
|
extern crate parity_bytes as bytes;
|
|
extern crate vm;
|
|
|
|
#[cfg(test)]
|
|
#[macro_use]
|
|
extern crate pretty_assertions;
|
|
|
|
#[cfg(test)]
|
|
extern crate tempdir;
|
|
|
|
use bytes::Bytes;
|
|
use docopt::Docopt;
|
|
use ethcore::{json_tests, spec, TrieSpec};
|
|
use ethereum_types::{Address, U256};
|
|
use rustc_hex::FromHex;
|
|
use std::{fmt, fs, path::PathBuf, sync::Arc};
|
|
use vm::{ActionParams, CallType};
|
|
|
|
mod display;
|
|
mod info;
|
|
|
|
use info::Informant;
|
|
|
|
const USAGE: &'static str = r#"
|
|
EVM implementation for Parity.
|
|
Copyright 2015-2020 Parity Technologies (UK) Ltd.
|
|
|
|
Usage:
|
|
openethereum-evm state-test <file> [--json --std-json --std-dump-json --only NAME --chain CHAIN --std-out-only --std-err-only --omit-storage-output --omit-memory-output]
|
|
openethereum-evm stats [options]
|
|
openethereum-evm stats-jsontests-vm <file>
|
|
openethereum-evm [options]
|
|
openethereum-evm [-h | --help]
|
|
|
|
Commands:
|
|
state-test Run a state test from a json file.
|
|
stats Execute EVM runtime code and return the statistics.
|
|
stats-jsontests-vm Execute standard json-tests format VMTests and return
|
|
timing statistics in tsv format.
|
|
|
|
Transaction options:
|
|
--code CODE Contract code as hex (without 0x).
|
|
--to ADDRESS Recipient address (without 0x).
|
|
--from ADDRESS Sender address (without 0x).
|
|
--input DATA Input data as hex (without 0x).
|
|
--gas GAS Supplied gas as hex (without 0x).
|
|
--gas-price WEI Supplied gas price as hex (without 0x).
|
|
|
|
State test options:
|
|
--chain CHAIN Run only from specific chain name (i.e. one of EIP150, EIP158,
|
|
Frontier, Homestead, Byzantium, Constantinople,
|
|
ConstantinopleFix, Istanbul, EIP158ToByzantiumAt5, FrontierToHomesteadAt5,
|
|
HomesteadToDaoAt5, HomesteadToEIP150At5, Berlin, Yolo3).
|
|
--only NAME Runs only a single test matching the name.
|
|
|
|
General options:
|
|
--json Display verbose results in JSON.
|
|
--std-json Display results in standardized JSON format.
|
|
--std-err-only With --std-json redirect to err output only.
|
|
--std-out-only With --std-json redirect to out output only.
|
|
--omit-storage-output With --std-json omit storage output.
|
|
--omit-memory-output With --std-json omit memory output.
|
|
--std-dump-json Display results in standardized JSON format
|
|
with additional state dump.
|
|
|
|
Display result state dump in standardized JSON format.
|
|
--chain CHAIN Chain spec file path.
|
|
-h, --help Display this message and exit.
|
|
"#;
|
|
|
|
fn main() {
|
|
panic_hook::set_abort();
|
|
env_logger::init();
|
|
|
|
let args: Args = Docopt::new(USAGE)
|
|
.and_then(|d| d.deserialize())
|
|
.unwrap_or_else(|e| e.exit());
|
|
|
|
let config = args.config();
|
|
|
|
if args.cmd_state_test {
|
|
run_state_test(args)
|
|
} else if args.cmd_stats_jsontests_vm {
|
|
run_stats_jsontests_vm(args)
|
|
} else if args.flag_json {
|
|
run_call(args, display::json::Informant::new(config))
|
|
} else if args.flag_std_dump_json || args.flag_std_json {
|
|
if args.flag_std_err_only {
|
|
run_call(args, display::std_json::Informant::err_only(config))
|
|
} else if args.flag_std_out_only {
|
|
run_call(args, display::std_json::Informant::out_only(config))
|
|
} else {
|
|
run_call(args, display::std_json::Informant::new_default(config))
|
|
};
|
|
} else {
|
|
run_call(args, display::simple::Informant::new(config))
|
|
}
|
|
}
|
|
|
|
fn run_stats_jsontests_vm(args: Args) {
|
|
use json_tests::HookType;
|
|
use std::{
|
|
collections::HashMap,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
let file = args.arg_file.expect("FILE (or PATH) is required");
|
|
|
|
let mut timings: HashMap<String, (Instant, Option<Duration>)> = HashMap::new();
|
|
|
|
{
|
|
let mut record_time = |name: &str, typ: HookType| match typ {
|
|
HookType::OnStart => {
|
|
timings.insert(name.to_string(), (Instant::now(), None));
|
|
}
|
|
HookType::OnStop => {
|
|
timings.entry(name.to_string()).and_modify(|v| {
|
|
v.1 = Some(v.0.elapsed());
|
|
});
|
|
}
|
|
};
|
|
for file_path in json_tests::find_json_files_recursive(&file) {
|
|
let json_data = std::fs::read(&file_path).unwrap();
|
|
json_tests::json_executive_test(&file_path, &json_data, &mut record_time);
|
|
}
|
|
}
|
|
|
|
for (name, v) in timings {
|
|
println!(
|
|
"{}\t{}",
|
|
name,
|
|
display::as_micros(&v.1.expect("All hooks are called with OnStop; qed"))
|
|
);
|
|
}
|
|
}
|
|
|
|
fn run_state_test(args: Args) {
|
|
use ethjson::state::test::Test;
|
|
let config = args.config();
|
|
let file = args.arg_file.expect("FILE is required");
|
|
let mut file = match fs::File::open(&file) {
|
|
Err(err) => die(format!("Unable to open: {:?}: {}", file, err)),
|
|
Ok(file) => file,
|
|
};
|
|
let state_test = match Test::load(&mut file) {
|
|
Err(err) => die(format!("Unable to load the test file: {}", err)),
|
|
Ok(test) => test,
|
|
};
|
|
let only_test = args.flag_only.map(|s| s.to_lowercase());
|
|
let only_chain = args.flag_chain.map(|s| s.to_lowercase());
|
|
|
|
for (name, test) in state_test {
|
|
if let Some(false) = only_test
|
|
.as_ref()
|
|
.map(|only_test| &name.to_lowercase() == only_test)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
let multitransaction = test.transaction;
|
|
let env_info = test.env.into();
|
|
let pre = test.pre_state.into();
|
|
|
|
for (spec, states) in test.post_states {
|
|
if let Some(false) = only_chain
|
|
.as_ref()
|
|
.map(|only_chain| &format!("{:?}", spec).to_lowercase() == only_chain)
|
|
{
|
|
continue;
|
|
}
|
|
for (idx, state) in states.into_iter().enumerate() {
|
|
let post_root = state.hash.into();
|
|
let transaction = multitransaction.select(&state.indexes).into();
|
|
|
|
let trie_spec = if args.flag_std_dump_json {
|
|
TrieSpec::Fat
|
|
} else {
|
|
TrieSpec::Secure
|
|
};
|
|
if args.flag_json {
|
|
info::run_transaction(
|
|
&name,
|
|
idx,
|
|
&spec,
|
|
&pre,
|
|
post_root,
|
|
&env_info,
|
|
transaction,
|
|
display::json::Informant::new(config),
|
|
trie_spec,
|
|
)
|
|
} else if args.flag_std_dump_json || args.flag_std_json {
|
|
if args.flag_std_err_only {
|
|
info::run_transaction(
|
|
&name,
|
|
idx,
|
|
&spec,
|
|
&pre,
|
|
post_root,
|
|
&env_info,
|
|
transaction,
|
|
display::std_json::Informant::err_only(config),
|
|
trie_spec,
|
|
)
|
|
} else if args.flag_std_out_only {
|
|
info::run_transaction(
|
|
&name,
|
|
idx,
|
|
&spec,
|
|
&pre,
|
|
post_root,
|
|
&env_info,
|
|
transaction,
|
|
display::std_json::Informant::out_only(config),
|
|
trie_spec,
|
|
)
|
|
} else {
|
|
info::run_transaction(
|
|
&name,
|
|
idx,
|
|
&spec,
|
|
&pre,
|
|
post_root,
|
|
&env_info,
|
|
transaction,
|
|
display::std_json::Informant::new_default(config),
|
|
trie_spec,
|
|
)
|
|
}
|
|
} else {
|
|
info::run_transaction(
|
|
&name,
|
|
idx,
|
|
&spec,
|
|
&pre,
|
|
post_root,
|
|
&env_info,
|
|
transaction,
|
|
display::simple::Informant::new(config),
|
|
trie_spec,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn run_call<T: Informant>(args: Args, informant: T) {
|
|
let from = arg(args.from(), "--from");
|
|
let to = arg(args.to(), "--to");
|
|
let code = arg(args.code(), "--code");
|
|
let spec = arg(args.spec(), "--chain");
|
|
let gas = arg(args.gas(), "--gas");
|
|
let gas_price = arg(args.gas_price(), "--gas-price");
|
|
let data = arg(args.data(), "--input");
|
|
|
|
if code.is_none() && to == Address::default() {
|
|
die("Either --code or --to is required.");
|
|
}
|
|
let mut params = ActionParams::default();
|
|
if spec.engine.params().eip2929_transition == 0 {
|
|
params.access_list.enable();
|
|
params.access_list.insert_address(from);
|
|
params.access_list.insert_address(to);
|
|
for (builtin, _) in spec.engine.builtins() {
|
|
params.access_list.insert_address(*builtin);
|
|
}
|
|
}
|
|
|
|
params.call_type = if code.is_none() {
|
|
CallType::Call
|
|
} else {
|
|
CallType::None
|
|
};
|
|
params.code_address = to;
|
|
params.address = to;
|
|
params.sender = from;
|
|
params.origin = from;
|
|
params.gas = gas;
|
|
params.gas_price = gas_price;
|
|
params.code = code.map(Arc::new);
|
|
params.data = data;
|
|
|
|
let mut sink = informant.clone_sink();
|
|
let result = if args.flag_std_dump_json {
|
|
info::run_action(&spec, params, informant, TrieSpec::Fat)
|
|
} else {
|
|
info::run_action(&spec, params, informant, TrieSpec::Secure)
|
|
};
|
|
T::finish(result, &mut sink);
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct Args {
|
|
cmd_stats: bool,
|
|
cmd_state_test: bool,
|
|
cmd_stats_jsontests_vm: bool,
|
|
arg_file: Option<PathBuf>,
|
|
flag_only: Option<String>,
|
|
flag_from: Option<String>,
|
|
flag_to: Option<String>,
|
|
flag_code: Option<String>,
|
|
flag_gas: Option<String>,
|
|
flag_gas_price: Option<String>,
|
|
flag_input: Option<String>,
|
|
flag_chain: Option<String>,
|
|
flag_json: bool,
|
|
flag_std_json: bool,
|
|
flag_std_dump_json: bool,
|
|
flag_std_err_only: bool,
|
|
flag_std_out_only: bool,
|
|
flag_omit_storage_output: bool,
|
|
flag_omit_memory_output: bool,
|
|
}
|
|
|
|
impl Args {
|
|
pub fn gas(&self) -> Result<U256, String> {
|
|
match self.flag_gas {
|
|
Some(ref gas) => gas.parse().map_err(to_string),
|
|
None => Ok(U256::from(u64::max_value())),
|
|
}
|
|
}
|
|
|
|
pub fn gas_price(&self) -> Result<U256, String> {
|
|
match self.flag_gas_price {
|
|
Some(ref gas_price) => gas_price.parse().map_err(to_string),
|
|
None => Ok(U256::zero()),
|
|
}
|
|
}
|
|
|
|
pub fn from(&self) -> Result<Address, String> {
|
|
match self.flag_from {
|
|
Some(ref from) => from.parse().map_err(to_string),
|
|
None => Ok(Address::default()),
|
|
}
|
|
}
|
|
|
|
pub fn to(&self) -> Result<Address, String> {
|
|
match self.flag_to {
|
|
Some(ref to) => to.parse().map_err(to_string),
|
|
None => Ok(Address::default()),
|
|
}
|
|
}
|
|
|
|
pub fn code(&self) -> Result<Option<Bytes>, String> {
|
|
match self.flag_code {
|
|
Some(ref code) => code.from_hex().map(Some).map_err(to_string),
|
|
None => Ok(None),
|
|
}
|
|
}
|
|
|
|
pub fn data(&self) -> Result<Option<Bytes>, String> {
|
|
match self.flag_input {
|
|
Some(ref input) => input.from_hex().map_err(to_string).map(Some),
|
|
None => Ok(None),
|
|
}
|
|
}
|
|
|
|
pub fn spec(&self) -> Result<spec::Spec, String> {
|
|
Ok(match self.flag_chain {
|
|
Some(ref spec_name) => {
|
|
let fork_spec: Result<ethjson::spec::ForkSpec, _> =
|
|
serde_json::from_str(&format!("{:?}", spec_name));
|
|
if let Ok(fork_spec) = fork_spec {
|
|
ethcore::client::EvmTestClient::spec_from_json(&fork_spec)
|
|
.expect("this forkspec is not defined")
|
|
} else {
|
|
let file = fs::File::open(spec_name).map_err(|e| format!("{}", e))?;
|
|
spec::Spec::load(&::std::env::temp_dir(), file)?
|
|
}
|
|
}
|
|
None => ethcore::ethereum::new_foundation(&::std::env::temp_dir()),
|
|
})
|
|
}
|
|
|
|
pub fn config(&self) -> display::config::Config {
|
|
display::config::Config::new(self.flag_omit_storage_output, self.flag_omit_memory_output)
|
|
}
|
|
}
|
|
|
|
fn arg<T>(v: Result<T, String>, param: &str) -> T {
|
|
v.unwrap_or_else(|e| die(format!("Invalid {}: {}", param, e)))
|
|
}
|
|
|
|
fn to_string<T: fmt::Display>(msg: T) -> String {
|
|
format!("{}", msg)
|
|
}
|
|
|
|
fn die<T: fmt::Display>(msg: T) -> ! {
|
|
println!("{}", msg);
|
|
::std::process::exit(-1)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::{Args, USAGE};
|
|
use docopt::Docopt;
|
|
|
|
fn run<T: AsRef<str>>(args: &[T]) -> Args {
|
|
Docopt::new(USAGE)
|
|
.and_then(|d| d.argv(args.into_iter()).deserialize())
|
|
.unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn should_parse_all_the_options() {
|
|
let args = run(&[
|
|
"openethereum-evm",
|
|
"--json",
|
|
"--std-json",
|
|
"--std-dump-json",
|
|
"--gas",
|
|
"1",
|
|
"--gas-price",
|
|
"2",
|
|
"--from",
|
|
"0000000000000000000000000000000000000003",
|
|
"--to",
|
|
"0000000000000000000000000000000000000004",
|
|
"--code",
|
|
"05",
|
|
"--input",
|
|
"06",
|
|
"--chain",
|
|
"./testfile",
|
|
"--std-err-only",
|
|
"--std-out-only",
|
|
]);
|
|
|
|
assert_eq!(args.flag_json, true);
|
|
assert_eq!(args.flag_std_json, true);
|
|
assert_eq!(args.flag_std_dump_json, true);
|
|
assert_eq!(args.flag_std_err_only, true);
|
|
assert_eq!(args.flag_std_out_only, true);
|
|
assert_eq!(args.gas(), Ok(1.into()));
|
|
assert_eq!(args.gas_price(), Ok(2.into()));
|
|
assert_eq!(args.from(), Ok(3.into()));
|
|
assert_eq!(args.to(), Ok(4.into()));
|
|
assert_eq!(args.code(), Ok(Some(vec![05])));
|
|
assert_eq!(args.data(), Ok(Some(vec![06])));
|
|
assert_eq!(args.flag_chain, Some("./testfile".to_owned()));
|
|
}
|
|
|
|
#[test]
|
|
fn should_parse_state_test_command() {
|
|
let args = run(&[
|
|
"openethereum-evm",
|
|
"state-test",
|
|
"./file.json",
|
|
"--chain",
|
|
"homestead",
|
|
"--only=add11",
|
|
"--json",
|
|
"--std-json",
|
|
"--std-dump-json",
|
|
]);
|
|
|
|
assert_eq!(args.cmd_state_test, true);
|
|
assert!(args.arg_file.is_some());
|
|
assert_eq!(args.flag_json, true);
|
|
assert_eq!(args.flag_std_json, true);
|
|
assert_eq!(args.flag_std_dump_json, true);
|
|
assert_eq!(args.flag_chain, Some("homestead".to_owned()));
|
|
assert_eq!(args.flag_only, Some("add11".to_owned()));
|
|
}
|
|
}
|