@nomicfoundation/edr 0.11.3 → 0.12.0-next.0

package/index.js

@@ -310,15 +310,73 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { SpecId, EdrContext, MineOrdering, Provider, Response, SuccessReason, ExceptionalHalt, linkHexStringBytecode, printStackTrace, Exit, ExitCode, BytecodeWrapper, ContractFunctionType, ReturnData, StackTraceEntryType, stackTraceEntryTypeToString, FALLBACK_FUNCTION_NAME, RECEIVE_FUNCTION_NAME, CONSTRUCTOR_FUNCTION_NAME, UNRECOGNIZED_FUNCTION_NAME, UNKNOWN_FUNCTION_NAME, PRECOMPILE_FUNCTION_NAME, UNRECOGNIZED_CONTRACT_NAME, RawTrace, getLatestSupportedSolcVersion } = nativeBinding
+const { GENERIC_CHAIN_TYPE, genericChainProviderFactory, L1_CHAIN_TYPE, l1GenesisState, l1ProviderFactory, SpecId, l1HardforkFromString, l1HardforkToString, l1HardforkLatest, FRONTIER, FRONTIER_THAWING, HOMESTEAD, DAO_FORK, TANGERINE, SPURIOUS_DRAGON, BYZANTIUM, CONSTANTINOPLE, PETERSBURG, ISTANBUL, MUIR_GLACIER, BERLIN, LONDON, ARROW_GLACIER, GRAY_GLACIER, MERGE, SHANGHAI, CANCUN, PRAGUE, OpHardfork, opHardforkFromString, opHardforkToString, opLatestHardfork, OP_CHAIN_TYPE, opGenesisState, opProviderFactory, BEDROCK, REGOLITH, CANYON, ECOTONE, FJORD, GRANITE, HOLOCENE, ISTHMUS, MineOrdering, EdrContext, addStatementCoverageInstrumentation, Precompile, precompileP256Verify, ProviderFactory, Response, Provider, SuccessReason, ExceptionalHalt, CachedChains, CachedEndpoints, FsAccessPermission, IncludeTraces, SolidityTestRunnerFactory, l1SolidityTestRunnerFactory, opSolidityTestRunnerFactory, SuiteResult, TestResult, TestStatus, CallKind, LogKind, linkHexStringBytecode, printStackTrace, Exit, ExitCode, BytecodeWrapper, ContractFunctionType, ReturnData, StackTraceEntryType, stackTraceEntryTypeToString, FALLBACK_FUNCTION_NAME, RECEIVE_FUNCTION_NAME, CONSTRUCTOR_FUNCTION_NAME, UNRECOGNIZED_FUNCTION_NAME, UNKNOWN_FUNCTION_NAME, PRECOMPILE_FUNCTION_NAME, UNRECOGNIZED_CONTRACT_NAME, RawTrace, getLatestSupportedSolcVersion } = nativeBinding
 
+module.exports.GENERIC_CHAIN_TYPE = GENERIC_CHAIN_TYPE
+module.exports.genericChainProviderFactory = genericChainProviderFactory
+module.exports.L1_CHAIN_TYPE = L1_CHAIN_TYPE
+module.exports.l1GenesisState = l1GenesisState
+module.exports.l1ProviderFactory = l1ProviderFactory
 module.exports.SpecId = SpecId
