@nomicfoundation/edr 0.12.0-next.6 → 0.12.0-next.8

package/src/config.rs

@@ -2,15 +2,14 @@ use core::fmt::{Debug, Display};
 use std::{
     num::NonZeroU64,
     path::PathBuf,
-    sync::Arc,
     time::{Duration, SystemTime},
 };
 
 use edr_coverage::reporter::SyncOnCollectedCoverageCallback;
 use edr_eip1559::{BaseFeeActivation, ConstantBaseFeeParams};
-use edr_eth::{Bytes, HashMap, HashSet};
+use edr_gas_report::SyncOnCollectedGasReportCallback;
+use edr_primitives::{Bytes, HashMap, HashSet};
 use edr_signer::{secret_key_from_str, SecretKey};
-use edr_solidity::contract_decoder::ContractDecoder;
 use napi::{
     bindgen_prelude::{BigInt, Promise, Reference, Uint8Array},
     threadsafe_function::{
@@ -22,8 +21,8 @@ use napi::{
 use napi_derive::napi;
 
 use crate::{
-    account::AccountOverride, block::BlobGas, cast::TryCast, logger::LoggerConfig,
-    precompile::Precompile, subscription::SubscriptionConfig,
+    account::AccountOverride, block::BlobGas, cast::TryCast, gas_report::GasReport,
+    logger::LoggerConfig, precompile::Precompile, subscription::SubscriptionConfig,
 };
 
 /// Configuration for EIP-1559 parameters
@@ -36,12 +35,12 @@ pub struct BaseFeeParamActivation {
 
 #[napi(object)]
 pub struct BaseFeeActivationByBlockNumber {
-    /// The block number at which the base_fee_params is activated
+    /// The block number at which the `base_fee_params` is activated
     pub block_number: BigInt,
 }
 #[napi(object)]
 pub struct BaseFeeActivationByHardfork {
-    /// The hardfork at which the base_fee_params is activated
+    /// The hardfork at which the `base_fee_params` is activated
     pub hardfork: String,
 }
 
@@ -94,6 +93,17 @@ pub struct CodeCoverageConfig {
     pub on_collected_coverage_callback: JsFunction,
 }
 
+#[napi(object)]
+pub struct GasReportConfig {
+    /// Gas reports are collected after a block is mined or `eth_call` is
+    /// executed.
+    ///
+    /// Exceptions thrown in the callback will be propagated to the original
+    /// caller.
+    #[napi(ts_type = "(gasReport: GasReport) => Promise<void>")]
+    pub on_collected_gas_report_callback: JsFunction,
+}
+
 /// Configuration for forking a blockchain
 #[napi(object)]
 pub struct ForkConfig {
@@ -171,6 +181,8 @@ pub struct MiningConfig {
 pub struct ObservabilityConfig {
     /// If present, configures runtime observability to collect code coverage.
     pub code_coverage: Option<CodeCoverageConfig>,
+    /// If present, configures runtime observability to collect gas reports.
+    pub gas_report: Option<GasReportConfig>,
 }
 
 /// Configuration for a provider
@@ -187,7 +199,7 @@ pub struct ProviderConfig {
     /// EIP-1559 base fee parameters activations to be used to calculate the
     /// block base fee.
     ///
-    /// Provide an ordered list of base_fee_params to be
+    /// Provide an ordered list of `base_fee_params` to be
     /// used starting from the specified activation point (hardfork or block
     /// number).
     /// If not provided, the default values from the chain spec
@@ -387,6 +399,8 @@ impl ObservabilityConfig {
             .code_coverage
             .map(
                 |code_coverage| -> napi::Result<Box<dyn SyncOnCollectedCoverageCallback>> {
+                    let runtime = runtime.clone();
+
                     let mut on_collected_coverage_callback: ThreadsafeFunction<
                         _,
                         ErrorStrategy::Fatal,
@@ -452,9 +466,61 @@ impl ObservabilityConfig {
                 },
             )
             .transpose()?;
+        let on_collected_gas_report_fn = self.gas_report.map(
+            |gas_report| -> napi::Result<Box<dyn SyncOnCollectedGasReportCallback>> {
+                let mut on_collected_gas_report_callback: ThreadsafeFunction<
+                    _,
+                    ErrorStrategy::Fatal,
+                > = gas_report
+                    .on_collected_gas_report_callback
+                    .create_threadsafe_function(
+                        0,
+                        |ctx: ThreadSafeCallContext<GasReport>| {
+                            let report = ctx.value;
+                            Ok(vec![report])
+                        }
+                        ,
+                    )?;
+                // Maintain a weak reference to the function to avoid blocking the event loop
+                // from exiting.
+                on_collected_gas_report_callback.unref(env)?;
+
+                let on_collected_gas_report_fn: Box<dyn SyncOnCollectedGasReportCallback> =
+                    Box::new(move |report| {
+                        let runtime = runtime.clone();
+
+                        let (sender, receiver) = std::sync::mpsc::channel();
+
+                        // Convert the report to the N-API representation
+                        let status = on_collected_gas_report_callback
+                            .call_with_return_value(GasReport::from(report), ThreadsafeFunctionCallMode::Blocking, move |result: Promise<()>| {
+                                // We spawn a background task to handle the async callback
+                                runtime.spawn(async move {
+                                    let result = result.await;
+                                    sender.send(result).map_err(|_error| {
+                                        napi::Error::new(
+                                            napi::Status::GenericFailure,
+                                            "Failed to send result from on_collected_gas_report_callback",
+                                        )
+                                    })
+                                });
+                                Ok(())
+                            });
+
+                        assert_eq!(status, napi::Status::Ok);
+
+                        let () = receiver.recv().expect("Receive can only fail if the channel is closed")?;
+
+                        Ok(())
+                    });
+
+                Ok(on_collected_gas_report_fn)
+            },
+        ).transpose()?;
 
         Ok(edr_provider::observability::Config {
             on_collected_coverage_fn,
+            on_collected_gas_report_fn,
             ..edr_provider::observability::Config::default()
         })
     }
@@ -511,7 +577,7 @@ impl ProviderConfig {
             .genesis_state
             .into_iter()
             .map(TryInto::try_into)
-            .collect::<napi::Result<HashMap<edr_eth::Address, edr_provider::AccountOverride>>>()?;
+            .collect::<napi::Result<HashMap<edr_primitives::Address, edr_provider::AccountOverride>>>()?;
 
         let precompile_overrides = self
             .precompile_overrides
@@ -606,7 +672,6 @@ impl From<BuildInfoAndOutput> for edr_napi_core::solidity::config::BuildInfoAndO
 
 /// Result of [`resolve_configs`].
 pub struct ConfigResolution {
-    pub contract_decoder: Arc<ContractDecoder>,
     pub logger_config: edr_napi_core::logger::Config,
     pub provider_config: edr_napi_core::provider::Config,
     pub subscription_callback: edr_napi_core::subscription::Callback,
@@ -619,28 +684,15 @@ pub fn resolve_configs(
     provider_config: ProviderConfig,
     logger_config: LoggerConfig,
     subscription_config: SubscriptionConfig,
-    tracing_config: TracingConfigWithBuffers,
 ) -> napi::Result<ConfigResolution> {
     let provider_config = provider_config.resolve(env, runtime)?;
     let logger_config = logger_config.resolve(env)?;
 
-    // TODO: https://github.com/NomicFoundation/edr/issues/760
-    let build_info_config = edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
-        (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(tracing_config)).into(),
-    )
-    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
-
-    let contract_decoder = ContractDecoder::new(&build_info_config).map_or_else(
-        |error| Err(napi::Error::from_reason(error.to_string())),
-        |contract_decoder| Ok(Arc::new(contract_decoder)),
-    )?;
-
     let subscription_config = edr_napi_core::subscription::Config::from(subscription_config);
     let subscription_callback =
         edr_napi_core::subscription::Callback::new(env, subscription_config.subscription_callback)?;
 
     Ok(ConfigResolution {
-        contract_decoder,
         logger_config,
         provider_config,
         subscription_callback,

package/src/context.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
-use edr_eth::HashMap;
 use edr_napi_core::{provider::SyncProviderFactory, solidity};
+use edr_primitives::HashMap;
 use edr_solidity_tests::{
     decode::RevertDecoder,
     multi_runner::{SuiteResultAndArtifactId, TestContract, TestContracts},
@@ -19,13 +19,14 @@ use tracing_subscriber::{prelude::*, EnvFilter, Registry};
 
 use crate::{
     config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
+    contract_decoder::ContractDecoder,
     logger::LoggerConfig,
     provider::{Provider, ProviderFactory},
     solidity_tests::{
         artifact::{Artifact, ArtifactId},
         config::SolidityTestRunnerConfigArgs,
         factory::SolidityTestRunnerFactory,
-        test_results::SuiteResult,
+        test_results::{SolidityTestResult, SuiteResult},
         LinkingOutput,
     },
     subscription::SubscriptionConfig,
@@ -38,7 +39,7 @@ pub struct EdrContext {
 
 #[napi]
 impl EdrContext {
-    #[doc = "Creates a new [`EdrContext`] instance. Should only be called once!"]
+    /// Creates a new [`EdrContext`] instance. Should only be called once!
     #[napi(catch_unwind, constructor)]
     pub fn new() -> napi::Result<Self> {
         let context = Context::new()?;
@@ -48,7 +49,7 @@ impl EdrContext {
         })
     }
 
-    #[doc = "Constructs a new provider with the provided configuration."]
+    /// Constructs a new provider with the provided configuration.
     #[napi(catch_unwind, ts_return_type = "Promise<Provider>")]
     pub fn create_provider(
         &self,
@@ -57,7 +58,7 @@ impl EdrContext {
         provider_config: ProviderConfig,
         logger_config: LoggerConfig,
         subscription_config: SubscriptionConfig,
-        tracing_config: TracingConfigWithBuffers,
+        contract_decoder: &ContractDecoder,
     ) -> napi::Result<JsObject> {
         let (deferred, promise) = env.create_deferred()?;
 
@@ -76,7 +77,6 @@ impl EdrContext {
         let runtime = runtime::Handle::current();
 
         let ConfigResolution {
-            contract_decoder,
             logger_config,
             provider_config,
             subscription_callback,
@@ -86,7 +86,6 @@ impl EdrContext {
             provider_config,
             logger_config,
             subscription_config,
-            tracing_config
         ));
 
         #[cfg(feature = "scenarios")]
@@ -105,6 +104,7 @@ impl EdrContext {
             try_or_reject_promise!(context.get_provider_factory(&chain_type))
         };
 
+        let contract_decoder = Arc::clone(contract_decoder.as_inner());
         runtime.clone().spawn_blocking(move || {
             let result = factory
                 .create_provider(
@@ -130,7 +130,7 @@ impl EdrContext {
         Ok(promise)
     }
 
-    #[doc = "Registers a new provider factory for the provided chain type."]
+    /// Registers a new provider factory for the provided chain type.
     #[napi(catch_unwind)]
     pub async fn register_provider_factory(
         &self,
@@ -153,14 +153,29 @@ impl EdrContext {
         Ok(())
     }
 
-    #[doc = "Executes Solidity tests."]
-    #[doc = ""]
-    #[doc = "The function will return as soon as test execution is started."]
-    #[doc = "The progress callback will be called with the results of each test"]
-    #[doc = "suite. It is up to the caller to track how many times the callback"]
-    #[doc = "is called to know when all tests are done."]
+    /// Executes Solidity tests
+    ///
+    /// The function will return a promise that resolves to a
+    /// [`SolidityTestResult`].
+    ///
+    /// Arguments:
+    /// - `chainType`: the same chain type that was passed to
+    ///   `registerProviderFactory`.
+    /// - `artifacts`: the project's compilation output artifacts. It's
+    ///   important to include include all artifacts here, otherwise cheatcodes
+    ///   that access artifacts and other functionality (e.g. auto-linking, gas
+    ///   reports) can break.
+    /// - `testSuites`: the test suite ids that specify which test suites to
+    ///   execute. The test suite artifacts must be present in `artifacts`.
+    /// - `configArgs`: solidity test runner configuration. See the struct docs
+    ///   for details.
+    /// - `tracingConfig`: the build infos used for stack trace generation.
+    ///   These are lazily parsed and it's important that they're passed as
+    ///   Uint8 arrays for performance.
+    /// - `onTestSuiteCompletedCallback`: The progress callback will be called
+    ///   with the results of each test suite as soon as it finished executing.
     #[allow(clippy::too_many_arguments)]
-    #[napi(catch_unwind, ts_return_type = "Promise<void>")]
+    #[napi(catch_unwind, ts_return_type = "Promise<SolidityTestResult>")]
     pub fn run_solidity_tests(
         &self,
         env: Env,
@@ -291,7 +306,7 @@ impl EdrContext {
                 .expect("Failed to join test runner factory thread"));
 
             let runtime_for_runner = runtime.clone();
-            let () = try_or_reject_deferred!(runtime
+            let test_result = try_or_reject_deferred!(runtime
                 .clone()
                 .spawn_blocking(move || {
                     test_runner.run_tests(
@@ -323,7 +338,7 @@ impl EdrContext {
                 .await
                 .expect("Failed to join test runner thread"));
 
-            deferred.resolve(move |_env| Ok(()));
+            deferred.resolve(move |_env| Ok(SolidityTestResult::from(test_result)));
         });
 
         Ok(promise)

package/src/contract_decoder.rs

@@ -0,0 +1,57 @@
+use std::sync::Arc;
+
+use napi_derive::napi;
+
+use crate::config::TracingConfigWithBuffers;
+
+#[napi]
+pub struct ContractDecoder {
+    inner: Arc<edr_solidity::contract_decoder::ContractDecoder>,
+}
+
+#[napi]
+impl ContractDecoder {
+    #[doc = "Creates an empty instance."]
+    #[napi(constructor, catch_unwind)]
+    // Following TS convention for the constructor without arguments to be `new()`.
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        Self {
+            inner: Arc::new(edr_solidity::contract_decoder::ContractDecoder::default()),
+        }
+    }
+
+    #[doc = "Creates a new instance with the provided configuration."]
+    #[napi(factory, catch_unwind)]
+    pub fn with_contracts(config: TracingConfigWithBuffers) -> napi::Result<Self> {
+        let build_info_config = edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
+            (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(config)).into(),
+        )
+        .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+        let contract_decoder =
+            edr_solidity::contract_decoder::ContractDecoder::new(&build_info_config).map_or_else(
+                |error| Err(napi::Error::from_reason(error.to_string())),
+                |contract_decoder| Ok(Arc::new(contract_decoder)),
+            )?;
+
+        Ok(Self {
+            inner: contract_decoder,
+        })
+    }
+}
+
+impl ContractDecoder {
+    /// Returns a reference to the inner contract decoder.
+    pub fn as_inner(&self) -> &Arc<edr_solidity::contract_decoder::ContractDecoder> {
+        &self.inner
+    }
+}
+
+impl From<Arc<edr_solidity::contract_decoder::ContractDecoder>> for ContractDecoder {
+    fn from(contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>) -> Self {
+        Self {
+            inner: contract_decoder,
+        }
+    }
+}

package/src/debug_trace.rs

@@ -3,6 +3,8 @@ use std::collections::HashMap;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
+// False positive: imported by HH2
+#[allow(dead_code)]
 #[napi(object)]
 pub struct DebugTraceResult {
     pub pass: bool,

package/src/gas_report.rs

@@ -0,0 +1,92 @@
+use std::collections::HashMap;
+
+use napi::bindgen_prelude::BigInt;
+use napi_derive::napi;
+
+#[napi(object)]
+pub struct GasReport {
+    pub contracts: HashMap<String, ContractGasReport>,
+}
+
+#[napi(object)]
+pub struct ContractGasReport {
+    pub deployments: Vec<DeploymentGasReport>,
+    pub functions: HashMap<String, Vec<FunctionGasReport>>,
+}
+
+#[napi]
+pub enum GasReportExecutionStatus {
+    Success,
+    Revert,
+    Halt,
+}
+
+#[napi(object)]
+pub struct DeploymentGasReport {
+    pub gas: BigInt,
+    pub size: BigInt,
+    pub status: GasReportExecutionStatus,
+}
+
+#[napi(object)]
+pub struct FunctionGasReport {
+    pub gas: BigInt,
+    pub status: GasReportExecutionStatus,
+}
+
+impl From<edr_gas_report::GasReport> for GasReport {
+    fn from(value: edr_gas_report::GasReport) -> Self {
+        Self {
+            contracts: value
+                .into_inner()
+                .into_iter()
+                .map(|(k, v)| (k, v.into()))
+                .collect(),
+        }
+    }
+}
+
+impl From<edr_gas_report::ContractGasReport> for ContractGasReport {
+    fn from(value: edr_gas_report::ContractGasReport) -> Self {
+        Self {
+            deployments: value.deployments.into_iter().map(Into::into).collect(),
+            functions: value
+                .functions
+                .into_iter()
+                .map(|(k, v)| {
+                    let function_reports = v.into_iter().map(FunctionGasReport::from).collect();
+                    (k, function_reports)
+                })
+                .collect(),
+        }
+    }
+}
+
+impl From<edr_gas_report::GasReportExecutionStatus> for GasReportExecutionStatus {
+    fn from(value: edr_gas_report::GasReportExecutionStatus) -> Self {
+        match value {
+            edr_gas_report::GasReportExecutionStatus::Success => Self::Success,
+            edr_gas_report::GasReportExecutionStatus::Revert => Self::Revert,
+            edr_gas_report::GasReportExecutionStatus::Halt => Self::Halt,
+        }
+    }
+}
+
+impl From<edr_gas_report::DeploymentGasReport> for DeploymentGasReport {
+    fn from(value: edr_gas_report::DeploymentGasReport) -> Self {
+        Self {
+            gas: BigInt::from(value.gas),
+            size: BigInt::from(value.size),
+            status: value.status.into(),
+        }
+    }
+}
+
+impl From<edr_gas_report::FunctionGasReport> for FunctionGasReport {
+    fn from(value: edr_gas_report::FunctionGasReport) -> Self {
+        Self {
+            gas: BigInt::from(value.gas),
+            status: value.status.into(),
+        }
+    }
+}

package/src/lib.rs

@@ -17,7 +17,10 @@ pub mod chains;
 pub mod config;
 /// Types related to an EDR N-API context.
 pub mod context;
+/// Types for decoding smart contract data.
+pub mod contract_decoder;
 mod debug_trace;
+pub mod gas_report;
 /// Types and functions related to code coverage instrumentation.
 pub mod instrument;
 /// Types for EVM execution logs.

package/src/logger.rs

@@ -1,7 +1,7 @@
 use std::sync::{mpsc::channel, Arc};
 
-use edr_eth::Bytes;
 use edr_napi_core::logger::LoggerError;
+use edr_primitives::Bytes;
 use napi::{
     threadsafe_function::{
         ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,

package/src/mock/time.rs

@@ -1,17 +1,18 @@
 use std::sync::Arc;
 
-use edr_eth::B256;
 use edr_evm::spec::RuntimeSpec;
 use edr_evm_spec::ChainSpec;
 use edr_generic::GenericChainSpec;
 use edr_napi_core::logger::Logger;
-use edr_rpc_eth::RpcSpec;
+use edr_primitives::B256;
+use edr_rpc_spec::RpcSpec;
 use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
 use napi_derive::napi;
 
 use crate::{
     cast::TryCast as _,
-    config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
+    config::{resolve_configs, ConfigResolution, ProviderConfig},
+    contract_decoder::ContractDecoder,
     logger::LoggerConfig,
     provider::Provider,
     subscription::SubscriptionConfig,
@@ -50,7 +51,7 @@ pub fn create_provider_with_mock_timer(
     provider_config: ProviderConfig,
     logger_config: LoggerConfig,
     subscription_config: SubscriptionConfig,
-    tracing_config: TracingConfigWithBuffers,
+    contract_decoder: &ContractDecoder,
     time: &MockTime,
 ) -> napi::Result<JsObject> {
     let (deferred, promise) = env.create_deferred()?;
@@ -70,7 +71,6 @@ pub fn create_provider_with_mock_timer(
     let runtime = runtime::Handle::current();
 
     let ConfigResolution {
-        contract_decoder,
         logger_config,
         provider_config,
         subscription_callback,
@@ -80,9 +80,9 @@ pub fn create_provider_with_mock_timer(
         provider_config,
         logger_config,
         subscription_config,
-        tracing_config,
     ));
 
+    let contract_decoder = Arc::clone(contract_decoder.as_inner());
     let timer = Arc::clone(&time.inner);
 
     runtime.clone().spawn_blocking(move || {
@@ -112,7 +112,7 @@ pub fn create_provider_with_mock_timer(
                         subscription_callback.call(event);
                     }),
                     provider_config,
-                    contract_decoder.clone(),
+                    Arc::clone(&contract_decoder),
                     timer,
                 )
                 .map_err(|error| napi::Error::from_reason(error.to_string()))?;

package/src/mock.rs

@@ -23,15 +23,6 @@ impl MockProvider {
 }
 
 impl SyncProvider for MockProvider {
-    fn add_compilation_result(
-        &self,
-        _solc_version: String,
-        _compiler_input: edr_solidity::artifacts::CompilerInput,
-        _compiler_output: edr_solidity::artifacts::CompilerOutput,
-    ) -> napi::Result<bool> {
-        Ok(false) // Mock provider does not handle compilation results
-    }
-
     fn handle_request(
         &self,
         _request: String,

package/src/precompile.rs

@@ -1,5 +1,5 @@
-use edr_eth::Address;
 use edr_evm::precompile::{self, PrecompileFn, PrecompileWithAddress};
+use edr_primitives::Address;
 use napi::bindgen_prelude::Uint8Array;
 use napi_derive::napi;
 

package/src/provider.rs

@@ -5,18 +5,18 @@ mod response;
 use std::sync::Arc;
 
 use edr_napi_core::provider::SyncProvider;
-use edr_solidity::contract_decoder::ContractDecoder;
+use edr_solidity::compiler::create_models_and_decode_bytecodes;
 use napi::{tokio::runtime, Env, JsFunction, JsObject, Status};
 use napi_derive::napi;
 
 pub use self::factory::ProviderFactory;
 use self::response::Response;
-use crate::call_override::CallOverrideCallback;
+use crate::{call_override::CallOverrideCallback, contract_decoder::ContractDecoder};
 
 /// A JSON-RPC provider for Ethereum.
 #[napi]
 pub struct Provider {
-    contract_decoder: Arc<ContractDecoder>,
+    contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>,
     provider: Arc<dyn SyncProvider>,
     runtime: runtime::Handle,
     #[cfg(feature = "scenarios")]
@@ -28,7 +28,7 @@ impl Provider {
     pub fn new(
         provider: Arc<dyn SyncProvider>,
         runtime: runtime::Handle,
-        contract_decoder: Arc<ContractDecoder>,
+        contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>,
         #[cfg(feature = "scenarios")] scenario_file: Option<
             napi::tokio::sync::Mutex<napi::tokio::fs::File>,
         >,
@@ -54,8 +54,8 @@ impl Provider {
         solc_version: String,
         compiler_input: serde_json::Value,
         compiler_output: serde_json::Value,
-    ) -> napi::Result<bool> {
-        let provider = self.provider.clone();
+    ) -> napi::Result<()> {
+        let contract_decoder = self.contract_decoder.clone();
 
         self.runtime
             .spawn_blocking(move || {
@@ -65,12 +65,33 @@ impl Provider {
                 let compiler_output = serde_json::from_value(compiler_output)
                     .map_err(|error| napi::Error::from_reason(error.to_string()))?;
 
-                provider.add_compilation_result(solc_version, compiler_input, compiler_output)
+                let contracts = match create_models_and_decode_bytecodes(
+                    solc_version,
+                    &compiler_input,
+                    &compiler_output,
+                ) {
+                    Ok(contracts) => contracts,
+                    Err(error) => {
+                        return Err(napi::Error::from_reason(format!("Contract decoder failed to be updated. Please report this to help us improve Hardhat.\n{error}")));
+                    }
+                };
+
+                for contract in contracts {
+                    contract_decoder.add_contract_metadata(contract);
+                }
+
+                Ok(())
             })
             .await
             .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))?
     }
 
+    #[doc = "Retrieves the instance's contract decoder."]
+    #[napi(catch_unwind)]
+    pub fn contract_decoder(&self) -> ContractDecoder {
+        ContractDecoder::from(Arc::clone(&self.contract_decoder))
+    }
+
     #[doc = "Handles a JSON-RPC request and returns a JSON-RPC response."]
     #[napi(catch_unwind)]
     pub async fn handle_request(&self, request: String) -> napi::Result<Response> {