tracing backport

ethcore/src/account.rs

@@ -58,8 +58,8 @@ impl Account {
 			nonce: pod.nonce,
 			storage_root: SHA3_NULL_RLP,
 			storage_overlay: RefCell::new(pod.storage.into_iter().map(|(k, v)| (k, (Filth::Dirty, v))).collect()),
-			code_hash: Some(pod.code.sha3()),
-			code_cache: pod.code
+			code_hash: pod.code.as_ref().map(|c| c.sha3()),
+			code_cache: pod.code.as_ref().map_or_else(|| { warn!("POD account with unknown code is being created! Assuming no code."); vec![] }, |c| c.clone()),
 		}
 	}
 

ethcore/src/action_params.rs

@@ -17,6 +17,7 @@
 //! Evm input params.
 use common::*;
 use ethjson;
+use types::executed::CallType;
 
 /// Transaction value
 #[derive(Clone, Debug)]
@@ -58,7 +59,10 @@ pub struct ActionParams {
 	/// Code being executed.
 	pub code: Option<Bytes>,
 	/// Input data.
-	pub data: Option<Bytes>
+	pub data: Option<Bytes>,
+	/// Type of call
+	pub call_type: CallType,
+
 }
 
 impl Default for ActionParams {
@@ -73,23 +77,26 @@ impl Default for ActionParams {
 			gas_price: U256::zero(),
 			value: ActionValue::Transfer(U256::zero()),
 			code: None,
-			data: None
+			data: None,
+			call_type: CallType::None,
 		}
 	}
 }
 
 impl From<ethjson::vm::Transaction> for ActionParams {
 	fn from(t: ethjson::vm::Transaction) -> Self {
+		let address: Address = t.address.into();
 		ActionParams {
 			code_address: Address::new(),
-			address: t.address.into(),
+			address: address,
 			sender: t.sender.into(),
 			origin: t.origin.into(),
 			code: Some(t.code.into()),
 			data: Some(t.data.into()),
 			gas: t.gas.into(),
 			gas_price: t.gas_price.into(),
 			value: ActionValue::Transfer(t.value.into()),
+			call_type: match address.is_zero() { true => CallType::None, false => CallType::Call },	// TODO @debris is this correct?
 		}
 	}
 }

ethcore/src/block.rs

@@ -22,7 +22,7 @@ use common::*;
 use engine::*;
 use state::*;
 use verification::PreverifiedBlock;
-use trace::Trace;
+use trace::FlatTrace;
 use evm::Factory as EvmFactory;
 
 /// A block, encoded as it is on the block chain.
@@ -78,7 +78,7 @@ pub struct ExecutedBlock {
 	receipts: Vec<Receipt>,
 	transactions_set: HashSet<H256>,
 	state: State,
-	traces: Option<Vec<Trace>>,
+	traces: Option<Vec<Vec<FlatTrace>>>,
 }
 
 /// A set of references to `ExecutedBlock` fields that are publicly accessible.
@@ -94,7 +94,7 @@ pub struct BlockRefMut<'a> {
 	/// State.
 	pub state: &'a mut State,
 	/// Traces.
-	pub traces: &'a Option<Vec<Trace>>,
+	pub traces: &'a Option<Vec<Vec<FlatTrace>>>,
 }
 
 /// A set of immutable references to `ExecutedBlock` fields that are publicly accessible.
@@ -110,7 +110,7 @@ pub struct BlockRef<'a> {
 	/// State.
 	pub state: &'a State,
 	/// Traces.
