@nomicfoundation/edr 0.3.2 → 0.3.3

package/Cargo.toml

@@ -14,8 +14,8 @@ k256 = { version = "0.13.1", default-features = false, features = ["arithmetic",
 log = { version = "0.4.20", default-features = false }
 # when napi is pinned, be sure to pin napi-derive to the same version
 # The `async` feature ensures that a tokio runtime is available
-napi = { version = "2.12.4", default-features = false, features = ["async", "error_anyhow", "napi8", "serde-json"] }
-napi-derive = "2.12.3"
+napi = { version = "2.16.0", default-features = false, features = ["async", "error_anyhow", "napi8", "serde-json"] }
+napi-derive = "2.16.0"
 edr_defaults = { version = "0.2.0-dev", path = "../edr_defaults" }
 edr_evm = { version = "0.2.0-dev", path = "../edr_evm", features = ["tracing"]}
 edr_eth = { version = "0.2.0-dev", path = "../edr_eth" }

package/index.d.ts

@@ -313,7 +313,7 @@ export const enum ExceptionalHalt {
   /** Error on created contract that begins with EF */
   CreateContractStartingWithEF = 12,
   /** EIP-3860: Limit and meter initcode. Initcode size limit exceeded. */
-  CreateInitcodeSizeLimit = 13
+  CreateInitCodeSizeLimit = 13
 }
 /** The result when the EVM terminates due to an exceptional halt. */
 export interface HaltResult {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "main": "index.js",
   "types": "index.d.ts",
   "files": [
@@ -43,15 +43,15 @@
     "node": ">= 18"
   },
   "optionalDependencies": {
-    "@nomicfoundation/edr-win32-x64-msvc": "0.3.2",
-    "@nomicfoundation/edr-darwin-x64": "0.3.2",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.3.2",
-    "@nomicfoundation/edr-darwin-arm64": "0.3.2",
-    "@nomicfoundation/edr-win32-arm64-msvc": "0.3.2",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.3.2",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.3.2",
-    "@nomicfoundation/edr-linux-x64-musl": "0.3.2",
-    "@nomicfoundation/edr-win32-ia32-msvc": "0.3.2"
+    "@nomicfoundation/edr-win32-x64-msvc": "0.3.3",
+    "@nomicfoundation/edr-darwin-x64": "0.3.3",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.3.3",
+    "@nomicfoundation/edr-darwin-arm64": "0.3.3",
+    "@nomicfoundation/edr-win32-arm64-msvc": "0.3.3",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.3.3",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.3.3",
+    "@nomicfoundation/edr-linux-x64-musl": "0.3.3",
+    "@nomicfoundation/edr-win32-ia32-msvc": "0.3.3"
   },
   "scripts": {
     "artifacts": "napi artifacts",
@@ -62,8 +62,8 @@
     "universal": "napi universal",
     "version": "napi version",
     "pretest": "pnpm build",
-    "test": "pnpm tsc && mocha --recursive \"test/**/*.ts\" --exit",
-    "testNoBuild": "pnpm tsc && mocha --recursive \"test/**/*.ts\" --exit",
+    "test": "pnpm tsc && mocha --recursive \"test/**/*.ts\"",
+    "testNoBuild": "pnpm tsc && mocha --recursive \"test/**/*.ts\"",
     "clean": "rm -rf @nomicfoundation/edr.node"
   }
 }

package/src/call_override.rs

@@ -1,14 +1,16 @@
-use std::sync::mpsc::{channel, Sender};
+use std::sync::mpsc::channel;
 
 use edr_eth::{Address, Bytes};
-use napi::{bindgen_prelude::Buffer, Env, JsFunction, NapiRaw, Status};
+use napi::{
+    bindgen_prelude::Buffer,
+    threadsafe_function::{
+        ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
+    },
+    Env, JsFunction, Status,
+};
 use napi_derive::napi;
 
-use crate::{
-    cast::TryCast,
-    sync::{await_promise, handle_error},
-    threadsafe_function::{ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode},
-};
+use crate::cast::TryCast;
 
 /// The result of executing a call override.
 #[napi(object)]
@@ -24,7 +26,7 @@ impl TryCast<Option<edr_provider::CallOverrideResult>> for Option<CallOverrideRe
         match self {
             None => Ok(None),
             Some(result) => Ok(Some(edr_provider::CallOverrideResult {
-                result: result.result.try_cast()?,
+                output: result.result.try_cast()?,
                 should_revert: result.should_revert,
             })),
         }
@@ -34,20 +36,16 @@ impl TryCast<Option<edr_provider::CallOverrideResult>> for Option<CallOverrideRe
 struct CallOverrideCall {
     contract_address: Address,
     data: Bytes,
-    sender: Sender<napi::Result<Option<edr_provider::CallOverrideResult>>>,
 }
 
 #[derive(Clone)]
 pub struct CallOverrideCallback {
-    call_override_callback_fn: ThreadsafeFunction<CallOverrideCall>,
+    call_override_callback_fn: ThreadsafeFunction<CallOverrideCall, ErrorStrategy::Fatal>,
 }
 
 impl CallOverrideCallback {
     pub fn new(env: &Env, call_override_callback: JsFunction) -> napi::Result<Self> {
-        let call_override_callback_fn = ThreadsafeFunction::create(
-            env.raw(),
-            // SAFETY: The callback is guaranteed to be valid for the lifetime of the inspector.
-            unsafe { call_override_callback.raw() },
+        let mut call_override_callback_fn = call_override_callback.create_threadsafe_function(
             0,
             |ctx: ThreadSafeCallContext<CallOverrideCall>| {
                 let address = ctx
@@ -60,17 +58,14 @@ impl CallOverrideCallback {
                     .create_buffer_with_data(ctx.value.data.to_vec())?
                     .into_raw();
 
-                let sender = ctx.value.sender.clone();
-                let promise = ctx.callback.call(None, &[address, data])?;
-                let result = await_promise::<
-                    Option<CallOverrideResult>,
-                    Option<edr_provider::CallOverrideResult>,
-                >(ctx.env, promise, ctx.value.sender);
-
-                handle_error(sender, result)
+                Ok(vec![address, data])
             },
         )?;
 
+        // Maintain a weak reference to the function to avoid the event loop from
+        // exiting.
+        call_override_callback_fn.unref(env)?;
+
         Ok(Self {
             call_override_callback_fn,
         })
@@ -83,13 +78,22 @@ impl CallOverrideCallback {
     ) -> Option<edr_provider::CallOverrideResult> {
         let (sender, receiver) = channel();
 
-        let status = self.call_override_callback_fn.call(
+        let status = self.call_override_callback_fn.call_with_return_value(
             CallOverrideCall {
                 contract_address,
                 data,
-                sender,
             },
             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",
+                    )
+                })
+            },
         );
 
         assert_eq!(status, Status::Ok, "Call override callback failed");

package/src/lib.rs

@@ -16,7 +16,5 @@ mod result;
 #[cfg(feature = "scenarios")]
 mod scenarios;
 mod subscribe;
-mod sync;
-mod threadsafe_function;
 mod trace;
 mod withdrawal;

package/src/log.rs

@@ -1,5 +1,3 @@
-use std::mem;
-
 use napi::{bindgen_prelude::Buffer, Env, JsBuffer, JsBufferValue};
 use napi_derive::napi;
 
@@ -14,23 +12,14 @@ pub struct ExecutionLog {
 impl ExecutionLog {
     pub fn new(env: &Env, log: &edr_evm::Log) -> napi::Result<Self> {
         let topics = log
-            .topics
+            .topics()
             .iter()
             .map(|topic| Buffer::from(topic.as_slice()))
             .collect();
 
-        let data = log.data.clone();
-        let data = unsafe {
-            env.create_buffer_with_borrowed_data(
-                data.as_ptr(),
-                data.len(),
-                data,
-                |data: edr_eth::Bytes, _env| {
-                    mem::drop(data);
-                },
-            )
-        }
-        .map(JsBufferValue::into_raw)?;
+        let data = env
+            .create_buffer_with_data(log.data.data.to_vec())
+            .map(JsBufferValue::into_raw)?;
 
         Ok(Self {
             address: Buffer::from(log.address.as_slice()),

package/src/logger.rs

@@ -1,7 +1,4 @@
-use std::{
-    fmt::Display,
-    sync::mpsc::{channel, Sender},
-};
+use std::{fmt::Display, sync::mpsc::channel};
 
 use ansi_term::{Color, Style};
 use edr_eth::{Bytes, B256, U256};
@@ -13,14 +10,15 @@ use edr_evm::{
 };
 use edr_provider::{ProviderError, TransactionFailure};
 use itertools::izip;
-use napi::{Env, JsFunction, NapiRaw, Status};
+use napi::{
+    threadsafe_function::{
+        ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
+    },
+    Env, JsFunction, Status,
+};
 use napi_derive::napi;
 
-use crate::{
-    cast::TryCast,
-    sync::{await_promise, handle_error},
-    threadsafe_function::{ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode},
-};
+use crate::cast::TryCast;
 
 #[napi(object)]
 pub struct ContractAndFunctionName {
@@ -38,16 +36,10 @@ impl TryCast<(String, Option<String>)> for ContractAndFunctionName {
     }
 }
 
-struct DecodeConsoleLogInputsCall {
-    inputs: Vec<Bytes>,
-    sender: Sender<napi::Result<Vec<String>>>,
-}
-
 struct ContractAndFunctionNameCall {
     code: Bytes,
     /// Only present for calls.
     calldata: Option<Bytes>,
-    sender: Sender<napi::Result<(String, Option<String>)>>,
 }
 
 #[napi(object)]
@@ -247,116 +239,71 @@ pub struct CollapsedMethod {
 
 #[derive(Clone)]
 struct LogCollector {
-    decode_console_log_inputs_fn: ThreadsafeFunction<DecodeConsoleLogInputsCall>,
-    get_contract_and_function_name_fn: ThreadsafeFunction<ContractAndFunctionNameCall>,
+    decode_console_log_inputs_fn: ThreadsafeFunction<Vec<Bytes>, ErrorStrategy::Fatal>,
+    get_contract_and_function_name_fn:
+        ThreadsafeFunction<ContractAndFunctionNameCall, ErrorStrategy::Fatal>,
     indentation: usize,
     is_enabled: bool,
     logs: Vec<LogLine>,
-    print_line_fn: ThreadsafeFunction<(String, bool)>,
+    print_line_fn: ThreadsafeFunction<(String, bool), ErrorStrategy::Fatal>,
     state: LoggingState,
     title_length: usize,
 }
 
 impl LogCollector {
     pub fn new(env: &Env, config: LoggerConfig) -> napi::Result<Self> {
-        let decode_console_log_inputs_fn = ThreadsafeFunction::create(
-            env.raw(),
-            // SAFETY: The callback is guaranteed to be valid for the lifetime of the tracer.
-            unsafe { config.decode_console_log_inputs_callback.raw() },
-            0,
-            |ctx: ThreadSafeCallContext<DecodeConsoleLogInputsCall>| {
-                // Bytes[]
-                let inputs = ctx
-                    .env
-                    .create_array_with_length(ctx.value.inputs.len())
-                    .and_then(|mut inputs| {
-                        for (idx, input) in ctx.value.inputs.into_iter().enumerate() {
-                            // SAFETY: The input is guaranteed to be valid for the lifetime of the
-                            // JS buffer.
-                            unsafe {
-                                ctx.env.create_buffer_with_borrowed_data(
-                                    input.as_ptr(),
-                                    input.len(),
-                                    input,
-                                    |input: Bytes, _env| {
-                                        std::mem::drop(input);
-                                    },
-                                )
+        let mut decode_console_log_inputs_fn = config
+            .decode_console_log_inputs_callback
+            .create_threadsafe_function(0, |ctx: ThreadSafeCallContext<Vec<Bytes>>| {
+                let inputs =
+                    ctx.env
+                        .create_array_with_length(ctx.value.len())
+                        .and_then(|mut inputs| {
+                            for (idx, input) in ctx.value.into_iter().enumerate() {
+                                ctx.env.create_buffer_with_data(input.to_vec()).and_then(
+                                    |input| inputs.set_element(idx as u32, input.into_raw()),
+                                )?;
                             }
-                            .and_then(|input| inputs.set_element(idx as u32, input.into_raw()))?;
-                        }
-
-                        Ok(inputs)
-                    })?;
-
-                let sender = ctx.value.sender.clone();
 
-                let promise = ctx.callback.call(None, &[inputs])?;
-                let result =
-                    await_promise::<Vec<String>, Vec<String>>(ctx.env, promise, ctx.value.sender);
-
-                handle_error(sender, result)
-            },
-        )?;
-
-        let get_contract_and_function_name_fn = ThreadsafeFunction::create(
-            env.raw(),
-            // SAFETY: The callback is guaranteed to be valid for the lifetime of the tracer.
-            unsafe { config.get_contract_and_function_name_callback.raw() },
-            0,
-            |ctx: ThreadSafeCallContext<ContractAndFunctionNameCall>| {
-                // Buffer
-                let code = ctx.value.code;
-                // SAFETY: The code is guaranteed to be valid for the lifetime of the
-                // JS buffer.
-                let code = unsafe {
-                    ctx.env.create_buffer_with_borrowed_data(
-                        code.as_ptr(),
-                        code.len(),
-                        code,
-                        |code: Bytes, _env| {
-                            std::mem::drop(code);
-                        },
-                    )
-                }?
-                .into_unknown();
-
-                // Option<Buffer>
-                let calldata = if let Some(calldata) = ctx.value.calldata {
-                    // SAFETY: The calldata is guaranteed to be valid for the lifetime of the
-                    // JS buffer.
-                    unsafe {
-                        ctx.env.create_buffer_with_borrowed_data(
-                            calldata.as_ptr(),
-                            calldata.len(),
-                            calldata,
-                            |calldata: Bytes, _env| {
-                                std::mem::drop(calldata);
-                            },
-                        )
-                    }?
-                    .into_unknown()
-                } else {
-                    ctx.env.get_undefined()?.into_unknown()
-                };
+                            Ok(inputs)
+                        })?;
 
-                let sender = ctx.value.sender.clone();
+                Ok(vec![inputs])
+            })?;
+
+        // Maintain a weak reference to the function to avoid the event loop from
+        // exiting.
+        decode_console_log_inputs_fn.unref(env)?;
+
+        let mut get_contract_and_function_name_fn = config
+            .get_contract_and_function_name_callback
+            .create_threadsafe_function(
+                0,
+                |ctx: ThreadSafeCallContext<ContractAndFunctionNameCall>| {
+                    // Buffer
+                    let code = ctx
+                        .env
+                        .create_buffer_with_data(ctx.value.code.to_vec())?
+                        .into_unknown();
+
+                    // Option<Buffer>
+                    let calldata = if let Some(calldata) = ctx.value.calldata {
+                        ctx.env
+                            .create_buffer_with_data(calldata.to_vec())?
+                            .into_unknown()
+                    } else {
+                        ctx.env.get_undefined()?.into_unknown()
+                    };
 
-                let promise = ctx.callback.call(None, &[code, calldata])?;
-                let result = await_promise::<ContractAndFunctionName, (String, Option<String>)>(
-                    ctx.env,
-                    promise,
-                    ctx.value.sender,
-                );
+                    Ok(vec![code, calldata])
+                },
+            )?;
 
-                handle_error(sender, result)
-            },
-        )?;
+        // Maintain a weak reference to the function to avoid the event loop from
+        // exiting.
+        get_contract_and_function_name_fn.unref(env)?;
 
-        let print_line_fn = ThreadsafeFunction::create(
-            env.raw(),
-            // SAFETY: The callback is guaranteed to be valid for the lifetime of the tracer.
-            unsafe { config.print_line_callback.raw() },
+        let mut print_line_fn = config.print_line_callback.create_threadsafe_function(
             0,
             |ctx: ThreadSafeCallContext<(String, bool)>| {
                 // String
@@ -365,12 +312,14 @@ impl LogCollector {
                 // bool
                 let replace = ctx.env.get_boolean(ctx.value.1)?;
 
-                ctx.callback
-                    .call(None, &[message.into_unknown(), replace.into_unknown()])?;
-                Ok(())
+                Ok(vec![message.into_unknown(), replace.into_unknown()])
             },
         )?;
 
+        // Maintain a weak reference to the function to avoid the event loop from
+        // exiting.
+        print_line_fn.unref(env)?;
+
         Ok(Self {
             decode_console_log_inputs_fn,
             get_contract_and_function_name_fn,
@@ -599,14 +548,21 @@ impl LogCollector {
     ) -> (String, Option<String>) {
         let (sender, receiver) = channel();
 
-        let status = self.get_contract_and_function_name_fn.call(
-            ContractAndFunctionNameCall {
-                code,
-                calldata,
-                sender,
-            },
-            ThreadsafeFunctionCallMode::Blocking,
-        );
+        let status = self
+            .get_contract_and_function_name_fn
+            .call_with_return_value(
+                ContractAndFunctionNameCall { code, calldata },
+                ThreadsafeFunctionCallMode::Blocking,
+                move |result: ContractAndFunctionName| {
+                    let contract_and_function_name = result.try_cast();
+                    sender.send(contract_and_function_name).map_err(|_error| {
+                        napi::Error::new(
+                            Status::GenericFailure,
+                            "Failed to send result from get_contract_and_function_name",
+                        )
+                    })
+                },
+            );
         assert_eq!(status, Status::Ok);
 
         receiver
@@ -793,19 +749,21 @@ impl LogCollector {
     fn log_console_log_messages(&mut self, console_log_inputs: &[Bytes]) {
         let (sender, receiver) = channel();
 
-        let status = self.decode_console_log_inputs_fn.call(
-            DecodeConsoleLogInputsCall {
-                inputs: console_log_inputs.to_vec(),
-                sender,
-            },
+        let status = self.decode_console_log_inputs_fn.call_with_return_value(
+            console_log_inputs.to_vec(),
             ThreadsafeFunctionCallMode::Blocking,
+            move |decoded_inputs: Vec<String>| {
+                sender.send(decoded_inputs).map_err(|_error| {
+                    napi::Error::new(
+                        Status::GenericFailure,
+                        "Failed to send result from decode_console_log_inputs",
+                    )
+                })
+            },
         );
         assert_eq!(status, Status::Ok);
 
-        let console_log_inputs = receiver
-            .recv()
-            .unwrap()
-            .expect("Failed call to decode_console_log_inputs");
+        let console_log_inputs = receiver.recv().unwrap();
         // This is a special case, as we always want to print the console.log messages.
         // The difference is how. If we have a logger, we should use that, so that logs
         // are printed in order. If we don't, we just print the messages here.
@@ -840,9 +798,9 @@ impl LogCollector {
             if let Some(to) = before_message.to {
                 // Call
                 let is_precompile = {
-                    let num_precompiles =
-                        Precompiles::new(precompile::SpecId::from_spec_id(spec_id)).len();
-                    precompile::is_precompile(to, num_precompiles)
+                    let precompiles =
+                        Precompiles::new(precompile::PrecompileSpecId::from_spec_id(spec_id));
+                    precompiles.contains(&to)
                 };
 
                 if is_precompile {

package/src/result.rs

@@ -1,5 +1,3 @@
-use std::mem;
-
 use napi::{
     bindgen_prelude::{BigInt, Buffer, Either3},
     Either, Env, JsBuffer, JsBufferValue,
@@ -19,17 +17,17 @@ pub enum SuccessReason {
     SelfDestruct,
 }
 
-impl From<edr_evm::Eval> for SuccessReason {
-    fn from(eval: edr_evm::Eval) -> Self {
+impl From<edr_evm::SuccessReason> for SuccessReason {
+    fn from(eval: edr_evm::SuccessReason) -> Self {
         match eval {
-            edr_evm::Eval::Stop => Self::Stop,
-            edr_evm::Eval::Return => Self::Return,
-            edr_evm::Eval::SelfDestruct => Self::SelfDestruct,
+            edr_evm::SuccessReason::Stop => Self::Stop,
+            edr_evm::SuccessReason::Return => Self::Return,
+            edr_evm::SuccessReason::SelfDestruct => Self::SelfDestruct,
         }
     }
 }
 
-impl From<SuccessReason> for edr_evm::Eval {
+impl From<SuccessReason> for edr_evm::SuccessReason {
     fn from(value: SuccessReason) -> Self {
         match value {
             SuccessReason::Stop => Self::Stop,
@@ -97,43 +95,47 @@ pub enum ExceptionalHalt {
     /// Error on created contract that begins with EF
     CreateContractStartingWithEF,
     /// EIP-3860: Limit and meter initcode. Initcode size limit exceeded.
-    CreateInitcodeSizeLimit,
+    CreateInitCodeSizeLimit,
 }
 
-impl From<edr_evm::Halt> for ExceptionalHalt {
-    fn from(halt: edr_evm::Halt) -> Self {
+impl From<edr_evm::HaltReason> for ExceptionalHalt {
+    fn from(halt: edr_evm::HaltReason) -> Self {
         match halt {
-            edr_evm::Halt::OutOfGas(..) => ExceptionalHalt::OutOfGas,
-            edr_evm::Halt::OpcodeNotFound => ExceptionalHalt::OpcodeNotFound,
-            edr_evm::Halt::InvalidFEOpcode => ExceptionalHalt::InvalidFEOpcode,
-            edr_evm::Halt::InvalidJump => ExceptionalHalt::InvalidJump,
-            edr_evm::Halt::NotActivated => ExceptionalHalt::NotActivated,
-            edr_evm::Halt::StackUnderflow => ExceptionalHalt::StackUnderflow,
-            edr_evm::Halt::StackOverflow => ExceptionalHalt::StackOverflow,
-            edr_evm::Halt::OutOfOffset => ExceptionalHalt::OutOfOffset,
-            edr_evm::Halt::CreateCollision => ExceptionalHalt::CreateCollision,
-            edr_evm::Halt::PrecompileError => ExceptionalHalt::PrecompileError,
-            edr_evm::Halt::NonceOverflow => ExceptionalHalt::NonceOverflow,
-            edr_evm::Halt::CreateContractSizeLimit => ExceptionalHalt::CreateContractSizeLimit,
-            edr_evm::Halt::CreateContractStartingWithEF => {
+            edr_evm::HaltReason::OutOfGas(..) => ExceptionalHalt::OutOfGas,
+            edr_evm::HaltReason::OpcodeNotFound => ExceptionalHalt::OpcodeNotFound,
+            edr_evm::HaltReason::InvalidFEOpcode => ExceptionalHalt::InvalidFEOpcode,
+            edr_evm::HaltReason::InvalidJump => ExceptionalHalt::InvalidJump,
+            edr_evm::HaltReason::NotActivated => ExceptionalHalt::NotActivated,
+            edr_evm::HaltReason::StackUnderflow => ExceptionalHalt::StackUnderflow,
+            edr_evm::HaltReason::StackOverflow => ExceptionalHalt::StackOverflow,
+            edr_evm::HaltReason::OutOfOffset => ExceptionalHalt::OutOfOffset,
+            edr_evm::HaltReason::CreateCollision => ExceptionalHalt::CreateCollision,
+            edr_evm::HaltReason::PrecompileError => ExceptionalHalt::PrecompileError,
+            edr_evm::HaltReason::NonceOverflow => ExceptionalHalt::NonceOverflow,
+            edr_evm::HaltReason::CreateContractSizeLimit => {
+                ExceptionalHalt::CreateContractSizeLimit
+            }
+            edr_evm::HaltReason::CreateContractStartingWithEF => {
                 ExceptionalHalt::CreateContractStartingWithEF
             }
-            edr_evm::Halt::CreateInitcodeSizeLimit => ExceptionalHalt::CreateInitcodeSizeLimit,
-            edr_evm::Halt::OverflowPayment
-            | edr_evm::Halt::StateChangeDuringStaticCall
-            | edr_evm::Halt::CallNotAllowedInsideStatic
-            | edr_evm::Halt::OutOfFund
-            | edr_evm::Halt::CallTooDeep => {
+            edr_evm::HaltReason::CreateInitCodeSizeLimit => {
+                ExceptionalHalt::CreateInitCodeSizeLimit
+            }
+            edr_evm::HaltReason::OverflowPayment
+            | edr_evm::HaltReason::StateChangeDuringStaticCall
+            | edr_evm::HaltReason::CallNotAllowedInsideStatic
+            | edr_evm::HaltReason::OutOfFunds
+            | edr_evm::HaltReason::CallTooDeep => {
                 unreachable!("Internal halts that can be only found inside Inspector: {halt:?}")
             }
         }
     }
 }
 
-impl From<ExceptionalHalt> for edr_evm::Halt {
+impl From<ExceptionalHalt> for edr_evm::HaltReason {
     fn from(value: ExceptionalHalt) -> Self {
         match value {
-            ExceptionalHalt::OutOfGas => Self::OutOfGas(edr_evm::OutOfGasError::BasicOutOfGas),
+            ExceptionalHalt::OutOfGas => Self::OutOfGas(edr_evm::OutOfGasError::Basic),
             ExceptionalHalt::OpcodeNotFound => Self::OpcodeNotFound,
             ExceptionalHalt::InvalidFEOpcode => Self::InvalidFEOpcode,
             ExceptionalHalt::InvalidJump => Self::InvalidJump,
@@ -146,7 +148,7 @@ impl From<ExceptionalHalt> for edr_evm::Halt {
             ExceptionalHalt::NonceOverflow => Self::NonceOverflow,
             ExceptionalHalt::CreateContractSizeLimit => Self::CreateContractSizeLimit,
             ExceptionalHalt::CreateContractStartingWithEF => Self::CreateContractStartingWithEF,
-            ExceptionalHalt::CreateInitcodeSizeLimit => Self::CreateInitcodeSizeLimit,
+            ExceptionalHalt::CreateInitCodeSizeLimit => Self::CreateInitCodeSizeLimit,
         }
     }
 }
@@ -190,36 +192,19 @@ impl ExecutionResult {
                     logs,
                     output: match output {
                         edr_evm::Output::Call(return_value) => {
-                            let return_value = return_value.clone();
-                            Either::A(CallOutput {
-                                return_value: unsafe {
-                                    env.create_buffer_with_borrowed_data(
-                                        return_value.as_ptr(),
-                                        return_value.len(),
-                                        return_value,
-                                        |return_value: edr_eth::Bytes, _env| {
-                                            mem::drop(return_value);
-                                        },
-                                    )
-                                }
-                                .map(JsBufferValue::into_raw)?,
-                            })
+                            let return_value = env
+                                .create_buffer_with_data(return_value.to_vec())
+                                .map(JsBufferValue::into_raw)?;
+
+                            Either::A(CallOutput { return_value })
                         }
                         edr_evm::Output::Create(return_value, address) => {
-                            let return_value = return_value.clone();
+                            let return_value = env
+                                .create_buffer_with_data(return_value.to_vec())
+                                .map(JsBufferValue::into_raw)?;
 
                             Either::B(CreateOutput {
-                                return_value: unsafe {
-                                    env.create_buffer_with_borrowed_data(
-                                        return_value.as_ptr(),
-                                        return_value.len(),
-                                        return_value,
-                                        |return_value: edr_eth::Bytes, _env| {
-                                            mem::drop(return_value);
-                                        },
-                                    )
-                                }
-                                .map(JsBufferValue::into_raw)?,
+                                return_value,
                                 address: address.map(|address| Buffer::from(address.as_slice())),
                             })
                         }
@@ -227,20 +212,13 @@ impl ExecutionResult {
                 })
             }
             edr_evm::ExecutionResult::Revert { gas_used, output } => {
-                let output = output.clone();
+                let output = env
+                    .create_buffer_with_data(output.to_vec())
+                    .map(JsBufferValue::into_raw)?;
+
                 Either3::B(RevertResult {
                     gas_used: BigInt::from(*gas_used),
-                    output: unsafe {
-                        env.create_buffer_with_borrowed_data(
-                            output.as_ptr(),
-                            output.len(),
-                            output,
-                            |output: edr_eth::Bytes, _env| {
-                                mem::drop(output);
-                            },
-                        )
-                    }
-                    .map(JsBufferValue::into_raw)?,
+                    output,
                 })
             }
             edr_evm::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {

package/src/subscribe.rs

@@ -1,22 +1,21 @@
 use edr_eth::{remote::eth, B256};
-use napi::{bindgen_prelude::BigInt, Env, JsFunction, NapiRaw};
-use napi_derive::napi;
-
-use crate::threadsafe_function::{
-    ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
+use napi::{
+    bindgen_prelude::BigInt,
+    threadsafe_function::{
+        ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
+    },
+    Env, JsFunction,
 };
+use napi_derive::napi;
 
 #[derive(Clone)]
 pub struct SubscriberCallback {
-    inner: ThreadsafeFunction<edr_provider::SubscriptionEvent>,
+    inner: ThreadsafeFunction<edr_provider::SubscriptionEvent, ErrorStrategy::Fatal>,
 }
 
 impl SubscriberCallback {
     pub fn new(env: &Env, subscription_event_callback: JsFunction) -> napi::Result<Self> {
-        let callback = ThreadsafeFunction::create(
-            env.raw(),
-            // SAFETY: The callback is guaranteed to be valid for the lifetime of the inspector.
-            unsafe { subscription_event_callback.raw() },
+        let mut callback = subscription_event_callback.create_threadsafe_function(
             0,
             |ctx: ThreadSafeCallContext<edr_provider::SubscriptionEvent>| {
                 // SubscriptionEvent
@@ -39,10 +38,14 @@ impl SubscriberCallback {
 
                 event.set_named_property("result", result)?;
 
-                ctx.callback.call(None, &[event])?;
-                Ok(())
+                Ok(vec![event])
             },
         )?;
+
+        // Maintain a weak reference to the function to avoid the event loop from
+        // exiting.
+        callback.unref(env)?;
+
         Ok(Self { inner: callback })
     }
 

package/src/trace.rs

@@ -1,6 +1,6 @@
-use std::{mem, sync::Arc};
+use std::sync::Arc;
 
-use edr_evm::{trace::BeforeMessage, OPCODE_JUMPMAP};
+use edr_evm::{interpreter::OPCODE_JUMPMAP, trace::BeforeMessage};
 use napi::{
     bindgen_prelude::{BigInt, Buffer, Either3},
     Env, JsBuffer, JsBufferValue,
@@ -47,34 +47,14 @@ pub struct TracingMessage {
 
 impl TracingMessage {
     pub fn new(env: &Env, message: &BeforeMessage) -> napi::Result<Self> {
-        let data = message.data.clone();
-        let data = unsafe {
-            env.create_buffer_with_borrowed_data(
-                data.as_ptr(),
-                data.len(),
-                data,
-                |data: edr_eth::Bytes, _env| {
-                    mem::drop(data);
-                },
-            )
-        }
-        .map(JsBufferValue::into_raw)?;
+        let data = env
+            .create_buffer_with_data(message.data.to_vec())
+            .map(JsBufferValue::into_raw)?;
 
         let code = message.code.as_ref().map_or(Ok(None), |code| {
-            let code = code.original_bytes();
-
-            unsafe {
-                env.create_buffer_with_borrowed_data(
-                    code.as_ptr(),
-                    code.len(),
-                    code,
-                    |code: edr_eth::Bytes, _env| {
-                        mem::drop(code);
-                    },
-                )
-            }
-            .map(JsBufferValue::into_raw)
-            .map(Some)
+            env.create_buffer_with_data(code.original_bytes().to_vec())
+                .map(JsBufferValue::into_raw)
+                .map(Some)
         })?;
 
         Ok(TracingMessage {

package/src/sync.rs

@@ -1,85 +0,0 @@
-use std::{fmt::Debug, sync::mpsc::Sender};
-
-use napi::{bindgen_prelude::FromNapiValue, Env, JsFunction, JsObject, JsUnknown, NapiRaw, Status};
-
-use crate::cast::TryCast;
-
-pub fn await_promise<I, O>(
-    env: Env,
-    result: JsUnknown,
-    tx: Sender<napi::Result<O>>,
-) -> napi::Result<()>
-where
-    I: FromNapiValue + TryCast<O, Error = napi::Error>,
-    O: 'static,
-{
-    // If the result is a promise, wait for it to resolve, and send the result to
-    // the channel. Otherwise, send the result immediately.
-    if result.is_promise()? {
-        let result: JsObject = result.try_into()?;
-        let then: JsFunction = result.get_named_property("then")?;
-        let tx2 = tx.clone();
-        let cb = env.create_function_from_closure("callback", move |ctx| {
-            let result = ctx.get::<I>(0)?;
-            tx.send(Ok(result.try_cast()?)).unwrap();
-            ctx.env.get_undefined()
-        })?;
-        let eb = env.create_function_from_closure("error_callback", move |ctx| {
-            // TODO: need a way to convert a JsUnknown to an Error
-            tx2.send(Err(napi::Error::from_reason("Promise rejected")))
-                .unwrap();
-            ctx.env.get_undefined()
-        })?;
-        then.call(Some(&result), &[cb, eb])?;
-    } else {
-        let result = unsafe { I::from_napi_value(env.raw(), result.raw())? };
-        tx.send(Ok(result.try_cast()?)).unwrap();
-    }
-
-    Ok(())
-}
-
-#[allow(dead_code)]
-pub fn await_void_promise(
-    env: Env,
-    result: JsUnknown,
-    tx: Sender<napi::Result<()>>,
-) -> napi::Result<()> {
-    // If the result is a promise, wait for it to resolve, and send the result to
-    // the channel. Otherwise, send the result immediately.
-    if result.is_promise()? {
-        let result: JsObject = result.try_into()?;
-        let then: JsFunction = result.get_named_property("then")?;
-        let tx2 = tx.clone();
-        let cb = env.create_function_from_closure("callback", move |ctx| {
-            tx.send(Ok(())).unwrap();
-            ctx.env.get_undefined()
-        })?;
-        let eb = env.create_function_from_closure("error_callback", move |ctx| {
-            // TODO: need a way to convert a JsUnknown to an Error
-            tx2.send(Err(napi::Error::from_reason("Promise rejected")))
-                .unwrap();
-            ctx.env.get_undefined()
-        })?;
-        then.call(Some(&result), &[cb, eb])?;
-        Ok(())
-    } else {
-        Err(napi::Error::new(
-            Status::ObjectExpected,
-            "Expected promise".to_owned(),
-        ))
-    }
-}
-
-pub fn handle_error<T: Debug>(
-    tx: Sender<napi::Result<T>>,
-    res: napi::Result<()>,
-) -> napi::Result<()> {
-    match res {
-        Ok(_) => Ok(()),
-        Err(e) => {
-            tx.send(Err(e)).expect("send error");
-            Ok(())
-        }
-    }
-}

package/src/threadsafe_function.rs

@@ -1,305 +0,0 @@
-// Fork of threadsafe_function from napi-rs that allows calling JS function
-// manually rather than only returning args. This enables us to use the return
-// value of the function.
-
-#![allow(clippy::single_component_path_imports)]
-
-use std::{
-    convert::Into,
-    ffi::CString,
-    marker::PhantomData,
-    os::raw::c_void,
-    ptr,
-    sync::{
-        atomic::{AtomicBool, AtomicUsize, Ordering},
-        Arc,
-    },
-};
-
-use napi::{check_status, sys, Env, JsError, JsFunction, NapiValue, Result, Status};
-
-/// `ThreadSafeFunction` context object
-/// the `value` is the value passed to `call` method
-pub struct ThreadSafeCallContext<T: 'static> {
-    pub env: Env,
-    pub value: T,
-    pub callback: JsFunction,
-}
-
-#[repr(u8)]
-pub enum ThreadsafeFunctionCallMode {
-    NonBlocking,
-    Blocking,
-}
-
-impl From<ThreadsafeFunctionCallMode> for sys::napi_threadsafe_function_call_mode {
-    fn from(value: ThreadsafeFunctionCallMode) -> Self {
-        match value {
-            ThreadsafeFunctionCallMode::Blocking => sys::ThreadsafeFunctionCallMode::blocking,
-            ThreadsafeFunctionCallMode::NonBlocking => sys::ThreadsafeFunctionCallMode::nonblocking,
-        }
-    }
-}
-
-/// Communicate with the addon's main thread by invoking a JavaScript function
-/// from other threads.
-///
-/// ## Example
-/// An example of using `ThreadsafeFunction`:
-///
-/// ```rust
-/// #[macro_use]
-/// extern crate napi_derive;
-///
-/// use std::thread;
-///
-/// use napi::{
-///     threadsafe_function::{
-///         ThreadSafeCallContext, ThreadsafeFunctionCallMode, ThreadsafeFunctionReleaseMode,
-///     },
-///     CallContext, Error, JsFunction, JsNumber, JsUndefined, Result, Status,
-/// };
-///
-/// #[js_function(1)]
-/// pub fn test_threadsafe_function(ctx: CallContext) -> Result<JsUndefined> {
-///   let func = ctx.get::<JsFunction>(0)?;
-///
-///   let tsfn =
-///       ctx
-///           .env
-///           .create_threadsafe_function(&func, 0, |ctx: ThreadSafeCallContext<Vec<u32>>| {
-///             ctx.value
-///                 .iter()
-///                 .map(|v| ctx.env.create_uint32(*v))
-///                 .collect::<Result<Vec<JsNumber>>>()
-///           })?;
-///
-///   let tsfn_cloned = tsfn.clone();
-///
-///   thread::spawn(move || {
-///       let output: Vec<u32> = vec![0, 1, 2, 3];
-///       // It's okay to call a threadsafe function multiple times.
-///       tsfn.call(Ok(output.clone()), ThreadsafeFunctionCallMode::Blocking);
-///   });
-///
-///   thread::spawn(move || {
-///       let output: Vec<u32> = vec![3, 2, 1, 0];
-///       // It's okay to call a threadsafe function multiple times.
-///       tsfn_cloned.call(Ok(output.clone()), ThreadsafeFunctionCallMode::NonBlocking);
-///   });
-///
-///   ctx.env.get_undefined()
-/// }
-/// ```
-#[derive(Debug)]
-pub struct ThreadsafeFunction<T: 'static> {
-    raw_tsfn: sys::napi_threadsafe_function,
-    aborted: Arc<AtomicBool>,
-    ref_count: Arc<AtomicUsize>,
-    _phantom: PhantomData<T>,
-}
-
-impl<T: 'static> Clone for ThreadsafeFunction<T> {
-    fn clone(&self) -> Self {
-        if !self.aborted.load(Ordering::Acquire) {
-            let acquire_status = unsafe { sys::napi_acquire_threadsafe_function(self.raw_tsfn) };
-            debug_assert!(
-                acquire_status == sys::Status::napi_ok,
-                "Acquire threadsafe function failed in clone"
-            );
-        }
-
-        Self {
-            raw_tsfn: self.raw_tsfn,
-            aborted: Arc::clone(&self.aborted),
-            ref_count: Arc::clone(&self.ref_count),
-            _phantom: PhantomData,
-        }
-    }
-}
-
-unsafe impl<T> Send for ThreadsafeFunction<T> {}
-unsafe impl<T> Sync for ThreadsafeFunction<T> {}
-
-impl<T: 'static> ThreadsafeFunction<T> {
-    /// See [napi_create_threadsafe_function](https://nodejs.org/api/n-api.html#n_api_napi_create_threadsafe_function)
-    /// for more information.
-    pub(crate) fn create<R: 'static + Send + FnMut(ThreadSafeCallContext<T>) -> Result<()>>(
-        env: sys::napi_env,
-        func: sys::napi_value,
-        max_queue_size: usize,
-        callback: R,
-    ) -> Result<Self> {
-        let mut async_resource_name = ptr::null_mut();
-        let s = "napi_rs_threadsafe_function";
-        let len = s.len();
-        let s = CString::new(s)?;
-        check_status!(unsafe {
-            sys::napi_create_string_utf8(env, s.as_ptr(), len, &mut async_resource_name)
-        })?;
-
-        let initial_thread_count = 1usize;
-        let mut raw_tsfn = ptr::null_mut();
-        let ptr = Box::into_raw(Box::new(callback)).cast::<c_void>();
-        check_status!(unsafe {
-            sys::napi_create_threadsafe_function(
-                env,
-                func,
-                ptr::null_mut(),
-                async_resource_name,
-                max_queue_size,
-                initial_thread_count,
-                ptr,
-                Some(thread_finalize_cb::<T, R>),
-                ptr,
-                Some(call_js_cb::<T, R>),
-                &mut raw_tsfn,
-            )
-        })?;
-
-        let aborted = Arc::new(AtomicBool::new(false));
-        let aborted_ptr = Arc::into_raw(aborted.clone()) as *mut c_void;
-        check_status!(unsafe {
-            sys::napi_add_env_cleanup_hook(env, Some(cleanup_cb), aborted_ptr)
-        })?;
-
-        Ok(ThreadsafeFunction {
-            raw_tsfn,
-            aborted,
-            ref_count: Arc::new(AtomicUsize::new(initial_thread_count)),
-            _phantom: PhantomData,
-        })
-    }
-}
-
-impl<T: 'static> ThreadsafeFunction<T> {
-    /// See [napi_call_threadsafe_function](https://nodejs.org/api/n-api.html#n_api_napi_call_threadsafe_function)
-    /// for more information.
-    pub fn call(&self, value: T, mode: ThreadsafeFunctionCallMode) -> Status {
-        if self.aborted.load(Ordering::Acquire) {
-            return Status::Closing;
-        }
-        unsafe {
-            sys::napi_call_threadsafe_function(
-                self.raw_tsfn,
-                Box::into_raw(Box::new(value)).cast(),
-                mode.into(),
-            )
-        }
-        .into()
-    }
-}
-
-impl<T: 'static> Drop for ThreadsafeFunction<T> {
-    fn drop(&mut self) {
-        if !self.aborted.load(Ordering::Acquire) && self.ref_count.load(Ordering::Acquire) > 0usize
-        {
-            let release_status = unsafe {
-                sys::napi_release_threadsafe_function(
-                    self.raw_tsfn,
-                    sys::ThreadsafeFunctionReleaseMode::release,
-                )
-            };
-            assert!(
-                release_status == sys::Status::napi_ok,
-                "Threadsafe Function release failed"
-            );
-        }
-    }
-}
-
-unsafe extern "C" fn cleanup_cb(cleanup_data: *mut c_void) {
-    let aborted = Arc::<AtomicBool>::from_raw(cleanup_data.cast());
-    aborted.store(true, Ordering::SeqCst);
-}
-
-unsafe extern "C" fn thread_finalize_cb<T: 'static, R>(
-    _raw_env: sys::napi_env,
-    finalize_data: *mut c_void,
-    _finalize_hint: *mut c_void,
-) where
-    R: 'static + Send + FnMut(ThreadSafeCallContext<T>) -> Result<()>,
-{
-    // cleanup
-    drop(Box::<R>::from_raw(finalize_data.cast()));
-}
-
-unsafe extern "C" fn call_js_cb<T: 'static, R>(
-    raw_env: sys::napi_env,
-    js_callback: sys::napi_value,
-    context: *mut c_void,
-    data: *mut c_void,
-) where
-    R: 'static + Send + FnMut(ThreadSafeCallContext<T>) -> Result<()>,
-{
-    // env and/or callback can be null when shutting down
-    if raw_env.is_null() || js_callback.is_null() {
-        return;
-    }
-
-    let ctx: &mut R = &mut *context.cast::<R>();
-    let val: Result<T> = Ok(*Box::<T>::from_raw(data.cast()));
-
-    let mut recv = ptr::null_mut();
-    sys::napi_get_undefined(raw_env, &mut recv);
-
-    let ret = val.and_then(|v| {
-        (ctx)(ThreadSafeCallContext {
-            env: Env::from_raw(raw_env),
-            value: v,
-            callback: JsFunction::from_raw(raw_env, js_callback).unwrap(), // TODO: unwrap
-        })
-    });
-
-    let status = match ret {
-        Ok(()) => sys::Status::napi_ok,
-        Err(e) => sys::napi_fatal_exception(raw_env, JsError::from(e).into_value(raw_env)),
-    };
-    if status == sys::Status::napi_ok {
-        return;
-    }
-    if status == sys::Status::napi_pending_exception {
-        let mut error_result = ptr::null_mut();
-        assert_eq!(
-            sys::napi_get_and_clear_last_exception(raw_env, &mut error_result),
-            sys::Status::napi_ok
-        );
-
-        // When shutting down, napi_fatal_exception sometimes returns another exception
-        let stat = sys::napi_fatal_exception(raw_env, error_result);
-        assert!(stat == sys::Status::napi_ok || stat == sys::Status::napi_pending_exception);
-    } else {
-        let error_code: Status = status.into();
-        let error_code_string = format!("{error_code:?}");
-        let mut error_code_value = ptr::null_mut();
-        assert_eq!(
-            sys::napi_create_string_utf8(
-                raw_env,
-                error_code_string.as_ptr().cast(),
-                error_code_string.len(),
-                &mut error_code_value,
-            ),
-            sys::Status::napi_ok,
-        );
-        let error_msg = "Call JavaScript callback failed in thread safe function";
-        let mut error_msg_value = ptr::null_mut();
-        assert_eq!(
-            sys::napi_create_string_utf8(
-                raw_env,
-                error_msg.as_ptr().cast(),
-                error_msg.len(),
-                &mut error_msg_value,
-            ),
-            sys::Status::napi_ok,
-        );
-        let mut error_value = ptr::null_mut();
-        assert_eq!(
-            sys::napi_create_error(raw_env, error_code_value, error_msg_value, &mut error_value),
-            sys::Status::napi_ok,
-        );
-        assert_eq!(
-            sys::napi_fatal_exception(raw_env, error_value),
-            sys::Status::napi_ok
-        );
-    }
-}