-module.exports.EdrContext = EdrContext
+module.exports.l1HardforkFromString = l1HardforkFromString
+module.exports.l1HardforkToString = l1HardforkToString
+module.exports.l1HardforkLatest = l1HardforkLatest
+module.exports.FRONTIER = FRONTIER
+module.exports.FRONTIER_THAWING = FRONTIER_THAWING
+module.exports.HOMESTEAD = HOMESTEAD
+module.exports.DAO_FORK = DAO_FORK
+module.exports.TANGERINE = TANGERINE
+module.exports.SPURIOUS_DRAGON = SPURIOUS_DRAGON
+module.exports.BYZANTIUM = BYZANTIUM
+module.exports.CONSTANTINOPLE = CONSTANTINOPLE
+module.exports.PETERSBURG = PETERSBURG
+module.exports.ISTANBUL = ISTANBUL
+module.exports.MUIR_GLACIER = MUIR_GLACIER
+module.exports.BERLIN = BERLIN
+module.exports.LONDON = LONDON
+module.exports.ARROW_GLACIER = ARROW_GLACIER
+module.exports.GRAY_GLACIER = GRAY_GLACIER
+module.exports.MERGE = MERGE
+module.exports.SHANGHAI = SHANGHAI
+module.exports.CANCUN = CANCUN
+module.exports.PRAGUE = PRAGUE
+module.exports.OpHardfork = OpHardfork
+module.exports.opHardforkFromString = opHardforkFromString
+module.exports.opHardforkToString = opHardforkToString
+module.exports.opLatestHardfork = opLatestHardfork
+module.exports.OP_CHAIN_TYPE = OP_CHAIN_TYPE
+module.exports.opGenesisState = opGenesisState
+module.exports.opProviderFactory = opProviderFactory
+module.exports.BEDROCK = BEDROCK
+module.exports.REGOLITH = REGOLITH
+module.exports.CANYON = CANYON
+module.exports.ECOTONE = ECOTONE
+module.exports.FJORD = FJORD
+module.exports.GRANITE = GRANITE
+module.exports.HOLOCENE = HOLOCENE
+module.exports.ISTHMUS = ISTHMUS
 module.exports.MineOrdering = MineOrdering
-module.exports.Provider = Provider
+module.exports.EdrContext = EdrContext
+module.exports.addStatementCoverageInstrumentation = addStatementCoverageInstrumentation
+module.exports.Precompile = Precompile
+module.exports.precompileP256Verify = precompileP256Verify
+module.exports.ProviderFactory = ProviderFactory
 module.exports.Response = Response
+module.exports.Provider = Provider
 module.exports.SuccessReason = SuccessReason
 module.exports.ExceptionalHalt = ExceptionalHalt
+module.exports.CachedChains = CachedChains
+module.exports.CachedEndpoints = CachedEndpoints
+module.exports.FsAccessPermission = FsAccessPermission
+module.exports.IncludeTraces = IncludeTraces
+module.exports.SolidityTestRunnerFactory = SolidityTestRunnerFactory
+module.exports.l1SolidityTestRunnerFactory = l1SolidityTestRunnerFactory
+module.exports.opSolidityTestRunnerFactory = opSolidityTestRunnerFactory
+module.exports.SuiteResult = SuiteResult
+module.exports.TestResult = TestResult
+module.exports.TestStatus = TestStatus
+module.exports.CallKind = CallKind
+module.exports.LogKind = LogKind
 module.exports.linkHexStringBytecode = linkHexStringBytecode
 module.exports.printStackTrace = printStackTrace
 module.exports.Exit = Exit

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.11.3",
+  "version": "0.12.0-next.0",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
+    "@nomicfoundation/ethereumjs-util": "^9.0.4",
     "@types/chai": "^4.2.0",
     "@types/chai-as-promised": "^7.1.8",
     "@types/mocha": ">=9.1.0",
@@ -21,7 +22,7 @@
     "mocha": "^10.0.0",
     "prettier": "^3.2.5",
     "ts-node": "^10.8.0",
