@nomicfoundation/edr 0.2.0-alpha.2

package/src/result.rs

@@ -0,0 +1,254 @@
+use std::mem;
+
+use napi::{
+    bindgen_prelude::{BigInt, Buffer, Either3},
+    Either, Env, JsBuffer, JsBufferValue,
+};
+use napi_derive::napi;
+
+use crate::log::ExecutionLog;
+
+/// The possible reasons for successful termination of the EVM.
+#[napi]
+pub enum SuccessReason {
+    /// The opcode `STOP` was called
+    Stop,
+    /// The opcode `RETURN` was called
+    Return,
+    /// The opcode `SELFDESTRUCT` was called
+    SelfDestruct,
+}
+
+impl From<edr_evm::Eval> for SuccessReason {
+    fn from(eval: edr_evm::Eval) -> Self {
+        match eval {
+            edr_evm::Eval::Stop => Self::Stop,
+            edr_evm::Eval::Return => Self::Return,
+            edr_evm::Eval::SelfDestruct => Self::SelfDestruct,
+        }
+    }
+}
+
+impl From<SuccessReason> for edr_evm::Eval {
+    fn from(value: SuccessReason) -> Self {
+        match value {
+            SuccessReason::Stop => Self::Stop,
+            SuccessReason::Return => Self::Return,
+            SuccessReason::SelfDestruct => Self::SelfDestruct,
+        }
+    }
+}
+
+#[napi(object)]
+pub struct CallOutput {
+    /// Return value
+    pub return_value: JsBuffer,
+}
+
+#[napi(object)]
+pub struct CreateOutput {
+    /// Return value
+    pub return_value: JsBuffer,
+    /// Optionally, a 160-bit address
+    pub address: Option<Buffer>,
+}
+
+/// The result when the EVM terminates successfully.
+#[napi(object)]
+pub struct SuccessResult {
+    /// The reason for termination
+    pub reason: SuccessReason,
+    /// The amount of gas used
+    pub gas_used: BigInt,
+    /// The amount of gas refunded
+    pub gas_refunded: BigInt,
+    /// The logs
+    pub logs: Vec<ExecutionLog>,
+    /// The transaction output
+    pub output: Either<CallOutput, CreateOutput>,
+}
+
+/// The result when the EVM terminates due to a revert.
+#[napi(object)]
+pub struct RevertResult {
+    /// The amount of gas used
+    pub gas_used: BigInt,
+    /// The transaction output
+    pub output: JsBuffer,
+}
+
+/// Indicates that the EVM has experienced an exceptional halt. This causes
+/// execution to immediately end with all gas being consumed.
+#[napi]
+pub enum ExceptionalHalt {
+    OutOfGas,
+    OpcodeNotFound,
+    InvalidFEOpcode,
+    InvalidJump,
+    NotActivated,
+    StackUnderflow,
+    StackOverflow,
+    OutOfOffset,
+    CreateCollision,
+    PrecompileError,
+    NonceOverflow,
+    /// Create init code size exceeds limit (runtime).
+    CreateContractSizeLimit,
+    /// Error on created contract that begins with EF
+    CreateContractStartingWithEF,
+    /// EIP-3860: Limit and meter initcode. Initcode size limit exceeded.
+    CreateInitcodeSizeLimit,
+}
+
+impl From<edr_evm::Halt> for ExceptionalHalt {
+    fn from(halt: edr_evm::Halt) -> 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 => {
+                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 => {
+                unreachable!("Internal halts that can be only found inside Inspector: {halt:?}")
+            }
+        }
+    }
+}
+
+impl From<ExceptionalHalt> for edr_evm::Halt {
+    fn from(value: ExceptionalHalt) -> Self {
+        match value {
+            ExceptionalHalt::OutOfGas => Self::OutOfGas(edr_evm::OutOfGasError::BasicOutOfGas),
+            ExceptionalHalt::OpcodeNotFound => Self::OpcodeNotFound,
+            ExceptionalHalt::InvalidFEOpcode => Self::InvalidFEOpcode,
+            ExceptionalHalt::InvalidJump => Self::InvalidJump,
+            ExceptionalHalt::NotActivated => Self::NotActivated,
+            ExceptionalHalt::StackUnderflow => Self::StackUnderflow,
+            ExceptionalHalt::StackOverflow => Self::StackOverflow,
+            ExceptionalHalt::OutOfOffset => Self::OutOfOffset,
+            ExceptionalHalt::CreateCollision => Self::CreateCollision,
+            ExceptionalHalt::PrecompileError => Self::PrecompileError,
+            ExceptionalHalt::NonceOverflow => Self::NonceOverflow,
+            ExceptionalHalt::CreateContractSizeLimit => Self::CreateContractSizeLimit,
+            ExceptionalHalt::CreateContractStartingWithEF => Self::CreateContractStartingWithEF,
+            ExceptionalHalt::CreateInitcodeSizeLimit => Self::CreateInitcodeSizeLimit,
+        }
+    }
+}
+
+/// The result when the EVM terminates due to an exceptional halt.
+#[napi(object)]
+pub struct HaltResult {
+    /// The exceptional halt that occurred
+    pub reason: ExceptionalHalt,
+    /// Halting will spend all the gas and will thus be equal to the specified
+    /// gas limit
+    pub gas_used: BigInt,
+}
+
+/// The result of executing a transaction.
+#[napi(object)]
+pub struct ExecutionResult {
+    /// The transaction result
+    pub result: Either3<SuccessResult, RevertResult, HaltResult>,
+}
+
+impl ExecutionResult {
+    pub fn new(env: &Env, result: &edr_evm::ExecutionResult) -> napi::Result<Self> {
+        let result = match result {
+            edr_evm::ExecutionResult::Success {
+                reason,
+                gas_used,
+                gas_refunded,
+                logs,
+                output,
+            } => {
+                let logs = logs
+                    .iter()
+                    .map(|log| ExecutionLog::new(env, log))
+                    .collect::<napi::Result<_>>()?;
+
+                Either3::A(SuccessResult {
+                    reason: SuccessReason::from(*reason),
+                    gas_used: BigInt::from(*gas_used),
+                    gas_refunded: BigInt::from(*gas_refunded),
+                    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)?,
+                            })
+                        }
+                        edr_evm::Output::Create(return_value, address) => {
+                            let return_value = return_value.clone();
+
+                            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)?,
+                                address: address.map(|address| Buffer::from(address.as_slice())),
+                            })
+                        }
+                    },
+                })
+            }
+            edr_evm::ExecutionResult::Revert { gas_used, output } => {
+                let output = output.clone();
+                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)?,
+                })
+            }
+            edr_evm::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
+                reason: ExceptionalHalt::from(*reason),
+                gas_used: BigInt::from(*gas_used),
+            }),
+        };
+
+        Ok(Self { result })
+    }
+}

