openethereum/evmbin/src/main.rs

159 lines
4.0 KiB
Rust
Raw Normal View History

// Copyright 2015-2017 Parity Technologies (UK) Ltd.
// This file is part of Parity.
// Parity 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.
// Parity 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 Parity. If not, see <http://www.gnu.org/licenses/>.
//! Parity EVM interpreter binary.
#![warn(missing_docs)]
#![allow(dead_code)]
extern crate ethcore;
2017-07-06 11:36:15 +02:00
extern crate rustc_hex;
extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate docopt;
extern crate ethcore_util as util;
extern crate evm;
2016-10-17 11:55:47 +02:00
use std::sync::Arc;
use std::{fmt, fs};
use docopt::Docopt;
2017-07-06 11:36:15 +02:00
use rustc_hex::FromHex;
use util::{U256, Bytes, Address};
use ethcore::spec;
use evm::action_params::ActionParams;
mod vm;
mod display;
use vm::Informant;
const USAGE: &'static str = r#"
EVM implementation for Parity.
Copyright 2016, 2017 Parity Technologies (UK) Ltd
Usage:
evmbin stats [options]
evmbin [options]
evmbin [-h | --help]
Transaction options:
--code CODE Contract code as hex (without 0x).
--from ADDRESS Sender address (without 0x).
--input DATA Input data as hex (without 0x).
--gas GAS Supplied gas as hex (without 0x).
General options:
--json Display verbose results in JSON.
--chain CHAIN Chain spec file path.
-h, --help Display this message and exit.
"#;
fn main() {
2017-07-06 11:36:15 +02:00
let args: Args = Docopt::new(USAGE).and_then(|d| d.deserialize()).unwrap_or_else(|e| e.exit());
if args.flag_json {
run(args, display::json::Informant::default())
} else {
run(args, display::simple::Informant::default())
}
}
fn run<T: Informant>(args: Args, mut informant: T) {
let from = arg(args.from(), "--from");
let code = arg(args.code(), "--code");
let spec = arg(args.spec(), "--chain");
let gas = arg(args.gas(), "--gas");
let data = arg(args.data(), "--input");
let mut params = ActionParams::default();
params.sender = from;
params.origin = from;
params.gas = gas;
params.code = Some(Arc::new(code));
params.data = data;
informant.set_gas(gas);
let result = vm::run(&mut informant, spec, params);
informant.finish(result);
}
2017-07-06 11:36:15 +02:00
#[derive(Debug, Deserialize)]
struct Args {
cmd_stats: bool,
flag_from: Option<String>,
flag_code: Option<String>,
flag_gas: Option<String>,
flag_input: Option<String>,
flag_spec: Option<String>,
flag_json: 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::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 code(&self) -> Result<Bytes, String> {
match self.flag_code {
Some(ref code) => code.from_hex().map_err(to_string),
None => Err("Code is required!".into()),
}
}
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_spec {
Some(ref filename) => {
let file = fs::File::open(filename).map_err(|e| format!("{}", e))?;
2017-07-11 10:21:23 +02:00
spec::Spec::load(::std::env::temp_dir(), file)?
},
None => {
2017-07-11 10:21:23 +02:00
ethcore::ethereum::new_foundation(&::std::env::temp_dir())
},
})
}
}
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)
}