more tests

Author: ermalkaleci

Makefile

@@ -150,7 +150,7 @@ test-eth: githooks test-evm
 
 .PHONY: test-evm
 test-evm: githooks
-	SKIP_WASM_BUILD= ${cargo_test} -p module-evm --features tracing
+	SKIP_WASM_BUILD= ${cargo_test} -p module-evm -p module-evm-bridge --features tracing
 	SKIP_WASM_BUILD= ${cargo_test} --release -p evm-jsontests --features evm-tests
 
 .PHONY: test-runtimes

modules/evm-bridge/Cargo.toml

@@ -59,3 +59,4 @@ try-runtime = [
 	"frame-system/try-runtime",
 	"module-evm/try-runtime",
 ]
+tracing = ["module-evm/tracing"]

modules/evm-bridge/src/tests.rs

@@ -353,3 +353,81 @@ fn liquidation_err_fails_as_expected() {
 			);
 		});
 }
+
+#[cfg(feature = "tracing")]
+#[test]
+fn tracing_should_work() {
+	use module_evm::runner::tracing;
+	use primitives::evm::tracing::TracerConfig;
+
+	ExtBuilder::default()
+		.balances(vec![(alice(), 1_000_000_000_000), (bob(), 1_000_000_000_000)])
+		.build()
+		.execute_with(|| {
+			deploy_contracts();
+			let mut tracer = tracing::Tracer::new(TracerConfig::CallTracer);
+			tracing::using(&mut tracer, || {
+				assert_err!(
+					EVMBridge::<Runtime>::transfer(
+						InvokeContext {
+							contract: erc20_address(),
+							sender: bob_evm_addr(),
+							origin: bob_evm_addr(),
+						},
+						alice_evm_addr(),
+						10
+					),
+					Error::<Runtime>::ExecutionRevert
+				);
+			});
+			let expected = r#"[
+			  {
+				"type": "CALL",
+				"from": "0x1000000000000000000000000000000000000002",
+				"to": "0x5dddfce53ee040d9eb21afbc0ae1bb4dbb0ba643",
+				"input": "0xa9059cbb0000000000000000000000001000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000a",
+				"value": "0x0",
+				"gas": 200000,
+				"gasUsed": 200000,
+				"output": null,
+				"error": null,
+				"revertReason": "0x08c379a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002645524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e63650000000000000000000000000000000000000000000000000000",
+				"depth": 0,
+				"calls": []
+			  }
+			]"#;
+			let expected = serde_json::from_str::<Vec<tracing::CallTrace>>(expected).unwrap();
+			assert_eq!(tracer.finalize(), tracing::TraceOutcome::Calls(expected));
+
+			tracing::using(&mut tracer, || {
+				assert_ok!(EVMBridge::<Runtime>::transfer(
+					InvokeContext {
+						contract: erc20_address(),
+						sender: alice_evm_addr(),
+						origin: alice_evm_addr(),
+					},
+					bob_evm_addr(),
+					100
+				));
+			});
+
+			let expected = r#"[
+			  {
+				"type": "CALL",
+				"from": "0x1000000000000000000000000000000000000001",
+				"to": "0x5dddfce53ee040d9eb21afbc0ae1bb4dbb0ba643",
+				"input": "0xa9059cbb00000000000000000000000010000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000064",
+				"value": "0x0",
+				"gas": 200000,
+				"gasUsed": 51929,
+				"output": "0x0000000000000000000000000000000000000000000000000000000000000001",
+				"error": null,
+				"revertReason": null,
+				"depth": 0,
+				"calls": []
+			  }
+			]"#;
+			let expected = serde_json::from_str::<Vec<tracing::CallTrace>>(expected).unwrap();
+			assert_eq!(tracer.finalize(), tracing::TraceOutcome::Calls(expected));
+		});
+}

primitives/src/evm.rs

@@ -384,20 +384,24 @@ pub mod tracing {
 	}
 
 	#[cfg(feature = "std")]
-	fn vec_to_hex<S>(data: &[u8], serializer: S) -> Result<S::Ok, S::Error>
-	where
-		S: serde::Serializer,
-	{
-		serializer.serialize_str(&sp_core::bytes::to_hex(data, false))
-	}
+	mod maybe_hex {
+		use serde::{Deserialize, Deserializer, Serializer};
+		pub fn serialize<S: Serializer>(data: &Option<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error> {
+			if let Some(data) = data {
+				sp_core::bytes::serialize(data.as_slice(), serializer)
+			} else {
+				serializer.serialize_none()
+			}
+		}
 
-	#[cfg(feature = "std")]
-	fn hex_to_vec<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
-	where
-		D: serde::Deserializer<'de>,
-	{
-		use serde::de::Error;
-		String::deserialize(deserializer).and_then(|string| sp_core::bytes::from_hex(&string).map_err(Error::custom))
+		pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Option<Vec<u8>>, D::Error> {
+			use serde::de::Error;
+			match Option::deserialize(deserializer) {
+				Ok(Some(data)) => sp_core::bytes::from_hex(data).map_err(Error::custom).map(Some),
+				Ok(None) => Ok(None),
+				Err(e) => Err(e),
+			}
+		}
 	}
 
 	#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)]
@@ -408,21 +412,21 @@ pub mod tracing {
 		pub call_type: CallType,
 		pub from: H160,
 		pub to: H160,
-		#[cfg_attr(
-			feature = "std",
-			serde(serialize_with = "vec_to_hex", deserialize_with = "hex_to_vec")
-		)]
+		#[cfg_attr(feature = "std", serde(with = "sp_core::bytes"))]
 		pub input: Vec<u8>,
 		pub value: U256,
 		// gas limit
 		#[codec(compact)]
 		pub gas: u64,
 		#[codec(compact)]
 		pub gas_used: u64,
+		#[cfg_attr(feature = "std", serde(with = "maybe_hex"))]
 		// value returned from EVM, if any
 		pub output: Option<Vec<u8>>,
+		#[cfg_attr(feature = "std", serde(with = "maybe_hex"))]
 		// evm error, if any
 		pub error: Option<Vec<u8>>,
+		#[cfg_attr(feature = "std", serde(with = "maybe_hex"))]
 		// revert reason, if any
 		pub revert_reason: Option<Vec<u8>>,
 		// depth of the call