package/src/subscribe.rs

@@ -0,0 +1,60 @@
+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,
+};
+
+#[derive(Clone)]
+pub struct SubscriberCallback {
+    inner: ThreadsafeFunction<edr_provider::SubscriptionEvent>,
+}
+
+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() },
+            0,
+            |ctx: ThreadSafeCallContext<edr_provider::SubscriptionEvent>| {
+                // SubscriptionEvent
+                let mut event = ctx.env.create_object()?;
+
+                ctx.env
+                    .create_bigint_from_words(false, ctx.value.filter_id.as_limbs().to_vec())
+                    .and_then(|filter_id| event.set_named_property("filterId", filter_id))?;
+
+                let result = match ctx.value.result {
+                    edr_provider::SubscriptionEventData::Logs(logs) => ctx.env.to_js_value(&logs),
+                    edr_provider::SubscriptionEventData::NewHeads(block) => {
+                        let block = eth::Block::<B256>::from(block);
+                        ctx.env.to_js_value(&block)
+                    }
+                    edr_provider::SubscriptionEventData::NewPendingTransactions(tx_hash) => {
+                        ctx.env.to_js_value(&tx_hash)
+                    }
+                }?;
+
+                event.set_named_property("result", result)?;
+
+                ctx.callback.call(None, &[event])?;
+                Ok(())
+            },
+        )?;
+        Ok(Self { inner: callback })
+    }
+
+    pub fn call(&self, event: edr_provider::SubscriptionEvent) {
+        // This is blocking because it's important that the subscription events are
+        // in-order
+        self.inner.call(event, ThreadsafeFunctionCallMode::Blocking);
+    }
+}
+
+#[napi(object)]
+pub struct SubscriptionEvent {
+    pub filter_id: BigInt,
+    pub result: serde_json::Value,
+}

package/src/sync.rs

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,305 @@
+// 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
+        );
+    }
+}