@nomicfoundation/edr 0.3.7 → 0.4.0-alpha.0

package/LICENSE

@@ -1 +1,21 @@
-SEE LICENSE IN EACH PACKAGE'S LICENSE FILE
+MIT License
+
+Copyright (c) 2021 Nomic Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.d.ts

@@ -329,6 +329,8 @@ export interface HaltResult {
 export interface ExecutionResult {
   /** The transaction result */
   result: SuccessResult | RevertResult | HaltResult
+  /** Optional contract address if the transaction created a new contract. */
+  contractAddress?: Buffer
 }
 export interface SubscriptionEvent {
   filterId: bigint
@@ -339,6 +341,8 @@ export interface TracingMessage {
   readonly caller: Buffer
   /** Recipient address. None if it is a Create message. */
   readonly to?: Buffer
+  /** Whether it's a static call */
+  readonly isStaticCall: boolean
   /** Transaction gas limit */
   readonly gasLimit: bigint
   /** Depth of the message */
@@ -362,8 +366,14 @@ export interface TracingStep {
   readonly pc: bigint
   /** The executed op code */
   readonly opcode: string
-  /** The top entry on the stack. None if the stack is empty. */
-  readonly stackTop?: bigint
+  /**
+   * The entries on the stack. It only contains the top element unless
+   * verbose tracing is enabled. The vector is empty if there are no elements
+   * on the stack.
+   */
+  readonly stack: Array<bigint>
+  /** The memory at the step. None if verbose tracing is disabled. */
+  readonly memory?: Buffer
 }
 export interface TracingMessageResult {
   /** Execution result */
@@ -390,6 +400,13 @@ export class Provider {
   /**Handles a JSON-RPC request and returns a JSON-RPC response. */
   handleRequest(jsonRequest: string): Promise<Response>
   setCallOverrideCallback(callOverrideCallback: (contract_address: Buffer, data: Buffer) => Promise<CallOverrideResult | undefined>): void
+  /**
+   * Set to `true` to make the traces returned with `eth_call`,
+   * `eth_estimateGas`, `eth_sendRawTransaction`, `eth_sendTransaction`,
+   * `evm_mine`, `hardhat_mine` include the full stack and memory. Set to
+   * `false` to disable this.
+   */
+  setVerboseTracing(verboseTracing: boolean): void
 }
 export class Response {
   get json(): string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.3.7",
+  "version": "0.4.0-alpha.0",
   "main": "index.js",
   "types": "index.d.ts",
   "files": [
@@ -42,13 +42,13 @@
     "node": ">= 18"
   },
   "optionalDependencies": {
-    "@nomicfoundation/edr-win32-x64-msvc": "0.3.7",
-    "@nomicfoundation/edr-darwin-x64": "0.3.7",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.3.7",
-    "@nomicfoundation/edr-darwin-arm64": "0.3.7",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.3.7",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.3.7",
-    "@nomicfoundation/edr-linux-x64-musl": "0.3.7"
+    "@nomicfoundation/edr-win32-x64-msvc": "0.4.0-alpha.0",
+    "@nomicfoundation/edr-darwin-x64": "0.4.0-alpha.0",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.4.0-alpha.0",
+    "@nomicfoundation/edr-darwin-arm64": "0.4.0-alpha.0",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.4.0-alpha.0",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.4.0-alpha.0",
+    "@nomicfoundation/edr-linux-x64-musl": "0.4.0-alpha.0"
   },
   "scripts": {
     "artifacts": "napi artifacts",

package/src/call_override.rs

@@ -2,10 +2,11 @@ use std::sync::mpsc::channel;
 
 use edr_eth::{Address, Bytes};
 use napi::{
-    bindgen_prelude::Buffer,
+    bindgen_prelude::{Buffer, Promise},
     threadsafe_function::{
         ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
     },
+    tokio::runtime,
     Env, JsFunction, Status,
 };
 use napi_derive::napi;
@@ -41,10 +42,15 @@ struct CallOverrideCall {
 #[derive(Clone)]
 pub struct CallOverrideCallback {
     call_override_callback_fn: ThreadsafeFunction<CallOverrideCall, ErrorStrategy::Fatal>,
+    runtime: runtime::Handle,
 }
 
 impl CallOverrideCallback {
-    pub fn new(env: &Env, call_override_callback: JsFunction) -> napi::Result<Self> {
+    pub fn new(
+        env: &Env,
+        call_override_callback: JsFunction,
+        runtime: runtime::Handle,
+    ) -> napi::Result<Self> {
         let mut call_override_callback_fn = call_override_callback.create_threadsafe_function(
             0,
             |ctx: ThreadSafeCallContext<CallOverrideCall>| {
@@ -68,6 +74,7 @@ impl CallOverrideCallback {
 
         Ok(Self {
             call_override_callback_fn,
+            runtime,
         })
     }
 
@@ -78,21 +85,24 @@ impl CallOverrideCallback {
     ) -> Option<edr_provider::CallOverrideResult> {
         let (sender, receiver) = channel();
 
+        let runtime = self.runtime.clone();
         let status = self.call_override_callback_fn.call_with_return_value(
             CallOverrideCall {
                 contract_address,
                 data,
             },
             ThreadsafeFunctionCallMode::Blocking,
-            move |result: Option<CallOverrideResult>| {
-                let result = result.try_cast();
-
-                sender.send(result).map_err(|_error| {
-                    napi::Error::new(
-                        Status::GenericFailure,
-                        "Failed to send result from call_override_callback",
-                    )
-                })
+            move |result: Promise<Option<CallOverrideResult>>| {
+                runtime.spawn(async move {
+                    let result = result.await?.try_cast();
+                    sender.send(result).map_err(|_error| {
+                        napi::Error::new(
+                            Status::GenericFailure,
+                            "Failed to send result from call_override_callback",
+                        )
+                    })
+                });
+                Ok(())
             },
         );
 

package/src/logger.rs

@@ -1,11 +1,11 @@
 use std::{fmt::Display, sync::mpsc::channel};
 
 use ansi_term::{Color, Style};
-use edr_eth::{Bytes, B256, U256};
+use edr_eth::{transaction::Transaction, Bytes, B256, U256};
 use edr_evm::{
     blockchain::BlockchainError,
     precompile::{self, Precompiles},
-    trace::TraceMessage,
+    trace::{AfterMessage, TraceMessage},
     ExecutableTransaction, ExecutionResult, SyncBlock,
 };
 use edr_provider::{ProviderError, TransactionFailure};
@@ -506,7 +506,7 @@ impl LogCollector {
                         result.transaction_traces.iter()
                     )
                     .find(|(block_transaction, _, _)| {
-                        *block_transaction.hash() == *transaction.hash()
+                        *block_transaction.transaction_hash() == *transaction.transaction_hash()
                     })
                     .map(|(_, transaction_result, trace)| (result, transaction_result, trace))
                 })
@@ -514,7 +514,11 @@ impl LogCollector {
 
             if mining_results.len() > 1 {
                 self.log_multiple_blocks_warning();
-                self.log_auto_mined_block_results(spec_id, mining_results, transaction.hash());
+                self.log_auto_mined_block_results(
+                    spec_id,
+                    mining_results,
+                    transaction.transaction_hash(),
+                );
                 self.log_currently_sent_transaction(
                     spec_id,
                     sent_block_result,
@@ -526,7 +530,11 @@ impl LogCollector {
                 let transactions = result.block.transactions();
                 if transactions.len() > 1 {
                     self.log_multiple_transactions_warning();
-                    self.log_auto_mined_block_results(spec_id, mining_results, transaction.hash());
+                    self.log_auto_mined_block_results(
+                        spec_id,
+                        mining_results,
+                        transaction.transaction_hash(),
+                    );
                     self.log_currently_sent_transaction(
                         spec_id,
                         sent_block_result,
@@ -659,7 +667,7 @@ impl LogCollector {
                     transaction_traces
                 ) {
                     let should_highlight_hash =
-                        *transaction.hash() == *transaction_hash_to_highlight;
+                        *transaction.transaction_hash() == *transaction_hash_to_highlight;
                     logger.log_block_transaction(
                         spec_id,
                         transaction,
@@ -706,7 +714,7 @@ impl LogCollector {
         console_log_inputs: &[Bytes],
         should_highlight_hash: bool,
     ) {
-        let transaction_hash = transaction.hash();
+        let transaction_hash = transaction.transaction_hash();
         if should_highlight_hash {
             self.log_with_title(
                 "Transaction",
@@ -841,8 +849,12 @@ impl LogCollector {
                     }
                 }
             } else {
-                let result = if let Some(TraceMessage::After(result)) = trace.messages.last() {
-                    result
+                let result = if let Some(TraceMessage::After(AfterMessage {
+                    execution_result,
+                    ..
+                })) = trace.messages.last()
+                {
+                    execution_result
                 } else {
                     unreachable!("Before messages must have an after message")
                 };
@@ -1090,7 +1102,7 @@ impl LogCollector {
         self.indented(|logger| {
             logger.log_contract_and_function_name::<false>(spec_id, trace);
 
-            let transaction_hash = transaction.hash();
+            let transaction_hash = transaction.transaction_hash();
             logger.log_with_title("Transaction", transaction_hash);
 
             logger.log_with_title("From", format!("0x{:x}", transaction.caller()));

package/src/provider.rs

@@ -20,6 +20,7 @@ use crate::{
 #[napi]
 pub struct Provider {
     provider: Arc<edr_provider::Provider<LoggerError>>,
+    runtime: runtime::Handle,
     #[cfg(feature = "scenarios")]
     scenario_file: Option<napi::tokio::sync::Mutex<napi::tokio::fs::File>>,
 }
@@ -53,7 +54,7 @@ impl Provider {
                 ))?;
 
             let result = edr_provider::Provider::new(
-                runtime,
+                runtime.clone(),
                 logger,
                 subscriber_callback,
                 config,
@@ -64,6 +65,7 @@ impl Provider {
                 |provider| {
                     Ok(Provider {
                         provider: Arc::new(provider),
+                        runtime,
                         #[cfg(feature = "scenarios")]
                         scenario_file,
                     })
@@ -185,7 +187,8 @@ impl Provider {
     ) -> napi::Result<()> {
         let provider = self.provider.clone();
 
-        let call_override_callback = CallOverrideCallback::new(&env, call_override_callback)?;
+        let call_override_callback =
+            CallOverrideCallback::new(&env, call_override_callback, self.runtime.clone())?;
         let call_override_callback =
             Arc::new(move |address, data| call_override_callback.call_override(address, data));
 
@@ -193,6 +196,15 @@ impl Provider {
 
         Ok(())
     }
+
+    /// Set to `true` to make the traces returned with `eth_call`,
+    /// `eth_estimateGas`, `eth_sendRawTransaction`, `eth_sendTransaction`,
+    /// `evm_mine`, `hardhat_mine` include the full stack and memory. Set to
+    /// `false` to disable this.
+    #[napi(ts_return_type = "void")]
+    pub fn set_verbose_tracing(&self, verbose_tracing: bool) {
+        self.provider.set_verbose_tracing(verbose_tracing);
+    }
 }
 
 #[napi]

package/src/result.rs

@@ -1,3 +1,4 @@
+use edr_evm::trace::AfterMessage;
 use napi::{
     bindgen_prelude::{BigInt, Buffer, Either3},
     Either, Env, JsBuffer, JsBufferValue,
@@ -168,11 +169,18 @@ pub struct HaltResult {
 pub struct ExecutionResult {
     /// The transaction result
     pub result: Either3<SuccessResult, RevertResult, HaltResult>,
+    /// Optional contract address if the transaction created a new contract.
+    pub contract_address: Option<Buffer>,
 }
 
 impl ExecutionResult {
-    pub fn new(env: &Env, result: &edr_evm::ExecutionResult) -> napi::Result<Self> {
-        let result = match result {
+    pub fn new(env: &Env, message: &AfterMessage) -> napi::Result<Self> {
+        let AfterMessage {
+            execution_result,
+            contract_address,
+        } = message;
+
+        let result = match execution_result {
             edr_evm::ExecutionResult::Success {
                 reason,
                 gas_used,
@@ -227,6 +235,11 @@ impl ExecutionResult {
             }),
         };
 
-        Ok(Self { result })
+        let contract_address = contract_address.map(|address| Buffer::from(address.as_slice()));
+
+        Ok(Self {
+            result,
+            contract_address,
+        })
     }
 }

package/src/trace.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use edr_evm::{interpreter::OPCODE_JUMPMAP, trace::BeforeMessage};
+use edr_evm::{interpreter::OpCode, trace::BeforeMessage};
 use napi::{
     bindgen_prelude::{BigInt, Buffer, Either3},
     Env, JsBuffer, JsBufferValue,
@@ -19,6 +19,10 @@ pub struct TracingMessage {
     #[napi(readonly)]
     pub to: Option<Buffer>,
 
+    /// Whether it's a static call
+    #[napi(readonly)]
+    pub is_static_call: bool,
+
     /// Transaction gas limit
     #[napi(readonly)]
     pub gas_limit: BigInt,
@@ -47,29 +51,41 @@ pub struct TracingMessage {
 
 impl TracingMessage {
     pub fn new(env: &Env, message: &BeforeMessage) -> napi::Result<Self> {
+        // Deconstruct to make sure all fields are handled
+        let BeforeMessage {
+            depth,
+            caller,
+            to: _,
+            is_static_call,
+            gas_limit,
+            data,
+            value,
+            code_address,
+            code,
+        } = message;
+
         let data = env
-            .create_buffer_with_data(message.data.to_vec())
+            .create_buffer_with_data(data.to_vec())
             .map(JsBufferValue::into_raw)?;
 
-        let code = message.code.as_ref().map_or(Ok(None), |code| {
+        let code = code.as_ref().map_or(Ok(None), |code| {
             env.create_buffer_with_data(code.original_bytes().to_vec())
                 .map(JsBufferValue::into_raw)
                 .map(Some)
         })?;
 
         Ok(TracingMessage {
-            caller: Buffer::from(message.caller.as_slice()),
+            caller: Buffer::from(caller.as_slice()),
             to: message.to.map(|to| Buffer::from(to.as_slice())),
-            gas_limit: BigInt::from(message.gas_limit),
-            depth: message.depth as u8,
+            gas_limit: BigInt::from(*gas_limit),
+            is_static_call: *is_static_call,
+            depth: *depth as u8,
             data,
             value: BigInt {
                 sign_bit: false,
-                words: message.value.into_limbs().to_vec(),
+                words: value.into_limbs().to_vec(),
             },
-            code_address: message
-                .code_address
-                .map(|address| Buffer::from(address.to_vec())),
+            code_address: code_address.map(|address| Buffer::from(address.to_vec())),
             code,
         })
     }
@@ -86,27 +102,46 @@ pub struct TracingStep {
     /// The executed op code
     #[napi(readonly)]
     pub opcode: String,
-    /// The top entry on the stack. None if the stack is empty.
+    /// The entries on the stack. It only contains the top element unless
+    /// verbose tracing is enabled. The vector is empty if there are no elements
+    /// on the stack.
+    #[napi(readonly)]
+    pub stack: Vec<BigInt>,
+    /// The memory at the step. None if verbose tracing is disabled.
     #[napi(readonly)]
-    pub stack_top: Option<BigInt>,
+    pub memory: Option<Buffer>,
 }
 
 impl TracingStep {
     pub fn new(step: &edr_evm::trace::Step) -> Self {
+        let stack = step.stack.full().map_or_else(
+            || {
+                step.stack
+                    .top()
+                    .map(u256_to_bigint)
+                    .map_or_else(Vec::default, |top| vec![top])
+            },
+            |stack| stack.iter().map(u256_to_bigint).collect(),
+        );
+        let memory = step.memory.as_ref().cloned().map(Buffer::from);
+
         Self {
             depth: step.depth as u8,
             pc: BigInt::from(step.pc),
-            opcode: OPCODE_JUMPMAP[usize::from(step.opcode)]
-                .unwrap_or("")
-                .to_string(),
-            stack_top: step.stack_top.map(|v| BigInt {
-                sign_bit: false,
-                words: v.into_limbs().to_vec(),
-            }),
+            opcode: OpCode::name_by_op(step.opcode).to_string(),
+            stack,
+            memory,
         }
     }
 }
 
+fn u256_to_bigint(v: &edr_evm::U256) -> BigInt {
+    BigInt {
+        sign_bit: false,
+        words: v.into_limbs().to_vec(),
+    }
+}
+
 #[napi(object)]
 pub struct TracingMessageResult {
     /// Execution result
@@ -140,7 +175,7 @@ impl RawTrace {
                     TracingMessage::new(&env, message).map(Either3::A)
                 }
                 edr_evm::trace::TraceMessage::Step(step) => Ok(Either3::B(TracingStep::new(step))),
-                edr_evm::trace::TraceMessage::After(result) => ExecutionResult::new(&env, result)
+                edr_evm::trace::TraceMessage::After(message) => ExecutionResult::new(&env, message)
                     .map(|execution_result| Either3::C(TracingMessageResult { execution_result })),
             })
             .collect::<napi::Result<_>>()