@nomicfoundation/edr 0.11.3 → 0.12.0-next.0

package/index.d.ts

@@ -3,51 +3,29 @@
 
 /* auto-generated by NAPI-RS */
 
-/** An account that needs to be created during the genesis block. */
-export interface GenesisAccount {
-  /** Account secret key */
-  secretKey: string
-  /** Account balance */
-  balance: bigint
-}
-export interface BlockOptions {
-  /** The parent block's hash */
-  parentHash?: Buffer
-  /** The block's beneficiary */
-  beneficiary?: Buffer
-  /** The state's root hash */
-  stateRoot?: Buffer
-  /** The block's difficulty */
-  difficulty?: bigint
-  /** The block's number */
-  number?: bigint
-  /** The block's gas limit */
-  gasLimit?: bigint
-  /** The block's timestamp */
-  timestamp?: bigint
-  /** The block's extra data */
-  extraData?: Buffer
-  /** The block's mix hash (or prevrandao) */
-  mixHash?: Buffer
-  /** The block's nonce */
-  nonce?: Buffer
-  /** The block's base gas fee */
-  baseFee?: bigint
-  /** The block's withdrawals */
-  withdrawals?: Array<Withdrawal>
-  /** Blob gas was added by EIP-4844 and is ignored in older headers. */
-  blobGas?: BlobGas
-  /**
-   * The hash tree root of the parent beacon block for the given execution
-   * block (EIP-4788).
-   */
-  parentBeaconBlockRoot?: Buffer
-  /**
-   * The commitment hash calculated for a list of [EIP-7685] data requests.
+/** Specification of overrides for an account and its storage. */
+export interface AccountOverride {
+  /** The account's address */
+  address: Uint8Array
+  /** If present, the overwriting balance. */
+  balance?: bigint
+  /** If present, the overwriting nonce. */
+  nonce?: bigint
+  /** If present, the overwriting code. */
+  code?: Uint8Array
+  /**
+   * BEWARE: This field is not supported yet. See <https://github.com/NomicFoundation/edr/issues/911>
    *
-   * [EIP-7685]: https://eips.ethereum.org/EIPS/eip-7685
+   * If present, the overwriting storage.
    */
-  requestsHash?: Buffer
+  storage?: Array<StorageSlot>
+}
+/** A description of a storage slot's state. */
+export interface StorageSlot {
+  /** The storage slot's index */
+  index: bigint
+  /** The storage slot's value */
+  value: bigint
 }
 /** Information about the blob gas used in a block. */
 export interface BlobGas {
@@ -66,9 +44,14 @@ export interface BlobGas {
 }
 /** The result of executing a call override. */
 export interface CallOverrideResult {
-  result: Buffer
+  result: Uint8Array
   shouldRevert: boolean
 }
+export const GENERIC_CHAIN_TYPE: string
+export declare function genericChainProviderFactory(): ProviderFactory
+export const L1_CHAIN_TYPE: string
+export declare function l1GenesisState(hardfork: SpecId): Array<AccountOverride>
+export declare function l1ProviderFactory(): ProviderFactory
 /** Identifier for the Ethereum spec. */
 export enum SpecId {
   /** Frontier */
@@ -108,75 +91,114 @@ export enum SpecId {
   /** Cancun */
   Cancun = 17,
   /** Prague */
-  Prague = 18,
-  /** Latest */
-  Latest = 19
-}
-export interface DebugTraceResult {
-  pass: boolean
-  gasUsed: bigint
-  output?: Buffer
-  structLogs: Array<DebugTraceLogItem>
-}
-export interface DebugTraceLogItem {
-  /** Program Counter */
-  pc: bigint
-  op: number
-  /** Gas left before executing this operation as hex number. */
-  gas: string
-  /** Gas cost of this operation as hex number. */
-  gasCost: string
-  /** Array of all values (hex numbers) on the stack */
-  stack?: Array<string>
-  /** Depth of the call stack */
-  depth: bigint
-  /** Size of memory array */
-  memSize: bigint
-  /** Name of the operation */
-  opName: string
-  /** Description of an error as a hex string. */
-  error?: string
-  /** Array of all allocated values as hex strings. */
-  memory?: Array<string>
-  /** Map of all stored values with keys and values encoded as hex strings. */
-  storage?: Record<string, string>
-}
-/** Ethereum execution log. */
-export interface ExecutionLog {
-  address: Buffer
-  topics: Array<Buffer>
-  data: Buffer
-}
-export interface ContractAndFunctionName {
-  /** The contract name. */
-  contractName: string
-  /** The function name. Only present for calls. */
-  functionName?: string
+  Prague = 18
 }
-export interface LoggerConfig {
-  /** Whether to enable the logger. */
-  enable: boolean
-  decodeConsoleLogInputsCallback: (inputs: Buffer[]) => string[]
-  printLineCallback: (message: string, replace: boolean) => void
+/**
+ * Tries to parse the provided string to create a [`SpecId`] instance.
+ *
+ * Returns an error if the string does not match any known hardfork.
+ */
+export declare function l1HardforkFromString(hardfork: string): SpecId
+export declare function l1HardforkToString(harfork: SpecId): string
+/**
+ * Returns the latest supported OP hardfork.
+ *
+ * The returned value will be updated after each network upgrade.
+ */
+export declare function l1HardforkLatest(): SpecId
+export const FRONTIER: string
+export const FRONTIER_THAWING: string
+export const HOMESTEAD: string
+export const DAO_FORK: string
+export const TANGERINE: string
+export const SPURIOUS_DRAGON: string
+export const BYZANTIUM: string
+export const CONSTANTINOPLE: string
+export const PETERSBURG: string
+export const ISTANBUL: string
+export const MUIR_GLACIER: string
+export const BERLIN: string
+export const LONDON: string
+export const ARROW_GLACIER: string
+export const GRAY_GLACIER: string
+export const MERGE: string
+export const SHANGHAI: string
+export const CANCUN: string
+export const PRAGUE: string
+/** Enumeration of supported OP hardforks. */
+export enum OpHardfork {
+  Bedrock = 100,
+  Regolith = 101,
+  Canyon = 102,
+  Ecotone = 103,
+  Fjord = 104,
+  Granite = 105,
+  Holocene = 106,
+  Isthmus = 107
 }
-/** Configuration for a chain */
-export interface ChainConfig {
+/**
+ * Tries to parse the provided string to create an [`OpHardfork`]
+ * instance.
+ *
+ * Returns an error if the string does not match any known hardfork.
+ */
+export declare function opHardforkFromString(hardfork: string): OpHardfork
+/** Returns the string representation of the provided OP hardfork. */
+export declare function opHardforkToString(hardfork: OpHardfork): string
+/**
+ * Returns the latest supported OP hardfork.
+ *
+ * The returned value will be updated after each network upgrade.
+ */
+export declare function opLatestHardfork(): OpHardfork
+export const OP_CHAIN_TYPE: string
+export declare function opGenesisState(hardfork: OpHardfork): Array<AccountOverride>
+export declare function opProviderFactory(): ProviderFactory
+export const BEDROCK: string
+export const REGOLITH: string
+export const CANYON: string
+export const ECOTONE: string
+export const FJORD: string
+export const GRANITE: string
+export const HOLOCENE: string
+export const ISTHMUS: string
+/** Specification of a chain with possible overrides. */
+export interface ChainOverride {
   /** The chain ID */
   chainId: bigint
-  /** The chain's supported hardforks */
-  hardforks: Array<HardforkActivation>
+  /** The chain's name */
+  name: string
+  /** If present, overrides for the chain's supported hardforks */
+  hardforkActivationOverrides?: Array<HardforkActivation>
+}
+/** Configuration for a code coverage reporter. */
+export interface CodeCoverageConfig {
+  /**
+   * The callback to be called when coverage has been collected.
+   *
+   * The callback receives an array of unique coverage hit markers (i.e. no
+   * repetition) per transaction.
+   *
+   * Exceptions thrown in the callback will be propagated to the original
+   * caller.
+   */
+  onCollectedCoverageCallback: (coverageHits: Uint8Array[]) => Promise<void>
 }
 /** Configuration for forking a blockchain */
 export interface ForkConfig {
-  /** The URL of the JSON-RPC endpoint to fork from */
-  jsonRpcUrl: string
   /**
    * The block number to fork from. If not provided, the latest safe block is
    * used.
    */
   blockNumber?: bigint
+  /** The directory to cache remote JSON-RPC responses */
+  cacheDir?: string
+  /** Overrides for the configuration of chains. */
+  chainOverrides?: Array<ChainOverride>
   /** The HTTP headers to use when making requests to the JSON-RPC endpoint */
   httpHeaders?: Array<HttpHeader>
+  /** The URL of the JSON-RPC endpoint to fork from */
+  url: string
 }
 export interface HttpHeader {
   name: string
@@ -184,10 +206,18 @@ export interface HttpHeader {
 }
 /** Configuration for a hardfork activation */
 export interface HardforkActivation {
+  /** The condition for the hardfork activation */
+  condition: HardforkActivationByBlockNumber | HardforkActivationByTimestamp
+  /** The activated hardfork */
+  hardfork: string
+}
+export interface HardforkActivationByBlockNumber {
   /** The block number at which the hardfork is activated */
   blockNumber: bigint
-  /** The activated hardfork */
-  specId: SpecId
+}
+export interface HardforkActivationByTimestamp {
+  /** The timestamp at which the hardfork is activated */
+  timestamp: bigint
 }
 /**The type of ordering to use when selecting blocks to mine. */
 export enum MineOrdering {
@@ -210,6 +240,11 @@ export interface MiningConfig {
   interval?: bigint | IntervalRange
   memPool: MemPoolConfig
 }
+/** Configuration for runtime observability. */
+export interface ObservabilityConfig {
+  /** If present, configures runtime observability to collect code coverage. */
+  codeCoverage?: CodeCoverageConfig
+}
 /** Configuration for a provider */
 export interface ProviderConfig {
   /** Whether to allow blocks with the same timestamp */
@@ -222,25 +257,19 @@ export interface ProviderConfig {
   bailOnTransactionFailure: boolean
   /** The gas limit of each block */
   blockGasLimit: bigint
-  /** The directory to cache remote JSON-RPC responses */
-  cacheDir?: string
   /** The chain ID of the blockchain */
   chainId: bigint
-  /** The configuration for chains */
-  chains: Array<ChainConfig>
   /** The address of the coinbase */
-  coinbase: Buffer
-  /** Enables RIP-7212 */
-  enableRip7212: boolean
+  coinbase: Uint8Array
   /**
    * The configuration for forking a blockchain. If not provided, a local
    * blockchain will be created
    */
   fork?: ForkConfig
-  /** The genesis accounts of the blockchain */
-  genesisAccounts: Array<GenesisAccount>
+  /** The genesis state of the blockchain */
+  genesisState: Array<AccountOverride>
   /** The hardfork of the blockchain */
-  hardfork: SpecId
+  hardfork: string
   /**
    * The initial base fee per gas of the blockchain. Required for EIP-1559
    * transactions and later
@@ -254,13 +283,19 @@ export interface ProviderConfig {
    * The initial parent beacon block root of the blockchain. Required for
    * EIP-4788
    */
-  initialParentBeaconBlockRoot?: Buffer
+  initialParentBeaconBlockRoot?: Uint8Array
   /** The minimum gas price of the next block. */
   minGasPrice: bigint
   /** The configuration for the miner */
   mining: MiningConfig
   /** The network ID of the blockchain */
   networkId: bigint
+  /** The configuration for the provider's observability */
+  observability: ObservabilityConfig
+  /** Secret keys of owned accounts */
+  ownedAccounts: Array<string>
+  /** Overrides for precompiles */
+  precompileOverrides: Array<Precompile>
 }
 /** Tracing config for Solidity stack trace generation. */
 export interface TracingConfigWithBuffers {
@@ -283,6 +318,86 @@ export interface BuildInfoAndOutput {
   /** The build info output file */
   output: Uint8Array
 }
+export interface DebugTraceResult {
+  pass: boolean
+  gasUsed: bigint
+  output?: Uint8Array
+  structLogs: Array<DebugTraceLogItem>
+}
+export interface DebugTraceLogItem {
+  /** Program Counter */
+  pc: bigint
+  op: number
+  /** Gas left before executing this operation as hex number. */
+  gas: string
+  /** Gas cost of this operation as hex number. */
+  gasCost: string
+  /** Array of all values (hex numbers) on the stack */
+  stack?: Array<string>
+  /** Depth of the call stack */
+  depth: bigint
+  /** Size of memory array */
+  memSize: bigint
+  /** Name of the operation */
+  opName: string
+  /** Description of an error as a hex string. */
+  error?: string
+  /** Array of all allocated values as hex strings. */
+  memory?: Array<string>
+  /** Map of all stored values with keys and values encoded as hex strings. */
+  storage?: Record<string, string>
+}
+export interface InstrumentationResult {
+  /** The generated source code with coverage instrumentation. */
+  readonly source: string
+  /** The metadata for each instrumented code segment. */
+  readonly metadata: Array<InstrumentationMetadata>
+}
+export interface InstrumentationMetadata {
+  /**
+   * The tag that identifies the instrumented code. Tags are
+   * deterministically generated from the source code, source id, and
+   * Solidity version.
+   */
+  readonly tag: Uint8Array
+  /**
+   * The kind of instrumented code. Currently, the only supported kind
+   * is "statement".
+   */
+  readonly kind: string
+  /**
+   * The starting position of the instrumented code - including trivia such
+   * as whitespace - in the source code, in UTF-16 code units.
+   */
+  readonly startUtf16: number
+  /**
+   * The ending position of the instrumented code - including trivia such as
+   * whitespace - in the source code, in UTF-16 code units.
+   */
+  readonly endUtf16: number
+}
+/**
+ * Adds per-statement coverage instrumentation to the given Solidity source
+ * code.
+ */
+export declare function addStatementCoverageInstrumentation(sourceCode: string, sourceId: string, solidityVersion: string, coverageLibraryPath: string): InstrumentationResult
+/** Ethereum execution log. */
+export interface ExecutionLog {
+  address: Uint8Array
+  topics: Array<Uint8Array>
+  data: Uint8Array
+}
+export interface LoggerConfig {
+  /** Whether to enable the logger. */
+  enable: boolean
+  decodeConsoleLogInputsCallback: (inputs: ArrayBuffer[]) => string[]
+  printLineCallback: (message: string, replace: boolean) => void
+}
+/**
+ * [RIP-7212](https://github.com/ethereum/RIPs/blob/master/RIPS/rip-7212.md#specification)
+ * secp256r1 precompile.
+ */
+export declare function precompileP256Verify(): Precompile
 /** The possible reasons for successful termination of the EVM. */
 export enum SuccessReason {
   /** The opcode `STOP` was called */
@@ -295,13 +410,13 @@ export enum SuccessReason {
 }
 export interface CallOutput {
   /** Return value */
-  returnValue: Buffer
+  returnValue: Uint8Array
 }
 export interface CreateOutput {
   /** Return value */
-  returnValue: Buffer
+  returnValue: Uint8Array
   /** Optionally, a 160-bit address */
-  address?: Buffer
+  address?: Uint8Array
 }
 /** The result when the EVM terminates successfully. */
 export interface SuccessResult {
@@ -321,7 +436,7 @@ export interface RevertResult {
   /** The amount of gas used */
   gasUsed: bigint
   /** The transaction output */
-  output: Buffer
+  output: Uint8Array
 }
 /**
  * Indicates that the EVM has experienced an exceptional halt. This causes
@@ -350,7 +465,7 @@ export enum ExceptionalHalt {
   /** Aud data is smaller then already present data size. */
   EofAuxDataTooSmall = 15,
   /** EOF Subroutine stack overflow */
-  EOFFunctionStackOverflow = 16,
+  SubRoutineStackOverflow = 16,
   /** Check for target address validity is only done inside subcall. */
   InvalidEXTCALLTarget = 17
 }
@@ -369,7 +484,563 @@ export interface ExecutionResult {
   /** The transaction result */
   result: SuccessResult | RevertResult | HaltResult
   /** Optional contract address if the transaction created a new contract. */
-  contractAddress?: Buffer
+  contractAddress?: Uint8Array
+}
+/** A compilation artifact. */
+export interface Artifact {
+  /** The identifier of the artifact. */
+  id: ArtifactId
+  /** The test contract. */
+  contract: ContractData
+}
+/** The identifier of a Solidity contract. */
+export interface ArtifactId {
+  /** The name of the contract. */
+  name: string
+  /** Original source file path. */
+  source: string
+  /** The solc semver string. */
+  solcVersion: string
+}
+/** A test contract to execute. */
+export interface ContractData {
+  /** Contract ABI as json string. */
+  abi: string
+  /**
+   * Contract creation code as hex string. It can be missing if the contract
+   * is ABI only.
+   */
+  bytecode?: string
+  /** The link references of the deployment bytecode. */
+  linkReferences?: Record<string, Record<string, Array<LinkReference>>>
+  /**
+   * Contract runtime code as hex string. It can be missing if the contract
+   * is ABI only.
+   */
+  deployedBytecode?: string
+  /** The link references of the deployed bytecode. */
+  deployedLinkReferences?: Record<string, Record<string, Array<LinkReference>>>
+}
+export interface LinkReference {
+  start: number
+  length: number
+}
+/**
+ * Solidity test runner configuration arguments exposed through the ffi.
+ * Docs based on <https://book.getfoundry.sh/reference/config/testing>.
+ */
+export interface SolidityTestRunnerConfigArgs {
+  /**
+   * The absolute path to the project root directory.
+   * Relative paths in cheat codes are resolved against this path.
+   */
+  projectRoot: string
+  /** Configures the permissions of cheat codes that access the file system. */
+  fsPermissions?: Array<PathPermission>
+  /** Whether to support the `testFail` prefix. Defaults to false. */
+  testFail?: boolean
+  /** Address labels for traces. Defaults to none. */
+  labels?: Array<AddressLabel>
+  /**
+   * Whether to enable isolation of calls. In isolation mode all top-level
+   * calls are executed as a separate transaction in a separate EVM
+   * context, enabling more precise gas accounting and transaction state
+   * changes.
+   * Defaults to false.
+   */
+  isolate?: boolean
+  /**
+   * Whether or not to enable the ffi cheatcode.
+   * Warning: Enabling this cheatcode has security implications, as it allows
+   * tests to execute arbitrary programs on your computer.
+   * Defaults to false.
+   */
+  ffi?: boolean
+  /**
+   * Allow expecting reverts with `expectRevert` at the same callstack depth
+   * as the test. Defaults to false.
+   */
+  allowInternalExpectRevert?: boolean
+  /**
+   * The value of `msg.sender` in tests as hex string.
+   * Defaults to `0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38`.
+   */
+  sender?: Uint8Array
+  /**
+   * The value of `tx.origin` in tests as hex string.
+   * Defaults to `0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38`.
+   */
+  txOrigin?: Uint8Array
+  /**
+   * The initial balance of the sender in tests.
+   * Defaults to `0xffffffffffffffffffffffff`.
+   */
+  initialBalance?: bigint
+  /**
+   * The value of `block.number` in tests.
+   * Defaults to `1`.
+   */
+  blockNumber?: bigint
+  /**
+   * The value of the `chainid` opcode in tests.
+   * Defaults to `31337`.
+   */
+  chainId?: bigint
+  /**
+   * The gas limit for each test case.
+   * Defaults to `9_223_372_036_854_775_807` (`i64::MAX`).
+   */
+  gasLimit?: bigint
+  /**
+   * The price of gas (in wei) in tests.
+   * Defaults to `0`.
+   */
+  gasPrice?: bigint
+  /**
+   * The base fee per gas (in wei) in tests.
+   * Defaults to `0`.
+   */
+  blockBaseFeePerGas?: bigint
+  /**
+   * The value of `block.coinbase` in tests.
+   * Defaults to `0x0000000000000000000000000000000000000000`.
+   */
+  blockCoinbase?: Uint8Array
+  /**
+   * The value of `block.timestamp` in tests.
+   * Defaults to 1.
+   */
+  blockTimestamp?: bigint
+  /**
+   * The value of `block.difficulty` in tests.
+   * Defaults to 0.
+   */
+  blockDifficulty?: bigint
+  /**
+   * The `block.gaslimit` value during EVM execution.
+   * Defaults to none.
+   */
+  blockGasLimit?: bigint
+  /**
+   * Whether to disable the block gas limit.
+   * Defaults to false.
+   */
+  disableBlockGasLimit?: boolean
+  /**
+   * The memory limit of the EVM in bytes.
+   * Defaults to 33_554_432 (2^25 = 32MiB).
+   */
+  memoryLimit?: bigint
+  /**
+   * The predeploys applied in local mode. Defaults to no predeploys.
+   * These should match the predeploys of the network in fork mode, so they
+   * aren't set in fork mode.
+   * The code must be set and non-empty. The nonce and the balance default to
+   * zero and storage defaults to empty.
+   */
+  localPredeploys?: Array<AccountOverride>
+  /**
+   * If set, all tests are run in fork mode using this url or remote name.
+   * Defaults to none.
+   */
+  ethRpcUrl?: string
+  /** Pins the block number for the global state fork. */
+  forkBlockNumber?: bigint
+  /**
+   * Map of RPC endpoints from chain name to RPC urls for fork cheat codes,
+   * e.g. `{ "optimism": "https://optimism.alchemyapi.io/v2/..." }`
+   */
+  rpcEndpoints?: Record<string, string>
+  /**
+   * Optional RPC cache path. If this is none, then no RPC calls will be
+   * cached, otherwise data is cached to `<rpc_cache_path>/<chain
+   * id>/<block number>`. Caching can be disabled for specific chains
+   * with `rpc_storage_caching`.
+   */
+  rpcCachePath?: string
+  /** What RPC endpoints are cached. Defaults to all. */
+  rpcStorageCaching?: StorageCachingConfig
+  /**
+   * The number of seconds to wait before `vm.prompt` reverts with a timeout.
+   * Defaults to 120.
+   */
+  promptTimeout?: number
+  /** Fuzz testing configuration. */
+  fuzz?: FuzzConfigArgs
+  /**
+   * Invariant testing configuration.
+   * If an invariant config setting is not set, but a corresponding fuzz
+   * config value is set, then the fuzz config value will be used.
+   */
+  invariant?: InvariantConfigArgs
+  /**
+   * Controls which test results should include execution traces. Defaults to
+   * None.
+   */
+  includeTraces?: IncludeTraces
+  /** The configuration for the Solidity test runner's observability */
+  observability?: ObservabilityConfig
+  /**
+   * A regex pattern to filter tests. If provided, only test methods that
+   * match the pattern will be executed and reported as a test result.
+   */
+  testPattern?: string
+}
+/** Fuzz testing configuration */
+export interface FuzzConfigArgs {
+  /** Path where fuzz failures are recorded and replayed if set. */
+  failurePersistDir?: string
+  /** Name of the file to record fuzz failures, defaults to `failures`. */
+  failurePersistFile?: string
+  /**
+   * The amount of fuzz runs to perform for each fuzz test case. Higher
+   * values gives more confidence in results at the cost of testing
+   * speed.
+   * Defaults to 256.
+   */
+  runs?: number
+  /**
+   * The maximum number of combined inputs that may be rejected before the
+   * test as a whole aborts. “Global” filters apply to the whole test
+   * case. If the test case is rejected, the whole thing is regenerated.
+   * Defaults to 65536.
+   */
+  maxTestRejects?: number
+  /**
+   * Hexadecimal string.
+   * Optional seed for the fuzzing RNG algorithm.
+   * Defaults to None.
+   */
+  seed?: string
+  /**
+   * Integer between 0 and 100.
+   * The weight of the dictionary. A higher dictionary weight will bias the
+   * fuzz inputs towards “interesting” values, e.g. boundary values like
+   * type(uint256).max or contract addresses from your environment.
+   * Defaults to 40.
+   */
+  dictionaryWeight?: number
+  /**
+   * The flag indicating whether to include values from storage.
+   * Defaults to true.
+   */
+  includeStorage?: boolean
+  /**
+   * The flag indicating whether to include push bytes values.
+   * Defaults to true.
+   */
+  includePushBytes?: boolean
+}
+/** Invariant testing configuration. */
+export interface InvariantConfigArgs {
+  /** Path where invariant failures are recorded and replayed if set. */
+  failurePersistDir?: string
+  /**
+   * The number of runs that must execute for each invariant test group.
+   * Defaults to 256.
+   */
+  runs?: number
+  /**
+   * The number of calls executed to attempt to break invariants in one run.
+   * Defaults to 500.
+   */
+  depth?: number
+  /**
+   * Fails the invariant fuzzing if a revert occurs.
+   * Defaults to false.
+   */
+  failOnRevert?: boolean
+  /**
+   * Overrides unsafe external calls when running invariant tests, useful for
+   * e.g. performing reentrancy checks.
+   * Defaults to false.
+   */
+  callOverride?: boolean
+  /**
+   * Integer between 0 and 100.
+   * The weight of the dictionary. A higher dictionary weight will bias the
+   * fuzz inputs towards “interesting” values, e.g. boundary values like
+   * type(uint256).max or contract addresses from your environment.
+   * Defaults to 40.
+   */
+  dictionaryWeight?: number
+  /**
+   * The flag indicating whether to include values from storage.
+   * Defaults to true.
+   */
+  includeStorage?: boolean
+  /**
+   * The flag indicating whether to include push bytes values.
+   * Defaults to true.
+   */
+  includePushBytes?: boolean
+  /**
+   * The maximum number of attempts to shrink a failed the sequence. Shrink
+   * process is disabled if set to 0.
+   * Defaults to 5000.
+   */
+  shrinkRunLimit?: number
+}
+/** Settings to configure caching of remote RPC endpoints. */
+export interface StorageCachingConfig {
+  /**
+   * Chains to cache. Either all or none or a list of chain names, e.g.
+   * ["optimism", "mainnet"].
+   */
+  chains: CachedChains | Array<string>
+  /** Endpoints to cache. Either all or remote or a regex. */
+  endpoints: CachedEndpoints | string
+}
+/** What chains to cache */
+export enum CachedChains {
+  /** Cache all chains */
+  All = 0,
+  /** Don't cache anything */
+  None = 1
+}
+/** What endpoints to enable caching for */
+export enum CachedEndpoints {
+  /** Cache all endpoints */
+  All = 0,
+  /** Only cache non-local host endpoints */
+  Remote = 1
+}
+/** Represents an access permission to a single path */
+export interface PathPermission {
+  /** Permission level to access the `path` */
+  access: FsAccessPermission
+  /** The targeted path guarded by the permission */
+  path: string
+}
+/** Determines the status of file system access */
+export enum FsAccessPermission {
+  /** FS access is allowed with `read` + `write` permission */
+  ReadWrite = 0,
+  /** Only reading is allowed */
+  Read = 1,
+  /** Only writing is allowed */
+  Write = 2
+}
+export interface AddressLabel {
+  /** The address to label */
+  address: Uint8Array
+  /** The label to assign to the address */
+  label: string
+}
+/**
+ * Configuration for [`SolidityTestRunnerConfigArgs::include_traces`] that
+ * controls execution trace decoding and inclusion in test results.
+ */
+export enum IncludeTraces {
+  /** No traces will be included in any test result. */
+  None = 0,
+  /** Traces will be included only on the results of failed tests. */
+  Failing = 1,
+  /** Traces will be included in all test results. */
+  All = 2
+}
+export declare function l1SolidityTestRunnerFactory(): SolidityTestRunnerFactory
+export declare function opSolidityTestRunnerFactory(): SolidityTestRunnerFactory
+/** The stack trace result */
+export interface StackTrace {
+  /** Enum tag for JS. */
+  kind: "StackTrace"
+  /** The stack trace entries */
+  entries: Array<SolidityStackTraceEntry>
+}
+/** We couldn't generate stack traces, because an unexpected error occurred. */
+export interface UnexpectedError {
+  /** Enum tag for JS. */
+  kind: "UnexpectedError"
+  /** The error message from the unexpected error. */
+  errorMessage: string
+}
+/**
+ * We couldn't generate stack traces, because the stack trace generation
+ * heuristics failed due to an unknown reason.
+ */
+export interface HeuristicFailed {
+  /** Enum tag for JS. */
+  kind: "HeuristicFailed"
+}
+/**
+ * We couldn't generate stack traces, because the test execution is unsafe to
+ * replay due to indeterminism. This can be caused by either specifying a fork
+ * url without a fork block number in the test runner config or using impure
+ * cheatcodes.
+ */
+export interface UnsafeToReplay {
+  /** Enum tag for JS. */
+  kind: "UnsafeToReplay"
+  /**
+   * Indeterminism due to specifying a fork url without a fork block number
+   * in the test runner config.
+   */
+  globalForkLatest: boolean
+  /**
+   * The list of executed impure cheatcode signatures. We collect function
+   * signatures instead of function names as whether a cheatcode is impure
+   * can depend on the arguments it takes (e.g. `createFork` without a second
+   * argument means implicitly fork from “latest”). Example signature:
+   * `function createSelectFork(string calldata urlOrAlias) external returns
+   * (uint256 forkId);`.
+   */
+  impureCheatcodes: Array<string>
+}
+/**The result of a test execution. */
+export enum TestStatus {
+  /**Test success */
+  Success = 'Success',
+  /**Test failure */
+  Failure = 'Failure',
+  /**Test skipped */
+  Skipped = 'Skipped'
+}
+/** See [edr_solidity_tests::result::TestKind::Standard] */
+export interface StandardTestKind {
+  /** The gas consumed by the test. */
+  readonly consumedGas: bigint
+}
+/** See [edr_solidity_tests::result::TestKind::Fuzz] */
+export interface FuzzTestKind {
+  /** See [edr_solidity_tests::result::TestKind::Fuzz] */
+  readonly runs: bigint
+  /** See [edr_solidity_tests::result::TestKind::Fuzz] */
+  readonly meanGas: bigint
+  /** See [edr_solidity_tests::result::TestKind::Fuzz] */
+  readonly medianGas: bigint
+}
+/** See [edr_solidity_tests::fuzz::FuzzCase] */
+export interface FuzzCase {
+  /** The calldata used for this fuzz test */
+  readonly calldata: Uint8Array
+  /** Consumed gas */
+  readonly gas: bigint
+  /** The initial gas stipend for the transaction */
+  readonly stipend: bigint
+}
+/** See [edr_solidity_tests::result::TestKind::Invariant] */
+export interface InvariantTestKind {
+  /** See [edr_solidity_tests::result::TestKind::Invariant] */
+  readonly runs: bigint
+  /** See [edr_solidity_tests::result::TestKind::Invariant] */
+  readonly calls: bigint
+  /** See [edr_solidity_tests::result::TestKind::Invariant] */
+  readonly reverts: bigint
+}
+/**
+ * Original sequence size and sequence of calls used as a counter example
+ * for invariant tests.
+ */
+export interface CounterExampleSequence {
+  /** The original sequence size before shrinking. */
+  originalSequenceSize: bigint
+  /** The shrunk counterexample sequence. */
+  sequence: Array<BaseCounterExample>
+}
+/** See [edr_solidity_tests::fuzz::BaseCounterExample] */
+export interface BaseCounterExample {
+  /** See [edr_solidity_tests::fuzz::BaseCounterExample::sender] */
+  readonly sender?: Uint8Array
+  /** See [edr_solidity_tests::fuzz::BaseCounterExample::addr] */
+  readonly address?: Uint8Array
+  /** See [edr_solidity_tests::fuzz::BaseCounterExample::calldata] */
+  readonly calldata: Uint8Array
+  /** See [edr_solidity_tests::fuzz::BaseCounterExample::contract_name] */
+  readonly contractName?: string
+  /** See [edr_solidity_tests::fuzz::BaseCounterExample::signature] */
+  readonly signature?: string
+  /** See [edr_solidity_tests::fuzz::BaseCounterExample::args] */
+  readonly args?: string
+}
+/**
+ * Object representing a call in an execution trace, including contract
+ * creation.
+ */
+export interface CallTrace {
+  /** The kind of call or contract creation this represents. */
+  kind: CallKind
+  /** Whether the call succeeded or reverted. */
+  success: boolean
+  /** Whether the call is a cheatcode. */
+  isCheatcode: boolean
+  /** The amount of gas that was consumed. */
+  gasUsed: bigint
+  /** The amount of native token that was included with the call. */
+  value: bigint
+  /**
+   * The target of the call. Provided as a contract name if known, otherwise
+   * a checksum address.
+   */
+  contract: string
+  /**
+   * The input (calldata) to the call. If it encodes a known function call,
+   * it will be decoded into the function name and a list of arguments.
+   * For example, `{ name: "ownerOf", arguments: ["1"] }`. Note that the
+   * function name may also be any of the special `fallback` and `receive`
+   * functions. Otherwise, it will be provided as a raw byte array.
+   */
+  inputs: DecodedTraceParameters | Uint8Array
+  /**
+   * The output of the call. This will be a decoded human-readable
+   * representation of the value if the function is known, otherwise a
+   * raw byte array.
+   */
+  outputs: string | Uint8Array
+  /**
+   * Interleaved subcalls and event logs. Use `kind` to check if each member
+   * of the array is a call or log trace.
+   */
+  children: Array<CallTrace | LogTrace>
+}
+/** Object representing an event log in an execution trace. */
+export interface LogTrace {
+  /** A constant to help discriminate the union `CallTrace | LogTrace`. */
+  kind: LogKind
+  /**
+   * If the log is a known event (based on its first topic), it will be
+   * decoded into the event name and list of named parameters. For
+   * example, `{ name: "Log", arguments: ["value: 1"] }`. Otherwise, it
+   * will be provided as an array where all but the last element are the
+   * log topics, and the last element is the log data.
+   */
+  parameters: DecodedTraceParameters | Array<Uint8Array>
+}
+/** The various kinds of call frames possible in the EVM. */
+export enum CallKind {
+  /** Regular call that may change state. */
+  Call = 0,
+  /**
+   * Variant of `DelegateCall` that doesn't preserve sender or value in the
+   * frame.
+   */
+  CallCode = 1,
+  /** Call that executes the code of the target in the context of the caller. */
+  DelegateCall = 2,
+  /** Regular call that may not change state. */
+  StaticCall = 3,
+  /** Contract creation. */
+  Create = 4
+}
+/** Kind marker for log traces. */
+export enum LogKind {
+  /** Single kind of log. */
+  Log = 5
+}
+/** Decoded function call or event. */
+export interface DecodedTraceParameters {
+  /** The name of a function or an event. */
+  name: string
+  /**
+   * The arguments of the function call or the event, in their human-readable
+   * representations.
+   */
+  arguments: Array<string>
+}
+/** Configuration for subscriptions. */
+export interface SubscriptionConfig {
+  /** Callback to be called when a new event is received. */
+  subscriptionCallback: (event: SubscriptionEvent) => void
 }
 export interface SubscriptionEvent {
   filterId: bigint
@@ -563,9 +1234,9 @@ export interface ContractCallRunOutOfGasError {
 }
 export interface TracingMessage {
   /** Sender address */
-  readonly caller: Buffer
+  readonly caller: Uint8Array
   /** Recipient address. None if it is a Create message. */
-  readonly to?: Buffer
+  readonly to?: Uint8Array
   /** Whether it's a static call */
   readonly isStaticCall: boolean
   /** Transaction gas limit */
@@ -573,16 +1244,16 @@ export interface TracingMessage {
   /** Depth of the message */
   readonly depth: number
   /** Input data of the message */
-  readonly data: Buffer
+  readonly data: Uint8Array
   /** Value sent in the message */
   readonly value: bigint
   /**
    * Address of the code that is being executed. Can be different from `to`
    * if a delegate call is being done.
    */
-  readonly codeAddress?: Buffer
+  readonly codeAddress?: Uint8Array
   /** Code of the contract that is being executed. */
-  readonly code?: Buffer
+  readonly code?: Uint8Array
 }
 export interface TracingStep {
   /** Call depth */
@@ -598,7 +1269,7 @@ export interface TracingStep {
    */
   readonly stack: Array<bigint>
   /** The memory at the step. None if verbose tracing is disabled. */
-  readonly memory?: Buffer
+  readonly memory?: Uint8Array
 }
 export interface TracingMessageResult {
   /** Execution result */
@@ -615,35 +1286,102 @@ export interface Withdrawal {
   /** The index of the validator that generated the withdrawal */
   validatorIndex: bigint
   /** The recipient address for withdrawal value */
-  address: Buffer
+  address: Uint8Array
   /** The value contained in withdrawal */
   amount: bigint
 }
 export declare class EdrContext {
   /**Creates a new [`EdrContext`] instance. Should only be called once! */
   constructor()
+  /**Constructs a new provider with the provided configuration. */
+  createProvider(chainType: string, providerConfig: ProviderConfig, loggerConfig: LoggerConfig, subscriptionConfig: SubscriptionConfig, tracingConfig: TracingConfigWithBuffers): Promise<Provider>
+  /**Registers a new provider factory for the provided chain type. */
+  registerProviderFactory(chainType: string, factory: ProviderFactory): Promise<void>
+  registerSolidityTestRunnerFactory(chainType: string, factory: SolidityTestRunnerFactory): Promise<void>
+  /**
+   *Executes Solidity tests.
+   *
+   *The function will return as soon as test execution is started.
+   *The progress callback will be called with the results of each test
+   *suite. It is up to the caller to track how many times the callback
+   *is called to know when all tests are done.
+   */
+  runSolidityTests(chainType: string, artifacts: Array<Artifact>, testSuites: Array<ArtifactId>, configArgs: SolidityTestRunnerConfigArgs, tracingConfig: TracingConfigWithBuffers, onTestSuiteCompletedCallback: (result: SuiteResult) => void): Promise<void>
+}
+export declare class Precompile {
+  /** Returns the address of the precompile. */
+  get address(): Uint8Array
+}
+export declare class ProviderFactory { }
+export declare class Response {
+  /**Returns the response data as a JSON string or a JSON object. */
+  get data(): string | any
+  /**Compute the error stack trace. Return the stack trace if it can be decoded, otherwise returns none. Throws if there was an error computing the stack trace. */
+  stackTrace(): SolidityStackTrace | null
+  /**Returns the raw traces of executed contracts. This maybe contain zero or more traces. */
+  get traces(): Array<RawTrace>
 }
 /** A JSON-RPC provider for Ethereum. */
 export declare class Provider {
-  /**Constructs a new provider with the provided configuration. */
-  static withConfig(context: EdrContext, config: ProviderConfig, loggerConfig: LoggerConfig, tracingConfig: TracingConfigWithBuffers, subscriberCallback: (event: SubscriptionEvent) => void): Promise<Provider>
   /**Handles a JSON-RPC request and returns a JSON-RPC response. */
-  handleRequest(jsonRequest: string): Promise<Response>
-  setCallOverrideCallback(callOverrideCallback: (contract_address: Buffer, data: Buffer) => Promise<CallOverrideResult | undefined>): void
+  handleRequest(request: string): Promise<Response>
+  setCallOverrideCallback(callOverrideCallback: (contract_address: ArrayBuffer, data: ArrayBuffer) => Promise<CallOverrideResult | undefined>): Promise<void>
   /**
    * Set to `true` to make the traces returned with `eth_call`,
    * `eth_estimateGas`, `eth_sendRawTransaction`, `eth_sendTransaction`,
    * `evm_mine`, `hardhat_mine` include the full stack and memory. Set to
    * `false` to disable this.
    */
-  setVerboseTracing(verboseTracing: boolean): void
+  setVerboseTracing(verboseTracing: boolean): Promise<void>
 }
-export declare class Response {
-  /** Returns the response data as a JSON string or a JSON object. */
-  get data(): string | any
-  get traces(): Array<RawTrace>
-  /**Compute the error stack trace. Return the stack trace if it can be decoded, otherwise returns none. Throws if there was an error computing the stack trace. */
-  stackTrace(): SolidityStackTrace | null
+export declare class SolidityTestRunnerFactory { }
+/** See [edr_solidity_tests::result::SuiteResult] */
+export declare class SuiteResult {
+  /**
+   * The artifact id can be used to match input to result in the progress
+   * callback
+   */
+  readonly id: ArtifactId
+  /** See [edr_solidity_tests::result::SuiteResult::duration] */
+  readonly durationNs: bigint
+  /** See [edr_solidity_tests::result::SuiteResult::test_results] */
+  readonly testResults: Array<TestResult>
+  /** See [edr_solidity_tests::result::SuiteResult::warnings] */
+  readonly warnings: Array<string>
+}
+/** See [edr_solidity_tests::result::TestResult] */
+export declare class TestResult {
+  /** The name of the test. */
+  readonly name: string
+  /** See [edr_solidity_tests::result::TestResult::status] */
+  readonly status: TestStatus
+  /** See [edr_solidity_tests::result::TestResult::reason] */
+  readonly reason?: string
+  /** See [edr_solidity_tests::result::TestResult::counterexample] */
+  readonly counterexample?: BaseCounterExample | CounterExampleSequence
+  /** See [edr_solidity_tests::result::TestResult::decoded_logs] */
+  readonly decodedLogs: Array<string>
+  /** See [edr_solidity_tests::result::TestResult::kind] */
+  readonly kind: StandardTestKind | FuzzTestKind | InvariantTestKind
+  /** See [edr_solidity_tests::result::TestResult::duration] */
+  readonly durationNs: bigint
+  /**
+   * Compute the error stack trace.
+   * The result is either the stack trace or the reason why we couldn't
+   * generate the stack trace.
+   * Returns null if the test status is succeeded or skipped.
+   * Cannot throw.
+   */
+  stackTrace(): StackTrace | UnexpectedError | HeuristicFailed | UnsafeToReplay | null
+  /**
+   * Constructs the execution traces for the test. Returns an empty array if
+   * traces for this test were not requested according to
+   * [`crate::solidity_tests::config::SolidityTestRunnerConfigArgs::include_traces`]. Otherwise, returns
+   * an array of the root calls of the trace, which always includes the test
+   * call itself and may also include the setup call if there is one
+   * (identified by the function name `setUp`).
+   */
+  callTraces(): Array<CallTrace>
 }
 export declare class Exit {
   get kind(): ExitCode
@@ -665,5 +1403,5 @@ export declare class ReturnData {
   decodePanic(): bigint
 }
 export declare class RawTrace {
-  trace(): Array<TracingMessage | TracingStep | TracingMessageResult>
+  get trace(): Array<TracingMessage | TracingStep | TracingMessageResult>
 }