NDEV-2620: Add executor_state: &impl Database parameter to EventListener::event method

evm_loader/api/src/api_server/handlers/emulate.rs

@@ -1,5 +1,6 @@
 use actix_request_identifier::RequestId;
 use actix_web::{http::StatusCode, post, web::Json, Responder};
+use neon_lib::tracing::tracers::TracerTypeEnum;
 use std::convert::Into;
 use tracing::info;
 
@@ -26,8 +27,14 @@ pub async fn emulate(
     };
 
     process_result(
-        &EmulateCommand::execute(&rpc, state.config.evm_loader, emulate_request.body, None)
-            .await
-            .map_err(Into::into),
+        &EmulateCommand::execute(
+            &rpc,
+            state.config.evm_loader,
+            emulate_request.body,
+            None::<TracerTypeEnum>,
+        )
+        .await
+        .map(|(response, _)| response)
+        .map_err(Into::into),
     )
 }

evm_loader/cli/src/main.rs

@@ -29,6 +29,7 @@ use crate::build_info::get_build_info;
 use evm_loader::types::Address;
 use neon_lib::errors::NeonError;
 use neon_lib::rpc::{CallDbClient, RpcEnum};
+use neon_lib::tracing::tracers::TracerTypeEnum;
 use neon_lib::types::TracerDb;
 use solana_clap_utils::keypair::signer_from_path;
 use solana_sdk::signature::Signer;