-	pub traces: &'a Option<Vec<Trace>>,
+	pub traces: &'a Option<Vec<Vec<FlatTrace>>>,
 }
 
 impl ExecutedBlock {
@@ -171,7 +171,7 @@ pub trait IsBlock {
 	fn receipts(&self) -> &Vec<Receipt> { &self.block().receipts }
 
 	/// Get all information concerning transaction tracing in this block.
-	fn traces(&self) -> &Option<Vec<Trace>> { &self.block().traces }
+	fn traces(&self) -> &Option<Vec<Vec<FlatTrace>>> { &self.block().traces }
 
 	/// Get all uncles in this block.
 	fn uncles(&self) -> &Vec<Header> { &self.block().base.uncles }
@@ -329,7 +329,7 @@ impl<'x> OpenBlock<'x> {
 				self.block.transactions_set.insert(h.unwrap_or_else(||t.hash()));
 				self.block.base.transactions.push(t);
 				let t = outcome.trace;
-				self.block.traces.as_mut().map(|traces| traces.push(t.expect("self.block.traces.is_some(): so we must be tracing: qed")));
+				self.block.traces.as_mut().map(|traces| traces.push(t));
 				self.block.receipts.push(outcome.receipt);
 				Ok(&self.block.receipts.last().unwrap())
 			}

ethcore/src/client/client.rs

@@ -48,6 +48,9 @@ use receipt::LocalizedReceipt;
 pub use blockchain::CacheSize as BlockChainCacheSize;
 use trace::{TraceDB, ImportRequest as TraceImportRequest, LocalizedTrace, Database as TraceDatabase};
 use trace;
+use trace::FlatTransactionTraces;
+
+// re-export
 pub use types::blockchain_info::BlockChainInfo;
 pub use types::block_status::BlockStatus;
 use evm::Factory as EvmFactory;
@@ -361,8 +364,13 @@ impl Client {
 		};
 
 		// Commit results
-		let receipts = block.receipts().clone();
-		let traces = From::from(block.traces().clone().unwrap_or_else(Vec::new));
+		let receipts = block.receipts().to_owned();
+		let traces = block.traces().clone().unwrap_or_else(Vec::new);
+		let traces: Vec<FlatTransactionTraces> = traces.into_iter()
+			.map(Into::into)
+			.collect();
+
+		//let traces = From::from(block.traces().clone().unwrap_or_else(Vec::new));
 
 		// CHECK! I *think* this is fine, even if the state_root is equal to another
 		// already-imported block of the same number.
@@ -373,7 +381,7 @@ impl Client {
 		// (when something is in chain but you are not able to fetch details)
 		let route = self.chain.insert_block(block_data, receipts);
 		self.tracedb.import(TraceImportRequest {
-			traces: traces,
+			traces: traces.into(),
 			block_hash: hash.clone(),
 			block_number: number,
 			enacted: route.enacted.clone(),

ethcore/src/evm/ext.rs

@@ -18,6 +18,7 @@
 
 use util::common::*;
 use evm::{self, Schedule};
+use types::executed::CallType;
 use env_info::*;
 
 /// Result of externalities create function.
@@ -69,13 +70,15 @@ pub trait Ext {
 	/// and true if subcall was successfull.
 	#[cfg_attr(feature="dev", allow(too_many_arguments))]
 	fn call(&mut self,
-			gas: &U256,
-			sender_address: &Address,
-			receive_address: &Address,
-			value: Option<U256>,
-			data: &[u8],
-			code_address: &Address,
-			output: &mut [u8]) -> MessageCallResult;
+		gas: &U256,
+		sender_address: &Address,
+		receive_address: &Address,
+		value: Option<U256>,
+		data: &[u8],
+		code_address: &Address,
+		output: &mut [u8],
+		call_type: CallType
+	) -> MessageCallResult;
 
 	/// Returns code at given address
 	fn extcode(&self, address: &Address) -> Bytes;

ethcore/src/evm/interpreter.rs

@@ -20,6 +20,7 @@ use common::*;
 use super::instructions as instructions;
 use super::instructions::{Instruction, get_info};
 use std::marker::Copy;
+use types::executed::CallType;
 use evm::{self, MessageCallResult, ContractCreateResult, GasLeft};
 
 #[cfg(not(feature = "evm-debug"))]
@@ -648,16 +649,16 @@ impl Interpreter {
 				});
 
 				// Get sender & receive addresses, check if we have balance
-				let (sender_address, receive_address, has_balance) = match instruction {
+				let (sender_address, receive_address, has_balance, call_type) = match instruction {
 					instructions::CALL => {
 						let has_balance = ext.balance(&params.address) >= value.unwrap();
-						(&params.address, &code_address, has_balance)
+						(&params.address, &code_address, has_balance, CallType::Call)
 					},
 					instructions::CALLCODE => {
 						let has_balance = ext.balance(&params.address) >= value.unwrap();
-						(&params.address, &params.address, has_balance)
+						(&params.address, &params.address, has_balance, CallType::CallCode)
 					},
-					instructions::DELEGATECALL => (&params.sender, &params.address, true),
+					instructions::DELEGATECALL => (&params.sender, &params.address, true, CallType::DelegateCall),
 					_ => panic!(format!("Unexpected instruction {} in CALL branch.", instruction))
 				};
 
@@ -672,7 +673,7 @@ impl Interpreter {
 					// and we don't want to copy
 					let input = unsafe { ::std::mem::transmute(self.mem.read_slice(in_off, in_size)) };
 					let output = self.mem.writeable_slice(out_off, out_size);
-					ext.call(&call_gas, sender_address, receive_address, value, input, &code_address, output)
+					ext.call(&call_gas, sender_address, receive_address, value, input, &code_address, output, call_type)
 				};
 
 				return match call_result {

ethcore/src/evm/tests.rs

@@ -15,6 +15,7 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use common::*;
+use types::executed::CallType;
 use evm::{self, Ext, Schedule, Factory, GasLeft, VMType, ContractCreateResult, MessageCallResult};
 use std::fmt::Debug;
 
@@ -36,7 +37,7 @@ struct FakeCall {
 	receive_address: Option<Address>,
 	value: Option<U256>,
 	data: Bytes,
-	code_address: Option<Address>
+	code_address: Option<Address>,
 }
 
 /// Fake externalities test structure.
@@ -119,7 +120,9 @@ impl Ext for FakeExt {
 			value: Option<U256>,
 			data: &[u8],
 			code_address: &Address,
-			_output: &mut [u8]) -> MessageCallResult {
+			_output: &mut [u8],
+			_call_type: CallType
+		) -> MessageCallResult {
 
 		self.calls.insert(FakeCall {
 			call_type: FakeCallType::Call,