first pass

evm-adapters/src/call_tracing.rs

@@ -0,0 +1,90 @@
+use ethers::abi::FunctionExt;
+use std::collections::BTreeMap;
+use ethers::{
+	abi::{Abi, RawLog},
+	types::{Address, H160},
+};
+
+/// Call trace of a tx
+#[derive(Clone, Default, Debug)]
+pub struct CallTrace {
+	pub depth: usize,
+	pub location: usize,
+    /// Successful
+    pub success: bool,
+    /// Callee
+    pub addr: H160,
+    /// Creation
+    pub created: bool,
+    /// Call data, including function selector (if applicable)
+    pub data: Vec<u8>,
+    /// Gas cost
+    pub cost: u64,
+    /// Output
+    pub output: Vec<u8>,
+    /// Logs
+    pub logs: Vec<RawLog>,
+    /// inner calls
+    pub inner: Vec<CallTrace>,
+}
+
+impl CallTrace {
+	pub fn add_trace(&mut self, new_trace: Self) {
+		if new_trace.depth == 0 {
+			// overwrite
+			self.update(new_trace);
+		} else if self.depth == new_trace.depth - 1 {
+			self.inner.push(new_trace);
+		} else {
+			self.inner.last_mut().expect("Disconnected trace").add_trace(new_trace);
+		}
+	}
+
+	fn update(&mut self, new_trace: Self) {
+		self.success = new_trace.success;
+		self.addr = new_trace.addr;
+		self.cost = new_trace.cost;
+		self.output = new_trace.output;
+		self.logs = new_trace.logs;
+		self.data = new_trace.data;
+		self.addr = new_trace.addr;
+		// we dont update inner because the temporary new_trace doesnt track inner calls
+	}
+
+	pub fn update_trace(&mut self, new_trace: Self) {
+		if new_trace.depth == 0 {
+			// overwrite
+			self.update(new_trace);
+		} else if self.depth == new_trace.depth - 1 {
+			self.inner[new_trace.location].update(new_trace);
+		} else {
+			self.inner.last_mut().expect("Disconnected trace update").update_trace(new_trace);
+		}
+	}
+
+	pub fn location(&self, new_trace: &Self) -> usize {
+		if new_trace.depth == 0 {
+			0
+		} else if self.depth == new_trace.depth - 1 {
+			self.inner.len()
+		} else {
+			self.inner.last().expect("Disconnected trace location").location(new_trace)
+		}
+	}
+
+	pub fn pretty_print(&self, contracts: &BTreeMap<String, (Abi, Address, Vec<String>)>) {
+		if let Some((name, (abi, _addr, _other))) = contracts.iter().find(|(_key, (_abi, addr, _other))| {
+			addr == &self.addr
+		}) {
+			for (func_name, overloaded_funcs) in abi.functions.iter() {
+				for func in overloaded_funcs.iter() {
+					if func.selector() == self.data[0..4] {
+						println!("{}.{}({:?})", name, func_name, func.decode_input(&self.data[4..]).unwrap());
+					}
+				}
+			}
+			self.inner.iter().for_each(|inner| inner.pretty_print(contracts));
+		}
+
+	}
+}

evm-adapters/src/lib.rs

@@ -12,6 +12,8 @@ pub use blocking_provider::BlockingProvider;
 
 pub mod fuzz;
 
