openethereum/src/evm/executive.rs

use util::hash::*;
use util::uint::*;
use util::rlp::*;
use util::sha3::*;
use util::bytes::*;
use state::*;
use env_info::*;
use engine::*;
use transaction::*;
use evm::{VmFactory, Ext, LogEntry, EvmParams, ParamsKind, ReturnCode};

/// Returns new address created from address and given nonce.
pub fn contract_address(address: &Address, nonce: &U256) -> Address {
	let mut stream = RlpStream::new_list(2);
	stream.append(address);
	stream.append(nonce);
	From::from(stream.out().sha3())
}

#[derive(PartialEq, Debug)]
pub enum ExecutiveResult {
	Ok,
	OutOfGas,
	InternalError
}

pub struct Executive<'a> {
	state: &'a mut State,
	info: &'a EnvInfo,
	engine: &'a Engine,
	depth: usize,
	params: EvmParams,

	logs: Vec<LogEntry>,
	refunds: U256,
}

impl<'a> Executive<'a> {
	pub fn new(state: &'a mut State, info: &'a EnvInfo, engine: &'a Engine, t: &Transaction) -> Self {
		// TODO: validate nonce ?
		
		let sender = t.sender();

		let params = match t.kind() {
			TransactionKind::ContractCreation => EvmParams {
				address: contract_address(&sender, &t.nonce),
				sender: sender.clone(),
				origin: sender.clone(),
				gas: t.gas,
				gas_price: t.gas_price,
				value: t.value,
				code: t.data.clone(),
				data: vec![],
				kind: ParamsKind::Create
			},
			TransactionKind::MessageCall => EvmParams {
				address: t.to.clone().unwrap(),
				sender: sender.clone(),
				origin: sender.clone(),
				gas: t.gas,
				gas_price: t.gas_price,
				value: t.value,
				code: state.code(&t.to.clone().unwrap()).unwrap_or(vec![]),
				data: t.data.clone(),
				kind: ParamsKind::Call
			}
		};

		Executive::new_from_params(state, info, engine, params)
	}

	pub fn new_from_params(state: &'a mut State, info: &'a EnvInfo, engine: &'a Engine, params: EvmParams) -> Self {
		Executive {
			state: state,
			info: info,
			engine: engine,
			depth: 0,
			params: params,
			logs: vec![],
			refunds: U256::zero(),
		}
	}

	fn from_parent(e: &'a mut Executive, params: EvmParams) -> Self {
		Executive {
			state: e.state,
			info: e.info,
			engine: e.engine,
			depth: e.depth + 1,
			params: params,
			logs: vec![],
			refunds: U256::zero(),
		}
	}

	pub fn exec(&mut self) -> ExecutiveResult {
		// TODO: validate that we have enough funds

		match &self.params.kind() {
			&ParamsKind::Call => { 
				self.state.inc_nonce(&self.params.address);
				self.call()
			},
			&ParamsKind::Create => self.create()
		}
	}

	fn call(&mut self) -> ExecutiveResult {
		ExecutiveResult::Ok
	}

	fn create(&mut self) -> ExecutiveResult {
		self.state.inc_nonce(&self.params.sender);
	
		//self.state.require_or_from(&self.params.address, false, ||Account::new_contract(U256::from(0)));
		self.state.transfer_balance(&self.params.sender, &self.params.address, &self.params.value);
		let code = {
			let evm = VmFactory::create();
			// TODO: valdidate that exec returns proper code
			evm.exec(self)
		};

		match code {
			ReturnCode::Stop => {  //| ReturnCode::Return => {
				//println!("code: {:?}", code);
				//self.state.set_code(&self.params.address, self.params.code.clone());
				ExecutiveResult::Ok
			},
			ReturnCode::Return => {
				//self.state.transfer_balance(&self.params.sender, &self.params.address, &self.params.value);
				//self.state.set_code(&self.params.address, self.params.code.clone());
				ExecutiveResult::Ok
			},
			ReturnCode::OutOfGas => {
				ExecutiveResult::OutOfGas
			},
			err => {
				ExecutiveResult::InternalError
			}
		}
	}

	pub fn logs(&self) -> &[LogEntry] {
		&self.logs
	}
}

impl<'a> Ext for Executive<'a> {
	fn params(&self) -> &EvmParams {
		&self.params
	}

	fn sload(&self, key: &H256) -> H256 {
		self.state.storage_at(&self.params.address, key)
	}

	fn sstore(&mut self, key: H256, value: H256) {
		if value == H256::new() && self.state.storage_at(&self.params.address, &key) != H256::new() {
			self.refunds = self.refunds + U256::from(self.engine.evm_schedule(self.info).sstore_refund_gas);
		}
		self.state.set_storage(&self.params.address, key, value)
	}

	fn balance(&self, address: &Address) -> U256 {
		self.state.balance(address)
	}

	fn blockhash(&self, number: &U256) -> H256 {
		match *number < self.info.number {
			false => H256::from(&U256::zero()),
			true => {
				let index = self.info.number - *number - U256::one();
				self.info.last_hashes[index.low_u32() as usize].clone()
			}
		}
	}