@@ -44,9 +45,9 @@ async fn run(options: &ArgMatches<'_>) -> NeonCliResult {
             let rpc = build_rpc(options, config).await?;
 
             let request = read_tx_from_stdin()?;
-            emulate::execute(&rpc, config.evm_loader, request, None)
+            emulate::execute(&rpc, config.evm_loader, request, None::<TracerTypeEnum>)
                 .await
-                .map(|result| json!(result))
+                .map(|(result, _)| json!(result))
         }
         ("trace", Some(_)) => {
             let rpc = build_rpc(options, config).await?;

evm_loader/lib/Cargo.toml

@@ -9,7 +9,7 @@ edition = "2021"
 thiserror = "1.0"
 anyhow = "1.0"
 bincode = "1.3.1"
-evm-loader = { path = "../program", default-features = false, features = ["log", "async-trait", "serde_json"] }
+evm-loader = { path = "../program", default-features = false, features = ["log", "async-trait"] }
 solana-sdk = "=1.16.23"
 solana-client = "=1.16.23"
 solana-clap-utils = "=1.16.23"

evm_loader/lib/src/commands/emulate.rs

@@ -2,19 +2,20 @@ use evm_loader::account::ContractAccount;
 use evm_loader::error::build_revert_message;
 use log::{debug, info};
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use solana_sdk::entrypoint::MAX_PERMITTED_DATA_INCREASE;
 use solana_sdk::pubkey::Pubkey;
 
 use crate::commands::get_config::BuildConfigSimulator;
 use crate::rpc::Rpc;
 use crate::syscall_stubs::setup_emulator_syscall_stubs;
+use crate::tracing::tracers::Tracer;
 use crate::types::{EmulateRequest, TxParams};
 use crate::{
     account_storage::{EmulatorAccountStorage, SolanaAccount},
     errors::NeonError,
     NeonResult,
 };
-use evm_loader::evm::tracing::TracerType;
 use evm_loader::{
     config::{EVM_STEPS_MIN, PAYMENT_TO_TREASURE},
     evm::{ExitStatus, Machine},
@@ -50,12 +51,12 @@ impl EmulateResponse {
     }
 }
 
-pub async fn execute(
+pub async fn execute<T: Tracer>(
     rpc: &(impl Rpc + BuildConfigSimulator),
     program_id: Pubkey,
     emulate_request: EmulateRequest,
-    tracer: Option<TracerType>,
-) -> NeonResult<EmulateResponse> {
+    tracer: Option<T>,
+) -> NeonResult<(EmulateResponse, Option<Value>)> {
     let block_overrides = emulate_request
         .trace_config
         .as_ref()
@@ -81,34 +82,31 @@ pub async fn execute(
     emulate_trx(emulate_request.tx, &mut storage, step_limit, tracer).await
 }
 
-async fn emulate_trx(
+async fn emulate_trx<T: Tracer>(
     tx_params: TxParams,
     storage: &mut EmulatorAccountStorage<'_, impl Rpc>,
     step_limit: u64,
-    tracer: Option<TracerType>,
-) -> NeonResult<EmulateResponse> {
+    tracer: Option<T>,
+) -> NeonResult<(EmulateResponse, Option<Value>)> {
     info!("tx_params: {:?}", tx_params);
 
     let (origin, tx) = tx_params.into_transaction(storage).await;
 
     info!("origin: {:?}", origin);
     info!("tx: {:?}", tx);
 
-    let (exit_status, actions, steps_executed) = {
-        let mut backend = ExecutorState::new(storage);
-        let mut evm = match Machine::new(tx, origin, &mut backend, tracer).await {
-            Ok(evm) => evm,
-            Err(e) => return Ok(EmulateResponse::revert(e)),
-        };
+    let mut backend = ExecutorState::new(storage);
+    let mut evm = match Machine::new(tx, origin, &mut backend, tracer).await {
+        Ok(evm) => evm,
+        Err(e) => return Ok((EmulateResponse::revert(e), None)),
+    };
 
-        let (result, steps_executed) = evm.execute(step_limit, &mut backend).await?;
-        if result == ExitStatus::StepLimit {
-            return Err(NeonError::TooManySteps);
-        }
+    let (exit_status, steps_executed, tracer) = evm.execute(step_limit, &mut backend).await?;
+    if exit_status == ExitStatus::StepLimit {
+        return Err(NeonError::TooManySteps);
+    }
 
-        let actions = backend.into_actions();
-        (result, actions, steps_executed)
-    };
+    let actions = backend.into_actions();
 
     storage.apply_actions(actions.clone()).await?;
     storage.mark_legacy_accounts().await?;
@@ -128,14 +126,17 @@ async fn emulate_trx(
 
     let solana_accounts = storage.accounts.borrow().values().cloned().collect();
 
-    Ok(EmulateResponse {
-        exit_status: exit_status.to_string(),
-        steps_executed,
-        used_gas,
-        solana_accounts,
-        result: exit_status.into_result().unwrap_or_default(),
-        iterations,
-    })
+    Ok((
+        EmulateResponse {
+            exit_status: exit_status.to_string(),
+            steps_executed,
+            used_gas,
+            solana_accounts,
+            result: exit_status.into_result().unwrap_or_default(),
+            iterations,
+        },
+        tracer.map(|tracer| tracer.into_traces()),
+    ))
 }
 
 fn realloc_iterations(actions: &[Action]) -> u64 {

evm_loader/lib/src/commands/trace.rs

@@ -1,5 +1,3 @@
-use std::rc::Rc;
-
 use serde_json::Value;
 use solana_sdk::pubkey::Pubkey;
 
@@ -22,13 +20,10 @@ pub async fn trace_transaction(
 
     let tracer = new_tracer(&trace_config)?;
 
-    let emulation_tracer = Some(Rc::clone(&tracer));
-    let r = super::emulate::execute(rpc, program_id, emulate_request, emulation_tracer).await?;
+    let (r, traces) =
+        super::emulate::execute(rpc, program_id, emulate_request, Some(tracer)).await?;
 
-    let mut traces = Rc::try_unwrap(tracer)
-        .expect("There is must be only one reference")
-        .into_inner()
-        .into_traces();
+    let mut traces = traces.expect("traces should not be None");
     traces["gas"] = r.used_gas.into();
 
     Ok(traces)

evm_loader/lib/src/tracing/tracers/mod.rs

@@ -1,21 +1,45 @@
 use crate::tracing::tracers::struct_logger::StructLogger;
 use crate::tracing::TraceConfig;
-use evm_loader::evm::tracing::TracerType;
-use std::cell::RefCell;
-use std::rc::Rc;
+use evm_loader::evm::database::Database;
+use evm_loader::evm::tracing::{Event, EventListener};
+use serde_json::Value;
 
 pub mod struct_logger;
 
-pub fn new_tracer(trace_config: &TraceConfig) -> evm_loader::error::Result<TracerType> {
-    Ok(Rc::new(RefCell::new(
-        match trace_config.tracer.as_deref() {
-            None | Some("") => Box::new(StructLogger::new(trace_config)),
-            _ => {
-                return Err(evm_loader::error::Error::Custom(format!(
-                    "Unsupported tracer: {:?}",
-                    trace_config.tracer
-                )))
+pub enum TracerTypeEnum {
+    StructLogger(StructLogger),
+}
+
+impl EventListener for TracerTypeEnum {
+    fn event(&mut self, executor_state: &impl Database, event: Event) {
+        match self {
+            TracerTypeEnum::StructLogger(struct_logger) => {
+                struct_logger.event(executor_state, event)
             }
-        },
-    )))
+        }
+    }
+}
+
+pub trait Tracer: EventListener {
+    fn into_traces(self) -> Value;
+}
+
+impl Tracer for TracerTypeEnum {
+    fn into_traces(self) -> Value {
+        match self {
+            TracerTypeEnum::StructLogger(struct_logger) => struct_logger.into_traces(),
+        }
+    }
+}
+
+pub fn new_tracer(trace_config: &TraceConfig) -> evm_loader::error::Result<TracerTypeEnum> {
+    match trace_config.tracer.as_deref() {
+        None | Some("") => Ok(TracerTypeEnum::StructLogger(StructLogger::new(
+            trace_config,
+        ))),
+        _ => Err(evm_loader::error::Error::Custom(format!(
+            "Unsupported tracer: {:?}",
+            trace_config.tracer
+        ))),
+    }
 }

evm_loader/lib/src/tracing/tracers/struct_logger.rs

@@ -1,11 +1,13 @@
 use std::collections::BTreeMap;
 
 use ethnum::U256;
+use evm_loader::evm::database::Database;
 use evm_loader::evm::ExitStatus;
 use serde::Serialize;
 use serde_json::Value;
 use web3::types::Bytes;
 
+use crate::tracing::tracers::Tracer;
 use crate::tracing::TraceConfig;
 use evm_loader::evm::opcode_table::OPNAMES;
 use evm_loader::evm::tracing::{Event, EventListener};
@@ -138,7 +140,7 @@ impl StructLogger {
 }
 
 impl EventListener for StructLogger {
-    fn event(&mut self, event: Event) {
+    fn event(&mut self, _executor_state: &impl Database, event: Event) {
         match event {
             Event::BeginVM { .. } => {
                 self.depth += 1;
@@ -203,8 +205,10 @@ impl EventListener for StructLogger {
             }
         };
     }
+}
 
-    fn into_traces(self: Box<Self>) -> Value {
+impl Tracer for StructLogger {
+    fn into_traces(self) -> Value {
         let exit_status = self.exit_status.expect("Emulation is not completed");
         let result = StructLoggerResult {
             gas: 0,

evm_loader/program/Cargo.toml

@@ -51,7 +51,6 @@ borsh = "0.9"
 bincode = "1"
 serde_bytes = "0.11.12"
 serde = { version = "1.0.186", default-features = false, features = ["derive", "rc"] }
-serde_json = { version = "1.0.107", features = ["preserve_order"], optional = true }
 ethnum = { version = "1.4", default-features = false, features = ["serde"] }
 cfg-if = { version = "1.0" }
 log = { version = "0.4", default-features = false, optional = true }
@@ -64,6 +63,7 @@ features = ["is_sync"]
 
 [dev-dependencies]
 tokio = { version = "1.0", features = ["full"] }
+serde_json = { version = "1.0.107", features = ["preserve_order"] }
 
 [lib]
 crate-type = ["cdylib", "lib"]