+pub mod call_tracing;
+
 use ethers::{
     abi::{Detokenize, Tokenize},
     contract::{decode_function_data, encode_function_data},

evm-adapters/src/sputnik/cheatcodes/cheatcode_handler.rs

@@ -6,6 +6,7 @@ use super::{
 use crate::{
     sputnik::{Executor, SputnikExecutor},
     Evm,
+    call_tracing::CallTrace,
 };
 
 use sputnik::{
@@ -163,6 +164,13 @@ impl<'a, 'b, B: Backend, P: PrecompileSet> SputnikExecutor<CheatcodeStackState<'
         self.state_mut().substate.logs_mut().clear()
     }
 
+    fn raw_logs(&self) -> Vec<RawLog> {
+        let logs = self.state().substate.logs().to_vec();
+        logs.into_iter()
+            .map(|log| RawLog { topics: log.topics, data: log.data })
+            .collect()
+    }
+
     fn logs(&self) -> Vec<String> {
         let logs = self.state().substate.logs().to_vec();
         logs.into_iter()
@@ -428,6 +436,32 @@ impl<'a, 'b, B: Backend, P: PrecompileSet> CheatcodeStackExecutor<'a, 'b, B, P>
         }
     }
 
+    fn start_trace(&mut self, address: H160, input: Vec<u8>, creation: bool) -> CallTrace {
+        let mut trace: CallTrace = Default::default();
+        trace.depth = self.state().metadata().depth().unwrap_or(0);
+        trace.addr = address;
+        trace.created = creation;
+        trace.data = input;
+        trace.location = self.state_mut().trace.location(&trace);
+        // we should probably delay having the input and other stuff so
+        // we minimize the size of the clone
+        self.state_mut().trace.add_trace(trace.clone());
+        trace
+    }
+
+    fn fill_trace(
+        &mut self, 
+        mut new_trace: CallTrace,
+        success: bool,
+        output: Option<Vec<u8>>,
+    ) {
+        new_trace.logs = self.raw_logs();
+        new_trace.output = output.unwrap_or(vec![]);
+        new_trace.cost = self.handler.used_gas();
+        new_trace.success = success;
+        self.state_mut().trace.update_trace(new_trace);
+    }
+
     // NB: This function is copy-pasted from uptream's call_inner
     #[allow(clippy::too_many_arguments)]
     fn call_inner(
@@ -441,11 +475,19 @@ impl<'a, 'b, B: Backend, P: PrecompileSet> CheatcodeStackExecutor<'a, 'b, B, P>
         take_stipend: bool,
         context: Context,
     ) -> Capture<(ExitReason, Vec<u8>), Infallible> {
+        let trace = self.start_trace(code_address, input.clone(), false);
+
         macro_rules! try_or_fail {
             ( $e:expr ) => {
                 match $e {
                     Ok(v) => v,
-                    Err(e) => return Capture::Exit((e.into(), Vec::new())),
+                    Err(e) => {
+                        // if let Some(call_trace) = trace {
+                        //     self.state_mut().trace.success = false;
+                        // }
+                        self.fill_trace(trace, false, None);
+                        return Capture::Exit((e.into(), Vec::new()))
+                    },
                 }
             };
         }
@@ -485,6 +527,7 @@ impl<'a, 'b, B: Backend, P: PrecompileSet> CheatcodeStackExecutor<'a, 'b, B, P>
 
         if let Some(depth) = self.state().metadata().depth() {
             if depth > self.config().call_stack_limit {
+                self.fill_trace(trace, false, None);
                 let _ = self.handler.exit_substate(StackExitKind::Reverted);
                 return Capture::Exit((ExitError::CallTooDeep.into(), Vec::new()))
             }
@@ -494,6 +537,7 @@ impl<'a, 'b, B: Backend, P: PrecompileSet> CheatcodeStackExecutor<'a, 'b, B, P>
             match self.state_mut().transfer(transfer) {
                 Ok(()) => (),
                 Err(e) => {
+                    self.fill_trace(trace, false, None);
                     let _ = self.handler.exit_substate(StackExitKind::Reverted);
                     return Capture::Exit((ExitReason::Error(e), Vec::new()))
                 }
@@ -517,6 +561,7 @@ impl<'a, 'b, B: Backend, P: PrecompileSet> CheatcodeStackExecutor<'a, 'b, B, P>
                     }
 
                     let _ = self.state_mut().metadata_mut().gasometer_mut().record_cost(cost);
+                    self.fill_trace(trace, true, Some(output.clone()));
                     let _ = self.handler.exit_substate(StackExitKind::Succeeded);
                     Capture::Exit((ExitReason::Succeed(exit_status), output))
                 }
@@ -528,6 +573,7 @@ impl<'a, 'b, B: Backend, P: PrecompileSet> CheatcodeStackExecutor<'a, 'b, B, P>
                         }
                         PrecompileFailure::Fatal { exit_status } => ExitReason::Fatal(exit_status),
                     };
+                    self.fill_trace(trace, false, None);
                     let _ = self.handler.exit_substate(StackExitKind::Failed);
                     Capture::Exit((e, Vec::new()))
                 }