	fn create(&mut self, gas: u64, endowment: &U256, code: &[u8]) -> (Address, u64) {
		match self.state.balance(&self.params.address) >= *endowment && self.depth < 1024 {
			false => (Address::new(), gas),
			true => {
				let address = contract_address(&self.params.address, &self.state.nonce(&self.params.address));
				let params = EvmParams {
					address: address.clone(),
					sender: self.params.address.clone(),
					origin: self.params.origin.clone(),
					gas: U256::from(gas),
					gas_price: self.params.gas_price.clone(),
					value: endowment.clone(),
					code: code.to_vec(),
					data: vec![],
					kind: ParamsKind::Create
				};
				println!("address: {:?}", address);
				println!("code: {:?}", code);
				let mut ex = Executive::from_parent(self, params);
				let res = ex.create();
				println!("res: {:?}", res);
				(address, gas)
			}
		}
	}

	fn call(&mut self, gas: u64, call_gas: u64, receive_address: &Address, value: &U256, data: &[u8], code_address: &Address) -> Option<(Vec<u8>, u64)>{
		// TODO: validation of the call
		
		let params = EvmParams {
			address: code_address.clone(),
			sender: receive_address.clone(),
			origin: self.params.origin.clone(),
			gas: U256::from(call_gas), // TODO: 
			gas_price: self.params.gas_price.clone(),
			value: value.clone(),
			code: self.state.code(code_address).unwrap_or(vec![]),
			data: data.to_vec(),
			kind: ParamsKind::Call
		};

		{
			let mut ex = Executive::from_parent(self, params);
			ex.call();
			unimplemented!();
			
		}
	}

	fn extcode(&self, address: &Address) -> Vec<u8> {
		self.state.code(address).unwrap_or(vec![])
	}

	fn log(&mut self, topics: Vec<H256>, data: Bytes) {
		let address = self.params.address.clone();
		self.logs.push(LogEntry::new(address, topics, data));
	}

}

#[cfg(test)]
mod tests {
	use rustc_serialize::hex::FromHex;
	use std::str::FromStr;
	use util::hash::*;
	use util::uint::*;
	use evm::*;
	use transaction::*;
	use env_info::*;
	use state::*;
	use spec::*;
	use engine::*;
	use evm_schedule::*;
	use super::contract_address;

	struct TestEngine {
		spec: Spec
	}

	impl TestEngine {
		fn new() -> Self {
			TestEngine {
				spec: Spec::new_like_frontier()
			}
		}
	}

	impl Engine for TestEngine {
		fn name(&self) -> &str { "TestEngine" }
		fn spec(&self) -> &Spec { &self.spec }
		fn evm_schedule(&self, _env_info: &EnvInfo) -> EvmSchedule { EvmSchedule::new_frontier() }
	}

	#[test]
	fn test_contract_address() {
		let address = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
		let expected_address = Address::from_str("3f09c73a5ed19289fb9bdc72f1742566df146f56").unwrap();
		assert_eq!(expected_address, contract_address(&address, &U256::from(88)));
	}

	#[test]
	// TODO: replace params with transactions!
	fn test_executive() {
		let sender = Address::from_str("0f572e5295c57f15886f9b263e2f6d2d6c7b5ec6").unwrap();
		let address = contract_address(&sender, &U256::zero());
		let mut params = EvmParams::new_create();
		params.address = address.clone();
		params.sender = sender.clone();
		params.gas = U256::from(0x174876e800u64);
		params.code = "3331600055".from_hex().unwrap();
		params.value = U256::from(0x7);
		let mut state = State::new_temp();
		state.add_balance(&sender, &U256::from(0x100u64));
		let info = EnvInfo::new();
		let engine = TestEngine::new();

		{
			let mut ex = Executive::new_from_params(&mut state, &info, &engine, params);
			assert_eq!(ex.exec(), ExecutiveResult::Ok);
		}

		assert_eq!(state.storage_at(&address, &H256::new()), H256::from(&U256::from(0xf9u64)));
		assert_eq!(state.balance(&sender), U256::from(0xf9));
		assert_eq!(state.balance(&address), U256::from(0x7));
	}

	#[test]
	fn test_create_contract() {
		let sender = Address::from_str("cd1722f3947def4cf144679da39c4c32bdc35681").unwrap();
		let address = contract_address(&sender, &U256::zero());
		let next_address = contract_address(&address, &U256::zero());
		println!("address: {:?}", address);
		println!("next address: {:?}", next_address);
		let mut params = EvmParams::new_create();
		params.address = address.clone();
		params.sender = sender.clone();
		params.origin = sender.clone();
		params.gas = U256::from(0x174876e800u64);
		params.code = "7c601080600c6000396000f3006000355415600957005b60203560003555600052601d60036000f0600055".from_hex().unwrap();
		let mut state = State::new_temp();
		state.add_balance(&sender, &U256::from(0x100u64));
		let info = EnvInfo::new();
		let engine = TestEngine::new();

		{
			let mut ex = Executive::new_from_params(&mut state, &info, &engine, params);
			assert_eq!(ex.exec(), ExecutiveResult::Ok);
		}
		
		assert_eq!(state.storage_at(&address, &H256::new()), H256::from(next_address.clone()));
		//assert_eq!(state.code(&next_address).unwrap(), "601080600c6000396000f3006000355415600957005b602035600035".from_hex().unwrap());
		//assert!(false);
	}
}