-    "typescript": "~5.0.0"
+    "typescript": "~5.8.2"
   },
   "engines": {
     "node": ">= 18"
@@ -52,29 +53,32 @@
   },
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
-  "dependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.11.3",
-    "@nomicfoundation/edr-darwin-x64": "0.11.3",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.11.3",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.11.3",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.11.3",
-    "@nomicfoundation/edr-linux-x64-musl": "0.11.3",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.11.3"
+  "optionalDependencies": {
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.0",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.0",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.0",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.0",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.0",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.0",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.0"
   },
   "scripts": {
     "artifacts": "napi artifacts",
-    "build": "napi build --platform --release --no-const-enum",
-    "build:debug": "napi build --platform  --no-const-enum",
-    "build:scenarios": "napi build --platform --release --no-const-enum --features scenarios",
-    "build:tracing": "napi build --platform --release --no-const-enum --features tracing",
+    "build": "pnpm run build:publish",
+    "build:debug": "napi build --platform  --no-const-enum --features op",
+    "build:dev": "napi build --platform --release --no-const-enum --features op,test-mock",
+    "build:publish": "napi build --platform --profile napi-publish --no-const-enum --features op",
+    "build:scenarios": "napi build --platform --release --no-const-enum --features op,scenarios",
+    "build:tracing": "napi build --platform --release --no-const-enum --features op,tracing",
+    "build:typingFile": "napi build --platform --no-const-enum --features op",
     "clean": "rm -rf @nomicfoundation/edr.node",
     "eslint": "eslint 'test/**/*.ts'",
     "lint": "pnpm run prettier && pnpm run eslint",
     "lint:fix": "pnpm run prettier --write",
-    "pretest": "pnpm build",
+    "pretest": "pnpm build:dev",
     "prettier": "prettier --check \"test/**.ts\"",
     "test": "pnpm tsc && node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/*.ts\"",
-    "testNoBuild": "pnpm tsc && node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/*.ts\"",
+    "testNoBuild": "pnpm tsc && node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/{,!(mock)}.ts\"",
     "universal": "napi universal",
     "version": "napi version"
   }

package/src/account.rs

@@ -1,46 +1,123 @@
-use std::fmt::{Debug, Display};
-
-#[allow(deprecated)]
-// This is the only source file in production code where it's allowed to create
-// `DangerousSecretKeyStr`.
-use edr_eth::signature::{secret_key_from_str, DangerousSecretKeyStr};
-use napi::{bindgen_prelude::BigInt, JsString, Status};
+use derive_more::Debug;
+use edr_eth::{hex, HashMap, U256};
+use edr_solidity_tests::{backend::Predeploy, revm::state::AccountInfo};
+use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
-use serde::Serialize;
 
-use crate::cast::TryCast;
+use crate::{
+    cast::TryCast,
+    serde::{
+        serialize_bigint_as_struct, serialize_optional_bigint_as_struct,
+        serialize_optional_uint8array_as_hex, serialize_uint8array_as_hex,
+    },
+};
 
-/// An account that needs to be created during the genesis block.
+/// Specification of overrides for an account and its storage.
 #[napi(object)]