@@ -543,18 +589,22 @@ impl<'a, 'b, B: Backend, P: PrecompileSet> CheatcodeStackExecutor<'a, 'b, B, P>
         // reason);
         match reason {
             ExitReason::Succeed(s) => {
+                self.fill_trace(trace, true, Some(runtime.machine().return_value()));
                 let _ = self.handler.exit_substate(StackExitKind::Succeeded);
                 Capture::Exit((ExitReason::Succeed(s), runtime.machine().return_value()))
             }
             ExitReason::Error(e) => {
+                self.fill_trace(trace, false, Some(runtime.machine().return_value()));
                 let _ = self.handler.exit_substate(StackExitKind::Failed);
                 Capture::Exit((ExitReason::Error(e), Vec::new()))
             }
             ExitReason::Revert(e) => {
+                self.fill_trace(trace, false, Some(runtime.machine().return_value()));
                 let _ = self.handler.exit_substate(StackExitKind::Reverted);
                 Capture::Exit((ExitReason::Revert(e), runtime.machine().return_value()))
             }
             ExitReason::Fatal(e) => {
+                self.fill_trace(trace, false, Some(runtime.machine().return_value()));
                 self.state_mut().metadata_mut().gasometer_mut().fail();
                 let _ = self.handler.exit_substate(StackExitKind::Failed);
                 Capture::Exit((ExitReason::Fatal(e), Vec::new()))
@@ -1048,4 +1098,31 @@ mod tests {
         };
         assert_eq!(reason, "ffi disabled: run again with --ffi if you want to allow tests to call external scripts");
     }
+
+    #[test]
+    fn tracing() {
+        use std::collections::BTreeMap;
+
+        let config = Config::istanbul();
+        let vicinity = new_vicinity();
+        let backend = new_backend(&vicinity, Default::default());
+        let gas_limit = 10_000_000;
+        let precompiles = PRECOMPILES_MAP.clone();
+        let mut evm =
+            Executor::new_with_cheatcodes(backend, gas_limit, &config, &precompiles, false);
+
+        let compiled = COMPILED.find("RecursiveCall").expect("could not find contract");
+         let (addr, _, _, _) =
+            evm.deploy(Address::zero(), compiled.bin.unwrap().clone(), 0.into()).unwrap();
+
+        // after the evm call is done, we call `logs` and print it all to the user
+        let (_, _, _, logs) = evm
+            .call::<(), _, _>(Address::zero(), addr, "recurseCall(uint256,uint256)", (U256::from(3u32), U256::from(0u32)), 0u32.into())
+            .unwrap();
+
+        let mut mapping = BTreeMap::new();
+        mapping.insert("RecursiveCall".to_string(), (compiled.abi.expect("No abi").clone(), addr, vec![]));
+        evm.state().trace.pretty_print(&mapping);
+
+    }
 }

evm-adapters/src/sputnik/cheatcodes/memory_stackstate_owned.rs

@@ -4,6 +4,8 @@ use sputnik::{
     ExitError, Transfer,
 };
 
+use crate::call_tracing::CallTrace;
+
 use ethers::types::{H160, H256, U256};
 
 /// This struct implementation is copied from [upstream](https://github.com/rust-blockchain/evm/blob/5ecf36ce393380a89c6f1b09ef79f686fe043624/src/executor/stack/state.rs#L412) and modified to own the Backend type.
@@ -15,6 +17,8 @@ use ethers::types::{H160, H256, U256};
 pub struct MemoryStackStateOwned<'config, B> {
     pub backend: B,
     pub substate: MemoryStackSubstate<'config>,
+    pub trace: CallTrace,
+    pub current_trace: CallTrace,
 }
 
 impl<'config, B: Backend> MemoryStackStateOwned<'config, B> {
@@ -25,7 +29,7 @@ impl<'config, B: Backend> MemoryStackStateOwned<'config, B> {
 
 impl<'config, B: Backend> MemoryStackStateOwned<'config, B> {
     pub fn new(metadata: StackSubstateMetadata<'config>, backend: B) -> Self {
-        Self { backend, substate: MemoryStackSubstate::new(metadata) }
+        Self { backend, substate: MemoryStackSubstate::new(metadata), trace: Default::default(), current_trace: Default::default() }
     }
 }
 

evm-adapters/src/sputnik/mod.rs

@@ -8,6 +8,7 @@ pub mod cheatcodes;
 pub mod state;
 
 use ethers::{
+    abi::RawLog,
     providers::Middleware,
     types::{Address, H160, H256, U256},
 };
@@ -81,6 +82,10 @@ pub trait SputnikExecutor<S> {
 
     fn create_address(&self, caller: CreateScheme) -> Address;
 
+    /// Returns a vector of sraw logs that occurred during the previous VM
+    /// execution
+    fn raw_logs(&self) -> Vec<RawLog>;
+
     /// Returns a vector of string parsed logs that occurred during the previous VM
     /// execution
     fn logs(&self) -> Vec<String>;
@@ -142,6 +147,11 @@ impl<'a, 'b, S: StackState<'a>, P: PrecompileSet> SputnikExecutor<S>
     fn logs(&self) -> Vec<String> {
         vec![]
     }
+
+    fn raw_logs(&self) -> Vec<RawLog> {
+        vec![]
+    }
+
     fn clear_logs(&mut self) {}
 }
 

evm-adapters/testdata/Trace.sol

@@ -0,0 +1,23 @@
+pragma solidity ^0.8.0;
+
+
+interface RecursiveCallee {
+	function recurseCall(uint256 neededDepth, uint256 depth) external returns (uint256);
+	function someCall() external;
+}
+
+contract RecursiveCall {
+	event Depth(uint256 depth);
+	function recurseCall(uint256 neededDepth, uint256 depth) public returns (uint256) {
+		if (depth == neededDepth) {
+			return neededDepth;
+		}
+		RecursiveCallee(address(this)).recurseCall(neededDepth, depth + 1);
+		RecursiveCallee(address(this)).someCall();
+		emit Depth(depth);
+		return depth;
+	}
+
+	function someCall() public {
+	}
+}