VM tracing and JSON RPC endpoint for it. (#1169)

* Groundwork for basic VM tracing.

* RPC endpoint for VM tracing and ser/de types ready.

* Create VMTracer trait.

* Rearchitected VM tracing to reflect existing tracing.

Should more or less work now.

* Integrated VM tracing into JSONRPC.

* Fix ethcore module tests.

* Add tests for VM tracing.

* Fix consensus test code.

* Fix mock tests.

* Added VM trace information for post-execution stuff.

* Fix max-value calls and add "creates" field to getTransaction.

* Tests for VM tracing.

* Don't implement the trait with unimplemented.

* Remove invlaid comment.

* Fix tests.

util/src/common.rs

@@ -24,6 +24,13 @@ pub use vector::*;
 pub use numbers::*;
 pub use sha3::*;
 
+#[macro_export]
+macro_rules! vec_into {
+	( $( $x:expr ),* ) => {
+		vec![ $( $x.into() ),* ]
+	}
+}
+
 #[macro_export]
 macro_rules! hash_map {
 	() => { HashMap::new() };

util/src/rlp/rlpstream.rs

@@ -338,6 +338,18 @@ impl<T> Encodable for Vec<T>  where T: Encodable {
 	}
 }
 
+impl<T> Encodable for Option<T>  where T: Encodable {
+	fn rlp_append(&self, s: &mut RlpStream) {
+		match *self {
+			None => { s.begin_list(0); },
+			Some(ref x) => {
+				s.begin_list(1);
+				s.append_internal(x);
+			}
+		}
+	}
+}
+
 impl<T> RlpEncodable for T where T: Encodable {
 	fn rlp_append(&self, s: &mut RlpStream) {
 		Encodable::rlp_append(self, s)

util/src/rlp/untrusted_rlp.rs

@@ -395,7 +395,7 @@ impl<'a> Decoder for BasicDecoder<'a> {
 }
 
 impl<T> Decodable for T where T: FromBytes {
-	fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
 		decoder.read_value(| bytes | {
 			Ok(try!(T::from_bytes(bytes)))
 		})
@@ -403,13 +403,19 @@ impl<T> Decodable for T where T: FromBytes {
 }
 
 impl<T> Decodable for Vec<T> where T: Decodable {
-	fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
 		decoder.as_rlp().iter().map(|d| T::decode(&BasicDecoder::new(d))).collect()
 	}
 }
 
+impl<T> Decodable for Option<T> where T: Decodable {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
+		decoder.as_rlp().iter().map(|d| T::decode(&BasicDecoder::new(d))).collect::<Result<Vec<_>, DecoderError>>().map(|mut a| a.pop())
+	}
+}
+
 impl Decodable for Vec<u8> {
-	fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
 		decoder.read_value(| bytes | {
 			let mut res = vec![];
 			res.extend_from_slice(bytes);
@@ -418,22 +424,10 @@ impl Decodable for Vec<u8> {
 	}
 }
 
-impl<T> Decodable for Option<T> where T: Decodable {
-	fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
-		decoder.read_value(| bytes | {
-			let res = match bytes.len() {
-				0 => None,
-				_ => Some(try!(T::decode(decoder)))
-			};
-			Ok(res)
-		})
-	}
-}
-
 macro_rules! impl_array_decodable {
 	($index_type:ty, $len:expr ) => (
 		impl<T> Decodable for [T; $len] where T: Decodable {
-			fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
+			fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
 				let decoders = decoder.as_rlp();
 
 				let mut result: [T; $len] = unsafe { ::std::mem::uninitialized() };
@@ -466,7 +460,7 @@ impl_array_decodable_recursive!(
 );
 
 impl<T> RlpDecodable for T where T: Decodable {
-	fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
 		Decodable::decode(decoder)
 	}
 }
@@ -489,7 +483,7 @@ impl FromBytes for DecodableU8 {
 }
 
 impl RlpDecodable for u8 {
-	fn decode<D>(decoder: &D) -> Result<Self, DecoderError>  where D: Decoder {
+	fn decode<D>(decoder: &D) -> Result<Self, DecoderError> where D: Decoder {
 		let u: DecodableU8 = try!(Decodable::decode(decoder));
 		Ok(u.0)
 	}