-pub struct GenesisAccount {
-    // Using JsString here as it doesn't have `Debug`, `Display` and `Serialize` implementation
-    // which prevents accidentally leaking the secret keys to error messages and logs.
-    /// Account secret key
-    pub secret_key: JsString,
-    /// Account balance
-    pub balance: BigInt,
+#[derive(Clone, Debug, serde::Serialize)]
+pub struct AccountOverride {
+    /// The account's address
+    #[debug("{}", hex::encode(address))]
+    #[serde(serialize_with = "serialize_uint8array_as_hex")]
+    pub address: Uint8Array,
+    /// If present, the overwriting balance.
+    #[serde(serialize_with = "serialize_optional_bigint_as_struct")]
+    pub balance: Option<BigInt>,
+    /// If present, the overwriting nonce.
+    #[serde(serialize_with = "serialize_optional_bigint_as_struct")]
+    pub nonce: Option<BigInt>,
+    /// If present, the overwriting code.
+    #[debug("{:?}", code.as_ref().map(hex::encode))]
+    #[serde(serialize_with = "serialize_optional_uint8array_as_hex")]
+    pub code: Option<Uint8Array>,
+    /// BEWARE: This field is not supported yet. See <https://github.com/NomicFoundation/edr/issues/911>
+    ///
+    /// If present, the overwriting storage.
+    pub storage: Option<Vec<StorageSlot>>,
 }
 
-impl TryFrom<GenesisAccount> for edr_provider::AccountConfig {
+impl TryFrom<AccountOverride> for (edr_eth::Address, edr_provider::AccountOverride) {
     type Error = napi::Error;
 
-    fn try_from(value: GenesisAccount) -> Result<Self, Self::Error> {
-        static_assertions::assert_not_impl_all!(JsString: Debug, Display, Serialize);
-        // `k256::SecretKey` has `Debug` implementation, but it's opaque (only shows the
-        // type name)
-        static_assertions::assert_not_impl_any!(k256::SecretKey: Display, Serialize);
+    fn try_from(value: AccountOverride) -> Result<Self, Self::Error> {
+        let AccountOverride {
+            address,
+            balance,
+            nonce,
+            code,
+            storage,
+        } = value;
+        let storage = storage
+            .map(|storage| {
+                storage
+                    .into_iter()
+                    .map(|StorageSlot { index, value }| {
+                        let value = value.try_cast()?;
+                        let slot = edr_evm::state::EvmStorageSlot::new(value);
+
+                        let index: edr_eth::U256 = index.try_cast()?;
+                        Ok((index, slot))
+                    })
+                    .collect::<napi::Result<_>>()
+            })
+            .transpose()?;
+
+        let account_override = edr_provider::AccountOverride {
+            balance: balance.map(TryCast::try_cast).transpose()?,
+            nonce: nonce.map(TryCast::try_cast).transpose()?,
+            code: code.map(TryCast::try_cast).transpose()?,
+            storage,
+        };
+
+        let address: edr_eth::Address = address.try_cast()?;
 
-        let secret_key = value.secret_key.into_utf8()?;
-        // This is the only place in production code where it's allowed to use
-        // `DangerousSecretKeyStr`.
-        #[allow(deprecated)]
-        let secret_key_str = DangerousSecretKeyStr(secret_key.as_str()?);
-        let secret_key: k256::SecretKey = secret_key_from_str(secret_key_str)
-            .map_err(|e| napi::Error::new(Status::InvalidArg, e.to_string()))?;
+        Ok((address, account_override))
+    }
+}
+
+impl TryFrom<AccountOverride> for Predeploy {
+    type Error = napi::Error;
+
+    fn try_from(value: AccountOverride) -> Result<Self, Self::Error> {
+        let (address, account_override) = value.try_into()?;
+
+        let storage = account_override.storage.unwrap_or_else(HashMap::new);
+        let balance = account_override.balance.unwrap_or(U256::ZERO);
+        let nonce = account_override.nonce.unwrap_or(0);
+        let code = account_override.code.ok_or_else(|| {
+            napi::Error::from_reason(format!("Predeploy with address '{address}' must have code"))
+        })?;
+
+        if code.is_empty() {
+            return Err(napi::Error::from_reason(
+                "Predeploy with address '{address}' must have non-empty code",
+            ));
+        }
+        let code_hash = code.hash_slow();
+
+        let account_info = AccountInfo {
+            balance,
+            nonce,
+            code_hash,
+            code: Some(code),
+        };
 
         Ok(Self {
-            secret_key,
-            balance: value.balance.try_cast()?,
+            address,
+            account_info,
+            storage,
         })
     }
 }
+
+/// A description of a storage slot's state.
+#[napi(object)]
+#[derive(Clone, Debug, serde::Serialize)]
+pub struct StorageSlot {
+    /// The storage slot's index
+    #[serde(serialize_with = "serialize_bigint_as_struct")]
+    pub index: BigInt,
+    /// The storage slot's value
+    #[serde(serialize_with = "serialize_bigint_as_struct")]
+    pub value: BigInt,
+}

package/src/block.rs

@@ -1,108 +1,7 @@
-use edr_eth::{Address, Bytes, B256, B64};
-use napi::bindgen_prelude::{BigInt, Buffer};
+use napi::bindgen_prelude::BigInt;
 use napi_derive::napi;
 
-use crate::{cast::TryCast, withdrawal::Withdrawal};
-
-#[napi(object)]
-pub struct BlockOptions {
-    /// The parent block's hash
-    pub parent_hash: Option<Buffer>,
-    /// The block's beneficiary
-    pub beneficiary: Option<Buffer>,
-    /// The state's root hash
-    pub state_root: Option<Buffer>,
-    /// The block's difficulty
-    pub difficulty: Option<BigInt>,
-    /// The block's number
-    pub number: Option<BigInt>,
-    /// The block's gas limit
-    pub gas_limit: Option<BigInt>,
-    /// The block's timestamp
-    pub timestamp: Option<BigInt>,
-    /// The block's extra data
-    pub extra_data: Option<Buffer>,
-    /// The block's mix hash (or prevrandao)
-    pub mix_hash: Option<Buffer>,
-    /// The block's nonce
-    pub nonce: Option<Buffer>,
-    /// The block's base gas fee
-    pub base_fee: Option<BigInt>,
-    /// The block's withdrawals
-    pub withdrawals: Option<Vec<Withdrawal>>,
-    /// Blob gas was added by EIP-4844 and is ignored in older headers.
-    pub blob_gas: Option<BlobGas>,
-    /// The hash tree root of the parent beacon block for the given execution
-    /// block (EIP-4788).
-    pub parent_beacon_block_root: Option<Buffer>,
-    /// The commitment hash calculated for a list of [EIP-7685] data requests.
-    ///
-    /// [EIP-7685]: https://eips.ethereum.org/EIPS/eip-7685
-    pub requests_hash: Option<Buffer>,
-}
-
-impl TryFrom<BlockOptions> for edr_eth::block::BlockOptions {
-    type Error = napi::Error;
-
-    #[cfg_attr(feature = "tracing", tracing::instrument(skip_all))]
-    fn try_from(value: BlockOptions) -> Result<Self, Self::Error> {
-        Ok(Self {
-            parent_hash: value
-                .parent_hash
-                .map(TryCast::<B256>::try_cast)
-                .transpose()?,
-            beneficiary: value
-                .beneficiary
-                .map(TryCast::<Address>::try_cast)
-                .transpose()?,
-            state_root: value
-                .state_root
-                .map(TryCast::<B256>::try_cast)
-                .transpose()?,
-            difficulty: value
-                .difficulty
-                .map_or(Ok(None), |difficulty| difficulty.try_cast().map(Some))?,
-            number: value
-                .number
-                .map_or(Ok(None), |number| number.try_cast().map(Some))?,
-            gas_limit: value
-                .gas_limit
-                .map_or(Ok(None), |gas_limit| gas_limit.try_cast().map(Some))?,
-            timestamp: value
-                .timestamp
-                .map_or(Ok(None), |timestamp| timestamp.try_cast().map(Some))?,
-            extra_data: value
-                .extra_data
-                .map(|extra_data| Bytes::copy_from_slice(&extra_data)),
-            mix_hash: value.mix_hash.map(TryCast::<B256>::try_cast).transpose()?,
-            nonce: value.nonce.map(TryCast::<B64>::try_cast).transpose()?,
-            base_fee: value
-                .base_fee
-                .map_or(Ok(None), |basefee| basefee.try_cast().map(Some))?,
-            withdrawals: value
-                .withdrawals
-                .map(|withdrawals| {
-                    withdrawals
-                        .into_iter()
-                        .map(edr_eth::withdrawal::Withdrawal::try_from)
-                        .collect()
-                })
-                .transpose()?,
-            blob_gas: value
-                .blob_gas
-                .map(edr_eth::block::BlobGas::try_from)
-                .transpose()?,
-            parent_beacon_block_root: value
-                .parent_beacon_block_root
-                .map(TryCast::<B256>::try_cast)
-                .transpose()?,
-            requests_hash: value
-                .requests_hash
-                .map(TryCast::<B256>::try_cast)
-                .transpose()?,
-        })
-    }
-}
+use crate::cast::TryCast;
 
 /// Information about the blob gas used in a block.
 #[napi(object)]

package/src/call_override.rs

@@ -2,7 +2,7 @@ use std::sync::mpsc::channel;
 
 use edr_eth::{Address, Bytes};
 use napi::{
-    bindgen_prelude::{Buffer, Promise},
+    bindgen_prelude::{Promise, Uint8Array},
     threadsafe_function::{
         ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
     },
@@ -16,7 +16,7 @@ use crate::cast::TryCast;
 /// The result of executing a call override.
 #[napi(object)]
 pub struct CallOverrideResult {
-    pub result: Buffer,
+    pub result: Uint8Array,
     pub should_revert: bool,
 }
 
@@ -27,7 +27,7 @@ impl TryCast<Option<edr_provider::CallOverrideResult>> for Option<CallOverrideRe
         match self {
             None => Ok(None),
             Some(result) => Ok(Some(edr_provider::CallOverrideResult {
-                output: result.result.try_cast()?,
+                output: Bytes::copy_from_slice(&result.result),
                 should_revert: result.should_revert,
             })),
         }
@@ -56,20 +56,20 @@ impl CallOverrideCallback {
             |ctx: ThreadSafeCallContext<CallOverrideCall>| {
                 let address = ctx
                     .env
-                    .create_buffer_with_data(ctx.value.contract_address.to_vec())?
+                    .create_arraybuffer_with_data(ctx.value.contract_address.to_vec())?
                     .into_raw();
 
                 let data = ctx
                     .env
-                    .create_buffer_with_data(ctx.value.data.to_vec())?
+                    .create_arraybuffer_with_data(ctx.value.data.to_vec())?
                     .into_raw();
 
                 Ok(vec![address, data])
             },
         )?;
 
-        // Maintain a weak reference to the function to avoid the event loop from
-        // exiting.
+        // Maintain a weak reference to the function to avoid blocking the event loop
+        // from exiting.
         call_override_callback_fn.unref(env)?;
 
         Ok(Self {

package/src/cast.rs

@@ -1,6 +1,6 @@
-use edr_eth::{Address, Bytes, B256, B64, U256};
+use edr_eth::{Address, Bytecode, Bytes, B256, B64, U256};
 use napi::{
-    bindgen_prelude::{BigInt, Buffer},
+    bindgen_prelude::{BigInt, Uint8Array},
     Status,
 };
 
@@ -15,48 +15,62 @@ pub trait TryCast<T>: Sized {
     fn try_cast(self) -> Result<T, Self::Error>;
 }
 
-impl TryCast<Address> for Buffer {
+impl TryCast<Address> for Uint8Array {
     type Error = napi::Error;
 
     fn try_cast(self) -> std::result::Result<Address, Self::Error> {
         if self.len() != 20 {
             return Err(napi::Error::new(
                 Status::InvalidArg,
-                "Buffer was expected to be 20 bytes.".to_string(),
+                "Uint8Array was expected to be 20 bytes.".to_string(),
             ));
         }
         Ok(Address::from_slice(&self))
     }
 }
 
-impl TryCast<B64> for Buffer {
+impl TryCast<B64> for Uint8Array {
     type Error = napi::Error;
 
     fn try_cast(self) -> std::result::Result<B64, Self::Error> {
         if self.len() != 8 {
             return Err(napi::Error::new(
                 Status::InvalidArg,
-                "Buffer was expected to be 8 bytes.".to_string(),
+                "Uint8Array was expected to be 8 bytes.".to_string(),
             ));
         }
         Ok(B64::from_slice(&self))
     }
 }
 
-impl TryCast<B256> for Buffer {
+impl TryCast<B256> for Uint8Array {
     type Error = napi::Error;
 
     fn try_cast(self) -> std::result::Result<B256, Self::Error> {
         if self.len() != 32 {
             return Err(napi::Error::new(
                 Status::InvalidArg,
-                "Buffer was expected to be 32 bytes.".to_string(),
+                "Uint8Array was expected to be 32 bytes.".to_string(),
             ));
         }
         Ok(B256::from_slice(&self))
     }
 }
 
+impl TryCast<Bytecode> for Uint8Array {
+    type Error = napi::Error;
+
+    fn try_cast(self) -> std::result::Result<Bytecode, Self::Error> {
+        let bytes = Bytes::copy_from_slice(&self);
+        Bytecode::new_raw_checked(bytes).map_err(|error| {
+            napi::Error::new(
+                Status::InvalidArg,
+                format!("Uint8Array was not valid bytecode: {error}"),
+            )
+        })
+    }
+}
+
 impl TryCast<u64> for BigInt {
     type Error = napi::Error;
 
@@ -81,6 +95,30 @@ impl TryCast<u64> for BigInt {
     }
 }
 
+impl TryCast<u128> for BigInt {
+    type Error = napi::Error;
+
+    fn try_cast(self) -> std::result::Result<u128, Self::Error> {
+        let (signed, value, lossless) = self.get_u128();
+
+        if signed {
+            return Err(napi::Error::new(
+                Status::InvalidArg,
+                "BigInt was expected to be unsigned.".to_string(),
+            ));
+        }
+
+        if !lossless {
+            return Err(napi::Error::new(
+                Status::InvalidArg,
+                "BigInt was expected to fit within 128 bits.".to_string(),
+            ));
+        }
+
+        Ok(value)
+    }
+}
+
 impl TryCast<usize> for BigInt {
     type Error = napi::Error;
 
@@ -118,15 +156,7 @@ impl<T> TryCast<T> for T {
     }
 }
 
-impl TryCast<Bytes> for Buffer {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> Result<Bytes, Self::Error> {
-        Ok(Bytes::copy_from_slice(&self))
-    }
-}
-
-impl TryCast<Option<Bytes>> for Option<Buffer> {
+impl TryCast<Option<Bytes>> for Option<Uint8Array> {
     type Error = napi::Error;
 
     fn try_cast(self) -> Result<Option<Bytes>, Self::Error> {

package/src/chains/generic.rs

@@ -0,0 +1,51 @@
+use std::sync::Arc;
+
+use edr_eth::l1;
+use edr_generic::GenericChainSpec;
+use edr_napi_core::{
+    logger::{self, Logger},
+    provider::{self, ProviderBuilder, SyncProviderFactory},
+    spec::SyncNapiSpec as _,
+    subscription,
+};
+use edr_solidity::contract_decoder::ContractDecoder;
+use napi_derive::napi;
+
+use crate::provider::ProviderFactory;
+
+pub struct GenericChainProviderFactory;
+
+impl SyncProviderFactory for GenericChainProviderFactory {
+    fn create_provider_builder(
+        &self,
+        env: &napi::Env,
+        provider_config: edr_napi_core::provider::Config,
+        logger_config: logger::Config,
+        subscription_config: subscription::Config,
+        contract_decoder: Arc<ContractDecoder>,
+    ) -> napi::Result<Box<dyn provider::Builder>> {
+        let logger = Logger::<GenericChainSpec>::new(logger_config, Arc::clone(&contract_decoder))?;
+
+        let provider_config =
+            edr_provider::ProviderConfig::<l1::SpecId>::try_from(provider_config)?;
+
+        let subscription_callback =
+            subscription::Callback::new(env, subscription_config.subscription_callback)?;
+
+        Ok(Box::new(ProviderBuilder::new(
+            contract_decoder,
+            Box::new(logger),
+            provider_config,
+            subscription_callback,
+        )))
+    }
+}
+
+#[napi]
+pub const GENERIC_CHAIN_TYPE: &str = GenericChainSpec::CHAIN_TYPE;
+
+#[napi(catch_unwind)]
+pub fn generic_chain_provider_factory() -> ProviderFactory {
+    let factory: Arc<dyn SyncProviderFactory> = Arc::new(GenericChainProviderFactory);
+    factory.into()
+}