foundry-rs/foundry

This system is a comprehensive Rust-based toolkit for Ethereum smart contract development, testing, and deployment, centered around the Forge, Cast, Anvil, and Chisel utilities. It provides a local blockchain node (Anvil) with extensive RPC and network support, a CLI interface (Cast) for transaction and account management, and a REPL for interactive EVM execution (Chisel). The platform also includes a robust testing framework with fuzzing, symbolic execution, and coverage analysis, alongside a rewritten Solidity formatter and linter for code quality enforcement.

98 changes.

This period focused on restructuring the codebase into modular crates and migrating core components to the Solar compiler and Alloy types. Significant efforts were made to refactor Anvil, the CLI tools, and the Solidity formatter, while expanding support for multiple EVM networks and enhancing testing infrastructure.

94 changes.

This period focused on unifying Foundry's support for multiple EVM networks, including Base, Optimism, Celo, and Tempo, by introducing dedicated primitives, hardfork enums, and network-specific EVM implementations. Concurrently, the project established a comprehensive Solidity linting framework with extensive security and gas-optimization rules, while significantly enhancing developer tooling through a new VS Code LSP integration and a robust symbolic execution engine.

The trace decoder now includes specific ABI definitions and decoding logic for Base and Monad network precompiles. For Base, it mirrors the \IActivationRegistry\, \IB20Factory\, \IB20Extensions\, and \IPolicyRegistry\ interfaces to correctly name and decode calls to these network-specific precompiles. For Monad, it adds decoding for staking-related precompiles (\IMonadStaking\, \IReserveBalance\) and internal staking syscalls, ensuring that traces on these networks are human-readable rather than showing raw hex data.

crates/evm/traces/src/decoder · high confidence

Anvil now includes dedicated error conversion logic for Base and Optimism L2 chains, allowing it to correctly interpret and report EVM errors specific to these networks. This change introduces new error variants such as \DepositTransactionUnsupported\, \BaseTransactionUnsupported\, and \Eip8130TransactionRejected\, ensuring that users receive accurate feedback when interacting with Base or Optimism forks, particularly regarding deposit transactions and network-specific transaction types.

crates/anvil/src/eth/error · high confidence

Anvil now exposes the \/eth/v1/beacon/blobs/{block\_id}\, \/eth/v1/beacon/blob\_sidecars/{block\_id}\, and \/eth/v1/beacon/genesis\ endpoints. The blobs endpoint accepts \versioned\_hashes\ as query parameters and returns data in either JSON or SSZ format based on the \Accept\ header, while the blob\_sidecars endpoint is marked as deprecated with a hint to use the new blobs endpoint. Genesis information is returned with zeroed validator roots and fork versions. Invalid block IDs and malformed versioned hashes are rejected with appropriate error codes.

crates/anvil/src/server/beacon · high confidence

Users can now execute native token transfers via the Celo transfer precompile (address 0xfd) when interacting with the Celo network. This new capability allows EVM contracts to transfer native tokens using the ERC20 token duality system by calling the precompile with a 96-byte input specifying the sender, recipient, and value. The implementation handles balance validation, overflow checks, and direct balance modifications, ensuring that transfers are processed correctly within the Celo-specific execution environment.

crates/evm/networks/src/celo · high confidence

The \forge test\ command now supports visualizing EVM execution traces in speedscope. When the \--evm-profile\ flag is used, the test runner generates a profile JSON file and starts a local HTTP server to serve it. The tool automatically opens the speedscope.app viewer in your browser, allowing you to interactively analyze the gas usage and execution flow of your tests.

crates/forge/src/cmd/test · high confidence

New files in \crates/evm/traces/src/speedscope\ introduce the ability to convert EVM execution traces into the speedscope profile format. The \builder\ module walks the call trace arena to generate an evented profile where flame graph widths represent gas usage, while the \schema\ module defines the necessary JSON structures (frames, profiles, events) to serialize these traces for import into the speedscope visualization tool.

crates/evm/traces/src/speedscope · high confidence

Anvil now implements the Otterscan API endpoints (ots\\) and the erigon\_getHeaderByNumber helper, enabling users to use Otterscan-compatible tools for tracing internal operations, inspecting transaction errors, searching address history, and retrieving block details directly against the local Anvil node.

crates/anvil/src/eth/otterscan · high confidence

The \cast\ CLI now includes a new \safe\ subcommand group for interacting with Safe accounts. This adds commands to deploy Safe accounts (\cast safe create\), propose and sign transactions via the Safe Transaction Service (\cast safe propose\, \cast safe sign\), execute confirmed transactions (\cast safe execute\), and manage delegates (\cast safe add-delegate\, \cast safe list-delegates\, \cast safe remove-delegate\). It also supports simulating Safe transactions (\cast safe simulate\) to verify outcomes without requiring owner signatures.

crates/cast/src · high confidence

Users can now initialize a new Foundry project configured for the Tempo network using the \--network tempo\ flag. This template includes a \Mail\ smart contract that supports both direct and relayed mail sending, where relayed messages are verified via the TIP-1020 \SignatureVerifier\ precompile (supporting secp256k1 and P256 signatures). The package also provides a deployment script (\MailScript\) that automatically creates a TIP-20 test token and a CI workflow template to run Forge formatting, building, and testing on push and pull requests.

crates/forge/assets/tempo · high confidence

The \cast\ CLI now includes a new \tip20\ subcommand group that allows users to create new TIP-20 tokens via the TIP20Factory, validate and update token logo URIs, and mine salts for registering virtual masters on Tempo. The \create\ command supports optional logo URIs (with early validation for T5-compatible factories) and warns if the currency code is not ISO 4217 compliant. The \mine\ command finds proof-of-work salts for TIP-1022 registrations and can optionally submit the \registerVirtualMaster\ transaction immediately.

crates/cast/src/cmd/tip20 · high confidence

Foundry now includes built-in support for Arbitrum, Base, and Optimism EVM networks. The Arbitrum variant adds a precompile for the ArbSys system contract to correctly handle \arbBlockNumber()\ calls. The Base variant introduces specific precompiles (such as B20Factory and NonceManager) and code sentinels required for compatibility with Base mainnet contracts. The Optimism variant provides network-specific base fee parameter calculations that switch between standard and Canyon hardfork rules based on the block timestamp. These changes allow users to run and test against these L2 networks with correct system-level behavior.

crates/evm/networks/src · high confidence

A new binary entry point for the \solar\ CLI has been added, which initializes a custom global memory allocator and re-exports the main function from the \solar\_cli\ crate to serve as the Solidity compiler executable.

crates/solar · high confidence

New Solidity source files and their corresponding ABI/bytecode JSON artifacts have been added to the \crates/anvil/test-data\ directory to support Anvil's testing capabilities. The new contracts include \SimpleStorage\ (a basic storage contract with value change events), \emit\_logs\ (a simplified version for log emission testing), \greeter\ (a greeting contract), \multicall\ (aggregating multiple read-only calls), and \state-dump-legacy-stress\ (a complex contract used for stress-testing legacy state dump formats).

crates/anvil/test-data · high confidence

The core Ethereum types in \crates/anvil/core/src/eth\ have been migrated to use Alloy types (e.g., \alloy\_consensus::Block\, \FoundryHeader\, \FoundryTxEnvelope\), introducing generic transaction handling and canonical blob transaction encoding. This change also adds support for a wide range of new JSON-RPC methods, including \eth\_getAccountInfo\, \eth\_getStorageValues\, \eth\_getHeaderByNumber\, \eth\_getBlockAccessList\, \eth\_blobBaseFee\, and \eth\coinbase\, while introducing EIP-7702 delegation support via the \wallet\ module and \anvil\\*\ namespace.

crates/anvil/core/src/eth · high confidence

Anvil now includes a dedicated transaction pool module (\crates/anvil/src/eth/pool\) that manages the lifecycle of pending transactions. This implementation handles importing, ordering (by fees or FIFO), and pruning transactions based on nonce dependencies and markers. It provides APIs to query ready and pending transactions, remove transactions by sender or hash, and notify listeners when transactions become ready for inclusion in a block.

crates/anvil/src/eth/pool · high confidence

Fuzzing now records comparison branch frontiers (specific EVM comparison sites and their concrete operands) during test runs. These frontiers are captured by workers, deduplicated across parallel runs, and persisted as structured JSON artifacts (branch-frontiers.json) with stable schema versions for both stateless and stateful (invariant) campaigns. This enables downstream symbolic execution or targeted input generation to explore paths that were previously missed by random fuzzing.

crates/evm/evm/src/executors/fuzz · high confidence

The Chisel REPL has been restructured to allow execution on different EVM networks (such as Ethereum, Base, Monad, Optimism, and Tempo) rather than a single hardcoded implementation. The CLI now infers the target network from the chain ID or fork configuration and instantiates a generic \ExecutorBuilder\ for that specific network. This change enables users to interact with and test Solidity code against various EVM-compatible chains directly within the REPL session.

crates/chisel/src · high confidence

Anvil now allows library users to inject custom precompiles via a new \PrecompileFactory\ trait, supporting both static additions and dynamic address lookups during EVM initialization. Additionally, Optimism-specific EVM logic is now isolated in a dedicated module and gated behind the \optimism\ Cargo feature, meaning Optimism support is opt-in rather than always compiled in.

crates/anvil/src/evm · high confidence

The debugger in \crates/evm/traces/src/debug\ now automatically identifies internal function calls within traces by analyzing source map JUMP instructions. When an internal call is detected, the debugger extracts the function name and decodes its input and output arguments, making them visible in the trace output. This enhancement relies on new source data structures in \sources.rs\ that parse Solidity/Vyper ASTs to map bytecode locations to specific function scopes and variable declarations, allowing for more detailed and readable debugging of complex contract interactions.

crates/evm/traces/src/debug · high confidence

The formatter now includes a \sort\_imports\ configuration option. When enabled, it reorders import statements alphabetically by source file path and symbol name, as demonstrated by the new test data in \crates/fmt/testdata/SortedImports\ which shows unsorted imports being transformed into a sorted order.

crates/fmt/testdata/SortedImports · high confidence

The \editors\ directory now contains the VS Code extension client (imported from the Solar project) and the \forge lsp\ launcher that opens a dedicated VS Code instance with the bundled extension. Users can run \forge lsp\ in a Solidity project to get diagnostics, Go-to-Definition, hover, and formatting powered by the embedded \solar\_lsp\ server and the Forge executable's \forge fmt\. The extension introduces the \solarLsp.forgePath\ setting to point to the Forge binary, deprecating the old \solarLsp.serverPath\ (which previously pointed to a standalone Solar executable). It also includes development tooling (\prepare-vscode.mjs\, launch/tasks configs) to build and debug the client in an isolated environment without affecting user settings.

editors · high confidence

Added a new \cli-markdown\ crate that generates Markdown documentation for command-line tools built with Clap. This library, based on \clap-markdown\, includes enhancements such as support for grouped options by help heading, display of environment variable names for arguments, and inclusion of version information in the generated output. Users can now programmatically generate structured help documentation with customizable options like titles, footers, and table of contents.

crates/cli-markdown · high confidence

The primitives crate now defines a \FoundryNetwork\ type that unifies Ethereum and Tempo consensus headers via a new \FoundryHeader\ enum, enabling seamless deserialization of both standard Ethereum and Tempo-specific block data. This change also introduces \FoundryTxReceipt\ and \FoundryReceiptEnvelope\ types that support Tempo-specific fields (such as \feePayer\ and \blockTimestamp\) and, when the \optimism\ or \base\ features are enabled, OP-stack deposit receipts and Base-specific EIP-8130 receipt structures. Users interacting with Foundry's multi-network tooling will now benefit from consistent header and receipt handling across Ethereum, Tempo, Optimism, and Base networks within a single unified type system.

crates/primitives/src/network · high confidence

The \crates/common/src/tempo\ module now implements the CLI-side device-code authorization flow for Tempo Accounts, generating a local secp256k1 access key, creating a PKCE-protected device code, and polling for browser-based passkey authorization to persist the key in the local \store.json\. It also adds a session registry that manages temporary access-key lifecycles, including typed session authorization policy building, spending limits, call scopes, and live signer resolution. Additionally, the module provides T5 payment-lane classification for transaction routing, TIP-20 logo URI validation, and centralized fee-token resolution and sponsorship tooling.

crates/common/src/tempo · high confidence

Added a new \cast vaddr\ subcommand suite to manage Tempo virtual addresses (TIP-1022). The \create\ subcommand mines a proof-of-work salt, registers the virtual address master on-chain, and derives virtual addresses for a specified owner. The \resolve\ subcommand decodes a virtual address to reveal its master ID, user tag, and registered master address. The \watch\ subcommand monitors and prints incoming TIP-20 token transfers to a specific virtual address, supporting historical log retrieval and continuous polling.

crates/cast/src/cmd/vaddr · high confidence

Users can now verify smart contracts by providing raw bytecode and constructor arguments directly, without needing to supply the original source code. This new \forge verify-bytecode\ command, implemented in the \crates/verify\ module, allows verification against block explorers like Etherscan and Sourcify by replaying the deployment transaction to reconstruct the creation code. It supports specifying constructor arguments via CLI flags, files, or ABI-encoded hex, and allows ignoring specific bytecode types (creation or runtime) during the matching process.

crates/verify/src · high confidence

The \crates/linking\ crate has been added to provide a standalone EVM bytecode linker. This new component exposes a \Linker\ struct and associated types (\LinkOutput\, \DetailedLinkOutput\, \LinkerError\) to handle resolving library artifacts, stripping project root paths, and performing the actual bytecode linking operations. It serves as the foundational logic for library deployment and linking, separating this concern from the broader forge compilation and testing workflows.

crates/linking · high confidence

The \crates/anvil/rpc\ module now provides explicit Rust types for JSON-RPC protocol structures, including \RpcError\, \RpcResponse\, \RpcMethodCall\, and \Request\. This introduces standardized serialization and deserialization for RPC requests (supporting single calls, notifications, and batches) and responses, ensuring consistent handling of error codes and request IDs within the Anvil RPC layer.

crates/anvil/rpc · high confidence

Added a new preprocessor that replaces static bytecode linking in tests and scripts (e.g., \new Contract\) with dynamic linkage via \Vm.create\*\ cheatcodes. This change improves compilation caching efficiency by avoiding unnecessary recompilation when only test code changes, while preserving constructor diagnostics, handling \try\ contract creation, and correctly generating helper contracts for constructor argument encoding.

crates/common/src/preprocessor · high confidence

This change adds the foundational infrastructure for the Forge Solidity linter within \crates/lint/src/sol\. It introduces \declare\_forge\_lint\ and \register\_lints\ macros to declaratively define lint metadata and automatically register lint passes with the Solar framework, alongside a \naming.rs\ module providing shared helpers for case-convention checks (PascalCase, mixedCase, etc.). These components enable the consistent application of linting rules across the codebase.

crates/lint/src/sol · high confidence

Forge now includes a mutation testing feature that analyzes Solidity source code to generate and execute mutants, providing a mutation score to assess test suite robustness. The implementation adds a new \crates/forge/src/mutation\ module containing an orchestrator for managing parallel mutation runs, a visitor to collect expression mutations, type-aware filtering to exclude invalid operator replacements, and a reporter that displays killed, survived, and timed-out mutants. This allows users to identify gaps in their test coverage by measuring how many injected code changes (mutations) are caught by their existing tests.

crates/forge/src/mutation · high confidence

This change adds a new mutation testing capability to Forge, implemented in the \crates/forge/src/mutation/mutators\ directory. It introduces a registry and a suite of mutators that generate mutants to evaluate test suite quality. The included mutators target specific code patterns: \AssemblyMutator\ swaps Yul opcodes within the same family (arithmetic, comparison, bitwise, shift); \AssignmentMutator\ flips boolean literals, replaces numeric literals with zero or their negation, and handles identifier assignments; \BinaryOpMutator\ replaces binary operators (including compound assignments) with alternatives from the same category (boolean, numeric, bitwise); \DeleteExpressionMutator\ removes \delete\ expressions; \ElimDelegateMutator\ replaces \delegatecall\ with \call\; \RequireMutator\ inverts or neutralizes \require\/\assert\ conditions (e.g., to \true\, \false\, or negated); and \UnaryOpMutator\ swaps unary operators (pre/post increment/decrement, negation, bitwise not) while filtering out invalid non-lvalue targets. The \MutationContext\ and \MutatorRegistry\ provide the infrastructure to apply these mutators and collect generated mutants and errors.

crates/forge/src/mutation/mutators · high confidence

Foundry now includes a new symbolic execution engine for the EVM, allowing users to verify smart contract properties by exploring multiple execution paths simultaneously rather than relying solely on concrete fuzzing. This feature adds a new \crates/evm/symbolic\ library that integrates with the existing Foundry executor to generate symbolic calldata variants, manage solver backends (such as Z3), and report results as safe, counterexamples, or incomplete. Users can now run symbolic invariant checks and bounded model searches to detect edge-case failures that might be missed by random fuzzing.

crates/evm/symbolic/src · high confidence

The formatter's internal state management has been rewritten to use the Solar parser and a structured pretty-printing algorithm. This change introduces new modules in \crates/fmt/src/state\ (common, sol, yul, mod) that handle language-specific formatting for Solidity and Yul, including improved logic for comment preservation, literal formatting (numbers, strings, hex), and call expression indentation. This replaces the previous state implementation to support the new formatting engine.

crates/fmt/src/state · high confidence

This change adds a new symbolic execution engine (\SymbolicExecutor\) to the EVM crate, enabling path-based analysis of smart contracts using SMT solving. The implementation covers core EVM operations including CALL and CREATE semantics, cheatcode handling (such as \expectCall\, \expectRevert\, and storage hooks), and invariant checking. It introduces symbolic constraint management, deferred arithmetic solving, and mapping storage provenance tracking to improve the accuracy and performance of symbolic test runs.

crates/evm/symbolic/src/executor · high confidence

The \crates/common/src/io\ module now provides a centralized foundation for console interaction, featuring a global \Shell\ abstraction that manages verbosity, color choices, and output formats (plain text, JSON, and Markdown). This change introduces dedicated macros (\sh\_print\, \sh\_eprint\, \sh\_status\, \sh\_progress\, \sh\_err\, \sh\_warn\) to standardize how messages are displayed, ensuring that progress updates are suppressed in non-interactive environments and that output respects the user's configured verbosity and color settings. Additionally, new stdin utilities in \stdin.rs\ handle input parsing and CRLF line-ending normalization, while \style.rs\ defines consistent ANSI styles for errors and warnings.

crates/common/src/io · high confidence

A new \crates/primitives\ crate has been added to the project, serving as a central location for shared Foundry types. It currently exposes network and transaction modules, making these primitives available for use across other components like Anvil.

crates/primitives/src · high confidence

A new lint crate has been added to the project, exposing modules for linting logic and Solidity handling. This establishes the foundational structure for the linting capability, allowing other parts of the system to integrate linting rules and analysis.

crates/lint/src · high confidence

The Forge LSP now launches VS Code with a dedicated, isolated user-data and extensions directory for each project and editor configuration. This ensures that editor state, settings, and extensions do not leak between different Forge projects or profiles, and prevents conflicts with existing VS Code installations by using unique session keys and private directories.

crates/forge/src/cmd/lsp · high confidence

The \cast\ CLI has been significantly restructured, introducing several new commands and enhancing existing ones. New capabilities include \cast artifact\ to generate contract artifacts (ABI and bytecode), \cast creation-args\ to decode constructor arguments from creation code, \cast b2e-payload\ to convert beacon payloads, \cast bal\ to retrieve block access lists, and \cast access-list\ to generate EIP-2930 access lists. The \cast call\ command now supports state and block overrides (e.g., \--override-balance\, \--block.time\), delegatecall simulation (\--delegate\), and remote trace rendering via \--debug-trace-call\. Additionally, \cast batch-send\ and \cast batch-mktx\ enable native call batching for Tempo transactions, while \cast bind\ is now a stub directing users to \cast source\ and \forge bind\. The refactoring also consolidates transaction building logic and improves Tempo session and access-key integration across these commands.

crates/cast/src/cmd · high confidence

The \crates/evm/sancov\ crate now provides SanitizerCoverage callbacks that allow the fuzzer to use native Rust code edge coverage (from precompiles and revm internals) as a guidance signal. When enabled via the \sancov\_edges\ config option, this native coverage replaces EVM bytecode coverage for mutation guidance. Additionally, the \sancov\_trace\_cmp\ option captures comparison operands from instrumented native code and injects them into the fuzzer's dictionary to help solve comparison guards, while the \--showmap-out\ flag enables exporting the corpus in AFL format for cross-fuzzer comparison.

crates/evm/sancov · high confidence

The \crates/cli\ crate has been introduced to centralize common CLI utilities, providing a structured JSON output envelope (\JsonEnvelope\) for machine-readable command results and a dedicated lockfile handler (\Lockfile\) to manage \foundry.lock\ synchronization with git submodules. This location also includes the shell completion logic for Nushell alongside existing shells, a custom error handler for consistent error reporting, and the shared dependency installation logic previously scattered across commands.

crates/cli/src · high confidence

The \crates/cli/src/utils\ module has been expanded with several new capabilities. \abi.rs\ introduces \parse\_function\_args\, which allows users to provide function signatures without parentheses by automatically fetching function data from Etherscan (requiring an API key) and resolves ENS names in arguments. \allocator.rs\ abstracts the global allocator, enabling users to switch to \jemalloc\ or \mimalloc\ via feature flags for improved performance, with optional \tracy-allocator\ integration for profiling. \tempo.rs\ adds support for named nonce lanes, allowing teams to define and use friendly aliases for 2D nonces in parallel scripts via a \tempo.lanes.toml\ file, and parses fee token symbols (e.g., \pathusd\) into addresses. \cmd.rs\ provides helper utilities for loading configuration, installing missing dependencies, and determining chain-specific gas calculation behaviors. \suggestions.rs\ adds typo-tolerant suggestions for user inputs using Jaro-Winkler similarity.

crates/cli/src/utils · high confidence

The \crates/evm/core/src\ module has been expanded with new capabilities: \buffer.rs\ and \bytecode.rs\ provide utilities for tracking memory/calldata/returndata access and iterating over EVM bytecode instructions, supporting the debugger; \decode.rs\ introduces a \RevertDecoder\ for interpreting test revert data and console logs; \eip2935.rs\ adds helpers for EIP-2935 history storage; \tempo.rs\ implements genesis initialization for the Tempo network, including precompiles and fee tokens; and \constants.rs\ centralizes addresses like the cheatcode handler and default CREATE2 deployer.

crates/evm/core/src · high confidence

The \benches/src\ directory now contains a complete benchmark runner (\foundry-bench\) that compares Foundry versions (stable, nightly, or specific commits) across configurable repositories. It supports multiple benchmark types including standard forge tests, build caching, coverage, and a new symbolic testing suite (with fixtures for Solady, Angstrom, and Farcaster) that captures detailed SMT solver metrics. The runner also includes an \scfuzzbench\ integration for property-based fuzzing campaigns. Results are aggregated and exported in Hyperfine JSON format, a common benchmark schema, and optional symbolic sidecars, enabling regression tracking and detailed performance analysis.

benches/src · high confidence

The \crates/lint/src/sol/med\ module introduces a suite of new Solidity lints to detect medium-severity issues. These include \assert-state-change\ to flag state-modifying expressions inside \assert()\, \environment-read-across-mutation\ to warn when environment reads cross Foundry cheatcode mutations, and \dangerous-unary-operator\ to catch fused operators like \x =- 1\. Additional checks cover \divide-before-multiply\ precision loss, \ecrecover\ malleability, incorrect ERC20/ERC721 interfaces, dangerous strict equality on externally-influenced values, locked ether, invalid mapping deletions, \nonReentrant\ modifier placement, tautological comparisons, type-based tautologies, and unsafe \tx.origin\ usage.

crates/lint/src/sol/med · high confidence

Users can now run \cast wallet list\ to display accounts from local keystores, Ledger, Trezor, AWS KMS, and Google Cloud KMS. The command supports an \--all\ flag to aggregate sources, \--max-senders\ to limit hardware wallet results, and structured JSON output via \--json\. It also includes a new \cast wallet session\ command for managing Tempo wallet sessions (create, revoke, and interactive \--for\ usage) and adds \cast wallet touch-id\ for enrolling, checking status, and removing Touch ID authentication on macOS.

crates/cast/src/cmd/wallet · high confidence

The EVM inspector stack now includes several new inspectors to enhance execution analysis and debugging. A \ChiselState\ inspector captures the final stack and memory state for the Chisel REPL. A \CustomPrintTracer\ provides step-level opcode and gas debugging output. The \EdgeCovInspector\ now supports configurable collision-free edge coverage and CmpLog-style comparison operand logging for guided fuzzing. A \RevertDiagnostic\ inspector detects and explains reverts caused by calls to non-contract addresses. Additionally, a \ScriptExecutionInspector\ now reverts script execution if the \address(this)\ opcode is used, and the \TempoLabels\ inspector has been updated to decode bounded TIP20 token names from storage.

crates/evm/evm/src/inspectors · high confidence

A new \anvil-core\ crate has been introduced to house core Ethereum types for Anvil, exposing \eth\ and \types\ modules. This includes the \ReorgOptions\ struct and \TransactionData\ enum, which enable users to configure and execute chain reorganizations by specifying depth and providing transaction/block pairs in either JSON or raw byte formats.

crates/anvil/core/src · high confidence

Added \vm.toBase64\ and \vm.toBase64URL\ cheatcodes to encode arbitrary bytes into standard and URL-safe base64 strings respectively, providing a convenient way to handle base64-encoded data within Solidity tests and scripts.

crates/cheatcodes/src · high confidence

Added three new shell scripts in benches/scripts to streamline benchmarking workflows: pr-bench.sh for comparing base and candidate branches, pr-scfuzzbench.sh for running security fuzzing benchmarks against specific repositories like Aave v4, and run-benchmark-suite.sh for defining and executing comprehensive benchmark suites (CI, nightly, symbolic, etc.) with configurable repositories and output formats.

benches/scripts · high confidence

The \crates/common\ crate now includes a \build.rs\ script that generates version metadata at compile time. This script uses the \vergen\ library to capture build date, timestamp, and Git SHA, and constructs detailed version strings (short, long, and SemVer) based on the package version, Git tag, and build profile. It also handles edge cases like building outside a Git worktree and normalizes nightly tags to ensure consistent versioning across artifacts.

crates/common · high confidence

The \crates/common/src/comments\ module has been rewritten to introduce a structured comment representation and support for inline formatting suppressions. Users can now use \forgefmt: disable-start\ and \forgefmt: disable-end\ comments to selectively disable formatting for specific code blocks, alongside granular directives like \disable-line\ and \disable-next-item\. The comment parser now accurately distinguishes between isolated, trailing, mixed, and blank-line comment styles, ensuring that multi-line trailing comments are grouped correctly for proper indentation and that inline configurations are validated against available lint IDs.

crates/common/src/comments · high confidence

The provider module now includes a \CurlTransport\ that outputs equivalent curl commands instead of executing RPC requests, supporting custom headers and JWT authentication for debugging. Additionally, a new \fee\ module introduces EIP-1559 fee estimation with configurable presets, allowing users to select reward percentiles and base-fee multipliers, while also providing a fee breakdown (max fee, priority fee, and base fee) and handling overrides for gas price and priority tips.

crates/common/src/provider · high confidence

The \crates/common/fmt\ crate now includes a new \console\ module that parses and formats \console.log\ style strings (supporting \%s\, \%d\, \%i\, \%o\, \%x\, and \%\<n\>e\ specifiers), a \dynamic\ module that provides pretty-printing and JSON serialization for \DynSolValue\ types (handling integers, arrays, tuples, and structs), and an \exp\ module that formats large integers with exponential notation hints (e.g., \1234567890 \[1.234e9\]\) to improve readability of large numbers in output.

crates/common/fmt · high confidence

The \forge lint\ tool now includes a suite of gas-focused checks in the \crates/lint/src/sol/gas\ module. These lints help identify patterns that waste gas: \cache-array-length\ flags dynamic array length reads inside loop conditions; \costly-loop\ detects storage writes within loops; \custom-errors\ warns when \require\ or \revert\ uses string literals instead of custom errors; \external-function\ suggests changing \public\ functions to \external\ when possible; \could-be-immutable\ and \could-be-constant\ recommend declaring state variables as immutable or constant to save storage; \asm-keccak256\ suggests using inline assembly for keccak256 calls; \unused-state-variables\ flags variables that are never read; \var-read-using-this\ warns against calling view/pure functions via \this\ (which triggers STATICCALL); and \write-after-write\ detects redundant storage writes where a value is overwritten before being read.

crates/lint/src/sol/gas · high confidence

The \crates/lint/src/sol/high\ module now includes a suite of new high-severity lints that detect critical Solidity security patterns. These include \arbitrary-send-eth\ and \arbitrary-send-erc20\ (with permit support) to flag unsafe token/ETH transfers to user-controlled addresses, \controlled-delegatecall\ to identify untrusted delegatecall targets, and \function-selector-collision\ to detect proxy/implementation selector clashes. Additional detectors cover \reentrancy\ (balance, ETH, and no-ETH variants), \protected-vars\ (Slither-compatible write-protection checks), \enumerable-loop-removal\ (EnumerableSet corruption), \encode-packed-collision\ (hash collision risks), \incorrect-exp\ (xor vs exponentiation), \incorrect-shift\ (Yul argument order), \rtlo\ (right-to-left override), \unchecked\_calls\, and \unprotected\_initializer\. These lints are registered in \mod.rs\ and utilize the Solar HIR for path-sensitive analysis.

crates/lint/src/sol/high · high confidence

A new lint rule, \unwrapped-modifier-logic\, has been added to the \codesize\ lint category. It detects Solidity modifiers where logic surrounding the placeholder (\\_;\) can be extracted into internal helper functions to reduce overall contract code size. When triggered, the linter provides a machine-applicable code suggestion that refactors the modifier by splitting the logic into \\_nameBefore\ and \\_nameAfter\ helper functions, ensuring the transformation is safe by checking for shared variables or complex control flow that would break behavior if moved.

crates/lint/src/sol/codesize · high confidence

The linting engine now includes a comprehensive suite of new checks in the \sol/info\ module. These rules detect boolean constant misuse and simplifiable boolean comparisons, flag unindexed \address\ event parameters, and warn about inline assembly usage. The linter also identifies code smells such as cyclomatic complexity exceeding 11, state variable initializers that depend on non-pure functions, and literals that should be extracted into constants. Additional rules enforce naming conventions for interfaces, detect unused imports, and flag internal functions or modifiers that are only used once. The suite also includes checks for incorrect \using ... for\ directives, missing inheritance from interfaces, and the use of low-level calls.

crates/lint/src/sol/info · high confidence

This change introduces a suite of new low-severity lints in the \crates/lint/src/sol/low\ module to help developers identify common Solidity pitfalls. Loop-related checks now flag external calls (\calls-loop\), \delegatecall\ usage (\delegatecall-loop\), \msg.value\ access (\msg-value-loop\), and reentrancy risks where events are emitted after external calls (\reentrancy-events\). State management is improved with detectors for missing events on access control changes (\missing-events-access-control\) and arithmetic operations (\missing-events-arithmetic\), as well as a stricter check for missing zero-address validations on address parameters (\missing-zero-check\). Additional lints warn against using \block.timestamp\ in comparisons (\block-timestamp\), using deprecated OpenZeppelin functions (\deprecated-oz-function\), and leaving function bodies empty (\empty-block\). The suite also enforces consistent integer type naming (\inconsistent-type-names\) and detects modifiers that can skip the modified function (\incorrect-modifier\).

crates/lint/src/sol/low · high confidence

The configuration crate has been reorganized into distinct modules to improve maintainability and clarity. New files define specific configuration structures and logic for various Foundry features: \bind\_json.rs\ for \forge bind-json\ settings, \cache.rs\ for storage caching controls, \compilation.rs\ for compilation restrictions and settings overrides, \coverage.rs\ for \forge coverage\ report options, \doc.rs\ for \forge doc\ rendering settings, \endpoints.rs\ for RPC endpoint management, \error.rs\ for configuration error handling and Solidity error codes, \etherscan.rs\ for Etherscan API key and URL management, \extend.rs\ for TOML inheritance strategies, \external\_compiler.rs\ for external compiler adapter configurations, \fee.rs\ for EIP-1559 fee estimation presets, and \filter.rs\ for file filtering utilities. This modularization separates concerns within the configuration system, making it easier to manage and extend individual feature configurations.

crates/config/src · high confidence

The \foundry-macros\ crate now provides two new derive macros: \Cheatcode\ and \ConsoleFmt\. The \Cheatcode\ macro generates the \CheatcodeDef\ implementation for cheatcode structs, extracting metadata like group, status, safety, and function signatures from attributes and documentation. The \ConsoleFmt\ macro implements the \ConsoleFmt\ trait for structs and enums, enabling formatted output for console logging, including special handling for table-like structures (structs with \Vec\ fields).

crates/macros · high confidence

The lint engine now includes a new \crates/lint/src/sol/analysis\ module providing shared, side-effect-free probes over the Solar HIR that Solidity lints can reuse. This adds access-control guard detection (identifying dominating checks against \msg.sender\/\tx.origin\ and tracking the state variables they depend on), expression-shape probes (identifying builtins like \msg.sender\, \require\, \assert\, \revert\, zero values, and address casts), statement-shape probes (visiting statements, detecting unconditional exits, and analyzing modifier control flow), and a bounded cache for helper-call analysis to prevent unbounded recursion. These utilities consolidate common analysis logic previously scattered across lints, improving consistency and reducing duplication in access-control and modifier-related checks.

crates/lint/src/sol/analysis · high confidence

The \crates/common/src/transactions\ module now provides core abstractions for transaction lifecycle and display. It introduces \TransactionMaybeSigned\ to unify handling of unsigned requests and signed envelopes, and the \FoundryTransactionBuilder\ trait to extend network transaction builders with support for EIP-4844 blobs, EIP-7702 authorizations, and Tempo-specific fields like fee tokens and nonce keys. Additionally, \TransactionReceiptWithRevertReason\ enhances receipt output by automatically fetching and displaying revert reasons for failed transactions, improving debugging visibility for users.

crates/common/src/transactions · high confidence

Fork creation now optionally fetches and validates the EIP-7928 Block Access List (BAL) from the RPC endpoint to pre-warm the local fork cache with account balances, nonces, code, and storage slots. This optimization is gated by strict eligibility checks (Ethereum mainnets, Cancun+ hardforks, default network profiles, and immutable source verification) and runs with a 500ms timeout to avoid blocking fork setup. Validated BAL data is merged into the in-memory database without overwriting existing cached values, reducing subsequent RPC calls during forked test execution.

crates/evm/core/src/fork · high confidence

The repository is initialized with essential configuration files to support development workflows. A new Dockerfile is added to build multi-architecture images using Rust 1.98 and sccache, exposing the built binaries (forge, cast, anvil, chisel, solar). A Makefile is introduced to standardize build, test, lint, and documentation commands. Developer tooling is configured via rustfmt.toml, clippy.toml, deny.toml, dprint.json, and typos.toml to enforce code style, dependency security, and formatting. Documentation and contribution guidelines are established through AGENTS.md, CONTRIBUTING.md, and README.md. Licensing is clarified with LICENSE-MIT and LICENSE-APACHE, and funding sources are recorded in FUNDING.json.

(repo-wide) · high confidence

Added support for generating detailed Solidity stack traces when tests fail. This new backtrace feature maps EVM program counters to specific source file locations (line and column) by leveraging deployed bytecode and source maps, allowing users to pinpoint exactly where a revert occurred in their Solidity code, including support for linked libraries.

crates/evm/traces/src/backtrace · high confidence

Foundry now integrates the Machine Payments Protocol (MPP) to handle RPC endpoints that require payment (HTTP 402). The \LazyMppHttpTransport\ and \LazyAccountsProvider\ in \crates/common/src/provider/mpp\ automatically detect insufficient balance errors, trigger an interactive login via \cast tempo login\ if needed, and manage session channels using a local SQLite store. This allows users to pay for RPC access seamlessly without manual configuration, with safeguards like concurrency limits and deposit caps.

crates/common/src/provider/mpp · high confidence

The transaction primitives now support Base-specific EIP-8130 account-abstraction transactions and OP-stack deposit transactions. This adds new variants to the \FoundryTxEnvelope\ and \FoundryReceiptEnvelope\ enums, implements conversion logic to map these transaction types into the appropriate EVM execution environments (\BaseTransaction\ and \OpTransaction\), and provides helper functions to extract deposit transaction parts and project simulation requests for EIP-8130 transactions.

crates/primitives/src/transaction · high confidence

The EVM backend now supports reading account state from a Block Access List (BAL) before executing a transaction against a forked block. This allows the backend to position reads at a specific transaction's index to retrieve its prestate without replaying earlier transactions in the block. The \Backend\ type now includes \set\_bal\ and related storage/account access methods to serve reads from the BAL with fallback to the underlying database, and \CowBackend\ (used for fuzzing) correctly delegates these reads. This capability is primarily useful for optimizing transaction replay and state inspection in forked environments.

crates/evm/core/src/backend · high confidence

Users can now generate folded stack traces from EVM call traces, enabling integration with profiling tools like speedscope for flamegraph visualization. This change introduces the \EvmFoldedStackTraceBuilder\ in \crates/evm/traces/src/folded\_stack\_trace.rs\, which recursively processes call nodes and internal function steps to produce a format compatible with stack trace analyzers. The module also handles gas accounting adjustments for isolated traces and correctly maps decoded internal function calls to their respective stack frames.

crates/evm/traces/src · high confidence

Users can now define Foundry configuration settings directly within Solidity source files using structured comments (NatSpec). By prefixing lines with \forge-config:\, configurations can be applied at either the contract level or specific function level, allowing granular control over test behavior (such as network selection or symbolic execution settings) without modifying external config files. The system parses these annotations from the compiler output, validates them against defined profiles, and merges them with the base configuration at runtime. Legacy \@custom:halmos\ annotations are also supported and translated into the new inline config format for backward compatibility.

crates/config/src/inline · high confidence

Added a new \external.rs\ module in the script verification crate to handle acquisition, compilation, and matching of external Solidity sources. This enables the verification of contracts deployed by external factories by fetching source code from providers like Etherscan and Sourcify, compiling them with the appropriate Solidity versions, and matching the resulting bytecode against the deployed contract.

crates/script/src/verify · high confidence

The symbolic execution engine for the EVM has been implemented in this location, introducing the core runtime components required to model and execute smart contracts symbolically. This includes the symbolic memory and stack management (\SymMemory\, \SymStack\), handling of symbolic bytes and calldata (\SymBytes\, \SymCalldata\), and the execution of EVM opcodes and precompiles (\SymExpr\, \precompiles.rs\). The runtime also integrates Foundry cheatcodes (\cheatcodes.rs\) and manages the symbolic state of the blockchain (\state.rs\), enabling the symbolic runner to track constraints and explore execution paths.

crates/evm/symbolic/src/runtime · high confidence

The \crates/evm/hardforks\ crate now provides a single \FoundryHardfork\ enum that unifies Ethereum, Optimism, Base, Tempo, and Monad hardforks. This allows users to specify and parse hardforks using a consistent \network:hardfork\ format (e.g., \optimism:shanghai\, \tempo:t1\) in CLI arguments and configuration files, with automatic detection of the active hardfork based on chain ID and timestamp.

crates/evm/hardforks · high confidence

The \src\ directory has been cleared of the initial CLI implementation, specifically deleting \src/bin/seth.rs\, \src/lib.rs\, and \src/opts.rs\. This removes the \structopt\-based command-line interface that previously exposed subcommands for buying NFTs, deploying contracts, and fetching prices, along with the associated Ethereum and Flashbots configuration options.

src · high confidence

The monolithic in-memory backend in \crates/anvil/src/eth/backend/mem\ has been reorganized into distinct modules to support multiple EVM networks. A new \optimism.rs\ module handles OP-stack specific receipt construction and blob gas accounting, while \base.rs\ introduces Base-specific transaction execution and upgrade gating. State management is now split into \cache.rs\ for on-disk snapshots, \fork\_db.rs\ for forked database operations, and \in\_memory\_db.rs\ for the incremental state root database. Additionally, \inspector.rs\ centralizes the EVM inspector logic for tracing and log collection, and \mod.rs\ serves as the main entry point wiring these components together.

crates/anvil/src/eth/backend/mem · high confidence

The script sequence handling logic has been moved into a new \crates/script-sequence\ crate, introducing \ScriptSequence\<N\>\ and \TransactionWithMetadata\<N\>\ as generic types parameterized by the Alloy \Network\. This change allows the broadcast reader and sequence management to work with different network types rather than being tied to a single implementation. The \BroadcastReader\ now supports filtering by transaction type and contract name, and the \ScriptSequence\ structure includes fields for sensitive metadata (like RPC URLs) stored separately in a cache file to improve security. Additionally, the \timestamp\ field in broadcast files is now stored as milliseconds instead of seconds, and the \opcode\ field in transaction metadata has been renamed to \call\_kind\ for clarity.

crates/script-sequence · high confidence

The \forge\ binary's main entry point has been moved to the \crates/forge/bin\ crate. This change consolidates the CLI executable logic, delegating argument parsing and command execution to the \forge::args::run\ function while maintaining the existing error handling and global allocator configuration.

crates/forge/bin · high confidence

The \crates/forge/src\ directory has been reorganized into a modular library crate, separating the CLI entry point (\args.rs\), command definitions (\opts.rs\), and core execution logic (\multi\_runner.rs\, \runner.rs\) from the binary. This change introduces dedicated modules for coverage reporting (\coverage.rs\), gas analysis (\gas\_report.rs\), and test progress tracking (\progress.rs\), while exposing public APIs for external consumers. Users benefit from a cleaner separation of concerns, improved testability, and the ability to integrate Forge's core testing and fuzzing capabilities into other Rust projects.

crates/forge/src · high confidence

The \crates/common\ directory has been reorganized into a dedicated \foundry-common\ library, extracting shared functionality previously scattered across the workspace. This new crate provides a unified interface for ABI encoding and decoding (including packed encoding and event data parsing), project compilation via a configurable \ProjectCompiler\ builder, and contract artifact management through \ContractsByArtifact\. It also introduces support for external compiler adapters, caching of external storage layouts for forked contracts, and system address constants for various L2 networks (Monad, MegaETH, Hyperliquid).

crates/common/src · high confidence

The invariant fuzzing logic in \crates/evm/fuzz/src/invariant\ has been restructured into distinct modules: \call\_override.rs\ now handles the generation and replay of random calls to simulate reentrancy, \filters.rs\ manages artifact and sender targeting/exclusion rules, and \mod.rs\ orchestrates the identification of target contracts and their fuzzable functions. This change improves code organization and separation of concerns within the invariant testing engine without altering the external fuzzing behavior.

crates/evm/fuzz/src/invariant · high confidence

The EVM executor has been refactored to be generic over network types (e.g., Ethereum, Base, Monad, Tempo) via the \FoundryEvmNetwork\ trait. This introduces a new \ExecutorBuilder\ for configuring executors, moves fuzz campaign execution logic into a dedicated \campaign\ module, and restructures corpus management into \corpus\ and \corpus\_io\ modules. The \Executor\ struct now uses \Arc\-wrapped backends for efficient cloning, and network-specific features like Monad cheatcodes or Tempo labels are handled via conditional compilation and network-specific builder implementations.

crates/evm/evm/src/executors · high confidence

The cheatcode logic in \crates/cheatcodes/src/evm\ has been reorganized into distinct modules—\fork.rs\, \mapping.rs\, \mock.rs\, \prank.rs\, and \record\_debug\_step.rs\—to improve code structure and maintainability. This change extracts the implementations for fork management, mapping slot recording, call mocking, prank handling, and debug trace recording into their own files, while introducing a generic \FoundryEvmNetwork\ trait bound to support the new Monad context architecture.

crates/cheatcodes/src/evm · high confidence

The test cheatcode implementation has been reorganized into distinct modules (\assert.rs\, \assume.rs\, \expect.rs\, \revert\_handlers.rs\) to improve maintainability and clarity. This change introduces structured error types for comparison assertions (e.g., \EqAbsAssertionError\, \EqRelAssertionError\) that provide detailed, formatted mismatch messages including decimal formatting for numeric comparisons. It also centralizes revert logic through a shared \RevertParameters\ trait and dedicated handlers, enabling consistent matching for \expectRevert\ and \assumeNoRevert\ across different call depths and contexts. The \expect\ module now explicitly tracks call counts, emitter addresses, and anonymous event support with granular mismatch reporting, while the \assume\ module cleanly separates state management for conditional test skipping.

crates/cheatcodes/src/test · high confidence

The fuzzing strategy generation logic in \crates/evm/fuzz/src/strategies\ has been reorganized into distinct modules (\calldata\, \int\, \uint\, \param\, \state\, \invariants\, \tx\, \mutators\, \literals\) to improve code maintainability and separation of concerns. This refactoring introduces specific strategies for generating calldata with enum constraint handling, dedicated strategies for signed and unsigned integer fuzzing with fixture support, and a unified transaction generator that handles both stateless and invariant test scenarios. The change also adds support for Gaussian noise and bound mutators for integer values, and integrates literal collection from source code into the fuzz dictionary, enhancing the quality and relevance of fuzz inputs without altering the external fuzzing API.

crates/evm/fuzz/src/strategies · high confidence

The trace identification logic in \crates/evm/traces/src/identifier\ has been restructured into distinct modules: \local.rs\ handles identification using local project artifacts and bytecode matching, while \external.rs\ manages lookups via block explorers (Etherscan) and Sourcify. A new \TraceIdentifiers\ collection in \mod.rs\ orchestrates these strategies, allowing the system to first attempt local identification and then fall back to external sources. Additionally, \signatures.rs\ now manages function, event, and error signature caching and resolution via OpenChain, improving how unknown selectors are resolved and persisted.

crates/evm/traces/src/identifier · high confidence

The CLI build command options have been reorganized into a new \crates/cli/src/opts/build\ module, splitting the previous monolithic definition into \BuildOpts\ (core build settings like cache, output, and libraries), \CompilerOpts\ (compiler-specific flags such as optimizer runs, EVM version, and via-ir), and \ProjectPathOpts\ (project root, contracts, remappings, and library paths). This refactoring improves code maintainability and clarity for users by logically grouping related command-line arguments, while preserving all existing functionality including cache control, compiler version selection, and project path configuration.

crates/cli/src/opts/build · high confidence

The EVM core module has been restructured to introduce a unified \FoundryEvmFactory\ trait and a \NestedEvm\ object-safe abstraction, replacing previous wrapper structs with a consistent interface for all supported networks. This change adds concrete implementations for Base, Monad, and Optimism alongside the existing Ethereum and Tempo networks, allowing cheatcodes and nested execution to operate without knowing the specific network type. For Base, the implementation handles L1 block info and precompile sentinel addresses; for Monad, it integrates reserve balance tracking and system call handling; and for Optimism, it preserves L1 fee context. This centralization simplifies how Foundry manages EVM execution across different chains.

crates/evm/core/src/evm · high confidence

A change to existing behaviour in crates/fmt/testdata/NumberLiteralUnderscore — 5 commits (2 fixs), 10 files.

crates/fmt/testdata/NumberLiteralUnderscore · medium confidence · unverified

The \anvil\ binary now initializes a global memory allocator (sourced from \foundry\_cli::utils\) before executing the main run loop. This change ensures consistent memory management behavior for the local Ethereum development node and aligns the binary's startup sequence with the abstracted global allocator pattern introduced in the CLI crate.

crates/anvil/bin · high confidence

The Anvil command-line interface has been reorganized into dedicated source files (\args.rs\, \cmd.rs\, \opts.rs\) to improve modularity. The entry point now explicitly parses global and node arguments via \Anvil::parse()\, resolves RPC aliases, and dispatches subcommands such as shell completion generation. This change separates the CLI argument definitions and execution flow from the core node logic, providing a cleaner structure for command-line interaction without altering the underlying node behavior.

crates/anvil/src · high confidence

The Anvil Ethereum JSON-RPC implementation has been reorganized into a new modular structure under \crates/anvil/src/eth\. The main RPC entry point is now the \EthApi\ struct in \api.rs\, which handles all \eth\\\, \debug\\\, and \anvil\\\ endpoints. Fee calculation logic has been extracted into \fees.rs\ (with Optimism-specific rules in \fees/optimism.rs\), and transaction mining is managed by the new \miner.rs\ module. Signing capabilities are centralized in \sign.rs\, providing network-agnostic support for developer keys and impersonation. This refactoring consolidates the core execution engine while maintaining the existing RPC surface.

crates/anvil/src/eth · high confidence

The Anvil backend module has been rewritten to integrate with the latest Alloy and Revm versions, replacing internal types with their Alloy equivalents (e.g., \alloy\_genesis::Genesis\, \alloy\_evm\ block execution traits). This change updates the core execution, database, and fork handling logic to align with the new EVM stack, ensuring compatibility with modern Ethereum client standards and improving type safety across the backend.

crates/anvil/src/eth/backend · high confidence

The brutalizer in \crates/forge/src/brutalizer\ has been expanded to detect external functions containing inline assembly and inject deterministic, span-seeded Solidity assembly blocks that corrupt memory (via \mstore\ and \keccak256\ loops) and misalign the free memory pointer. This new behavior targets only \external\ functions with assembly bodies, leaving public, internal, constructor, fallback, and receive functions untouched, and is accompanied by tests verifying the injection logic and deterministic output.

crates/forge/src/brutalizer · high confidence

The CLI argument definitions in \crates/cli/src/opts\ have been reorganized into distinct, modular structs (\GlobalArgs\, \EvmArgs\, \RpcOpts\, \TempoOpts\, \TransactionOpts\, etc.) to improve composability and reduce duplication. This change introduces a custom \ChainValueParser\ for better chain ID validation, adds support for specific dependency references (\@tag=\, \@branch=\, \@rev=\) in \forge install\, and integrates new Tempo-specific transaction options such as fee tokens, expiring nonces, and sponsorship. Users will see these new flags and refined error messages for chain selection and dependency parsing.

crates/cli/src/opts · high confidence

The \cast\ CLI entry point has been moved from the previous location into the new \crates/cast/bin\ crate. This change introduces structured JSON error output: when the \--json\ flag is active, errors are wrapped in a \JsonEnvelope\ and printed via \print\_json\, preserving error chains and specific error codes (e.g., \cast.error\), while non-JSON mode continues to use the standard error formatter. The binary also now explicitly configures a global allocator via \foundry\_cli::utils::Allocator\.

crates/cast/bin · high confidence

The Chisel binary now initializes with a global allocator defined in foundry\_cli::utils, ensuring consistent memory allocation behavior across the application. The main entry point invokes the run function from chisel::args and handles errors by formatting them using Debug trait output via foundry\_common::sh\_err before exiting with a non-zero status code.

crates/chisel/bin · high confidence

The \crates/script/src\ module has been completely rewritten to introduce a structured, state-machine-driven workflow for \forge script\. The new implementation replaces the previous monolithic logic with distinct stages—PreprocessedState, LinkedState, PreExecutionState, and ExecutedState—managed by a new \ScriptRunner\. This refactor introduces robust nonce synchronization with retry logic during sequential broadcasts, integrates native Tempo support (including batch transactions, access keys, and fee token resolution), and adds browser wallet support. It also improves multi-chain deployment handling via \MultiChainSequence\ and enhances user feedback with detailed progress bars and JSON output during the broadcast phase.

crates/script/src · high confidence

The configuration loading system has been restructured to improve validation and remapping handling. A new \WarningsProvider\ now actively checks for unknown keys and deprecated settings across all configuration profiles, providing clearer feedback to users when they use invalid or outdated configuration options. The remappings provider has been rewritten to support parallel processing for better performance and to more accurately handle context-specific remappings, ensuring that project-level remappings correctly override dependency-level ones while preventing conflicts. Additionally, the system now supports TOML inheritance via an \extends\ field, allowing configuration files to inherit settings from a base file while preventing nested inheritance to avoid complexity.

crates/config/src/providers · high confidence

The Solidity formatter now properly handles the indentation of closing braces in empty contracts that contain comments. Previously, a comment inside an empty contract could result in incorrect formatting of the closing brace; the update ensures the brace is aligned correctly according to the contract's scope.

crates/fmt/testdata/CommentEmptyLine · high confidence

The debugger's terminal user interface has been completely rewritten to improve structure and functionality. The new implementation introduces a modular architecture with separate modules for context management, rendering, and storage access tracking. Users benefit from enhanced storage inspection capabilities, including support for both persistent and transient storage access tracking, with detailed views of slot values and changes. The TUI now features a more robust layout system with configurable horizontal and vertical arrangements, improved scroll position memory to reduce screen jitter, and better handling of internal call contexts. The rewrite also includes a new command prompt system with specialized input handling for different command types, and improved error handling with specific fallback messages for non-interactive environments.

crates/debugger/src/tui · high confidence

The debugger crate has been refactored to use a \DebuggerBuilder\ for constructing the debugger instance, allowing configuration of traces, contract identifiers, sources, breakpoints, and TUI layout. A new \DebuggerLayout\ enum lets users choose between Auto, Horizontal, or Vertical terminal layouts. The debugger now supports dumping its internal state to a JSON file via \dump\_to\_file\, including contract sources, artifacts, and debug nodes. The core debugger logic has been reorganized into separate modules for builder, context, node representation, and TUI interaction.

crates/debugger/src · high confidence

The CLI now strictly prevents combining the \--tempo.session\ flag (or \TEMPO\_SESSION\_ID\ environment variable) with any explicit wallet signer options (such as private keys, mnemonics, hardware wallets, or cloud KMS). When a Tempo session is active, the system resolves the signer exclusively from that session and fails if conflicting signer configurations are detected, ensuring that session-based signing does not fall back to long-lived credentials.

crates/cli/src/opts/tempo · high confidence

The symbolic solver now handles complex EVM arithmetic more effectively by introducing a bounded fallback model generator for hard arithmetic constraints (such as multiplication and division involving symbolic variables) and a new polynomial identity reasoning pass that recognizes nonlinear algebraic identities over EVM words. Additionally, the solver normalizes constraints using rounding error bounds to simplify relations between rounded multiples and their dividends, and applies lightweight monotonic product reasoning to detect unsatisfiability earlier. These changes improve the solver's ability to prove path feasibility and generate models for contracts relying on intricate arithmetic logic without immediately falling back to external SMT solvers.

crates/evm/symbolic/src/runtime/solver · high confidence

The Etherscan verification provider in \crates/verify/src/etherscan\ has been refactored to support submitting contracts using a flattened source file format, in addition to the existing standard JSON input. A new \EtherscanFlattenedSource\ provider validates that the \bytecodeHash\ is set to \ipfs\ (a requirement for Etherscan's compiler settings) and performs a local dry-run compilation of the flattened code to catch errors before submission, unless the \--force\ flag is used. This change is implemented via a new \EtherscanSourceProvider\ trait and associated modules (\flatten.rs\, \standard\_json.rs\) within the Etherscan verification module.

crates/verify/src/etherscan · high confidence

The \sol-macro-gen\ crate has been updated to support generating Rust bindings from Solidity contracts with several key improvements. Bindings are now generated in parallel using \rayon\ to improve performance, and the output can be streamed for single-file generation. When the \all\_derives\ option is enabled, the generated code automatically includes \serde\ and \serde\_with\ dependencies and derives, handling large arrays via \serde\_with\ attributes. The generated \Cargo.toml\ now supports custom package descriptions and licenses, and the system ensures proper qualification of shadowed event module paths and correct snake\_case file naming.

crates/sol-macro-gen · high confidence

The Solidity formatter has been updated to handle long method chains and function calls with options (such as \target{value: amount}(...)\) by wrapping them across multiple lines when they exceed the configured line length. This change ensures that chained calls, including those with comments or complex call options, are formatted consistently and readably, addressing issues where previously long chains remained on a single line or were formatted inconsistently.

crates/fmt/testdata/MethodChain, crates/fmt/testdata/MethodChainCallOptions · high confidence

The Solidity formatter now correctly retains comments (inline, trailing, isolated, and multiline) attached to modifier and constructor definitions during formatting. Previously, these comments might have been lost or misaligned; the new behavior ensures that explanatory comments remain associated with their respective definitions, improving code readability and documentation preservation.

crates/fmt/testdata/ModifierDefinition · high confidence

The formatter now correctly retains empty parentheses on constructor modifiers (e.g., \Ownable()\ instead of stripping them to \Ownable\). This change ensures that the formatted output matches the original source style for these specific modifier invocations, preventing unwanted normalization of constructor modifier syntax.

crates/fmt/testdata/ConstructorModifierStyle · high confidence

The \foundry-evm\ crate has been reorganized to expose a cleaner public API. The library now explicitly re-exports core components such as \EvmEnv\, \FoundryInspectorExt\, and \InspectorExt\ from \foundry\_evm\_core\, alongside dedicated modules for \foundry\_evm\_coverage\, \foundry\_evm\_fuzz\, \foundry\_evm\_hardforks\, and \foundry\_evm\_traces\. This change centralizes the main abstractions and simplifies access to key EVM backend functionality for users of the crate.

crates/evm/evm/src · high confidence

Anvil now uses generic \MaybeImpersonatedTransaction\ and \PendingTransaction\ types to handle transaction impersonation and pending state management. This change allows the transaction pool and core logic to support various transaction envelope types while preserving impersonation metadata (such as overriding the sender address) and ensuring correct transaction hashing for impersonated transactions.

crates/anvil/core/src/eth/transaction · high confidence

The \crates/common/src/errors\ module now provides \FsPathError\, a new error type that wraps standard I/O errors with specific file paths for operations like read, write, copy, and lock, ensuring users see exactly which file caused a failure. Additionally, the error reporting logic has been updated to deduplicate redundant messages in error chains (e.g., collapsing "msg1: msg2; msg2" into "msg1: msg2") and to improve diagnostics reporting from the Solar compiler, including better handling of non-buffer emitters.

crates/common/src/errors · high confidence

The Solidity formatter now handles emit statements, revert statements with named arguments, and function calls with call options (e.g., { gas: ... }) with greater precision. It correctly preserves inline and block comments within these constructs, ensures proper line breaks when arguments exceed the configured line length, and respects the \prefer\_compact\ and \bracket\_spacing\ configuration options for tighter or more spaced-out formatting.

crates/fmt/testdata/EmitStatement · high confidence

The linter module now exposes a \Linter\ trait that integrates with the Solar compiler framework, allowing configured lints to run against an already parsed compiler instance. This change brings support for project-wide linting passes via \ProjectLintPass\ and \ProjectLintContext\, as well as late-stage linting capabilities through \LateLintPass\ and \LateLintVisitor\. Users benefit from a unified interface for language-specific linting that leverages Solar's semantic analysis and suggestion infrastructure.

crates/lint/src/linter · high confidence

The fuzzing engine now includes a dedicated \FuzzError\ enum to explicitly handle \vm.assume\ rejections (including limits on excessive rejects) and integrates this into the proptest \Reason\ flow. Additionally, a new \Fuzzer\ inspector has been added to the fuzzing pipeline to observe and buffer sub-calls (recording depth, caller, target, calldata, and value) for corpus seeding, while also capturing mapping slot access hashes to support storage slot sampling during invariant tests.

crates/evm/fuzz/src · high confidence

The invariant executor logic has been restructured into distinct modules (\campaign\, \error\, \replay\, \result\, \shrink\) to improve maintainability and separate concerns. The new \campaign\ module introduces \InvariantCampaignSpec\ and \InvariantWorkerPlan\ to explicitly partition logical runs across parallel workers, while \InvariantCampaignState\ manages shared atomic metrics and cancellation. The \error\ module adds \HandlerAssertionFailure\ to deduplicate and track handler-side assertion bugs by \(reverter, selector)\ site, and \InvariantRunCtx\ centralizes revert reason decoding. The \replay\ module provides dedicated functions to replay call sequences for collecting logs, traces, and coverage, and to shrink failing sequences. The \result\ module defines \InvariantFuzzTestResult\ with fields for handler errors, optimization best values, and metrics, and introduces \did\_fail\_on\assert\ to detect assertion failures from various sources (Solidity \assert\, \vm.assert\\, global fail slot). The \shrink\ module implements \SequenceShrink\ and \ShrinkRun\ to manage the shrinking process with attempt limits and candidate deduplication.

crates/evm/evm/src/executors/invariant · high confidence

The \forge\ CLI commands in \crates/forge/src/cmd\ (including \bind\, \bind-json\, \build\, \cache\, \clone\, \compiler\, \config\, \coverage\, and \create\) have been migrated to use a new structured output channel contract system. This change replaces the previous ad-hoc printing logic with a unified, structured output mechanism, improving consistency and reliability of command results. The migration also integrates the Solar compiler and linting framework into these commands, enhancing compilation and analysis capabilities.

crates/forge/src/cmd · high confidence

The internal testing infrastructure has been reorganized into the new \crates/test-utils\ crate. This change consolidates previously scattered test helpers into a dedicated module, introducing new source files for Etherscan interactions (\etherscan.rs\), external test execution (\ext.rs\), file locking (\fd\_lock.rs\), test filtering (\filter.rs\), project and command setup (\prj.rs\), RPC endpoint management (\rpc.rs\), script testing (\script.rs\), UI test running (\ui\_runner.rs\), and general utilities (\util.rs\). Users running tests will benefit from this structural consolidation, which includes updated tracing initialization, refined RPC URL rotation logic, and improved handling of global test templates and compilation locks.

crates/test-utils · high confidence

The \foundryup\ installation script has been replaced by a Rust-based installer. The existing bash script now acts as a one-time bootstrap that downloads, validates, and atomically replaces itself with the new Rust binary, ensuring a seamless upgrade for users. A deprecated \foundryup/install\ entrypoint remains for backward compatibility but now warns users to use the canonical installer URL. Comprehensive tests have been added to verify the bootstrap process, including loop guards, download failures, and binary validation.

foundryup · high confidence

Anvil introduces a new \BlockListener\ component and a \TaskManager\ API in \crates/anvil/src/tasks\ to handle block events more reliably. The \BlockListener\ ensures that when multiple new blocks arrive while a previous task is still running, the system waits for the active task to finish before processing the latest block, effectively coalescing updates. The \TaskManager\ exposes methods like \spawn\_reset\_on\_new\_polled\_blocks\ and \spawn\_reset\_on\_subscribed\_blocks\ to automatically reset the forked provider state when new blocks are detected, and \spawn\_blocking\ now returns a \JoinHandle\ for better task control.

crates/anvil/src/tasks · high confidence

The Anvil server has been refactored into a new modular structure under \crates/anvil/server\, introducing dedicated modules for configuration, error handling, request processing, and transport layers (HTTP, WebSocket, and IPC). This change adds a \--no-request-size-limit\ CLI option to disable the default 2MB request body size limit, improves JSON-RPC compliance by properly executing notifications and handling malformed IPC framing, and standardizes error responses. The new architecture separates concerns into \config.rs\, \handler.rs\, \ipc.rs\, \ws.rs\, and \pubsub.rs\, providing a cleaner foundation for RPC handling while maintaining backward compatibility with existing HTTP and WebSocket endpoints.

crates/anvil/server · high confidence

The \crates/fmt/src/pp\ directory now contains a new pretty-printing engine, introducing a structured algorithm with a \Printer\ that manages tokens (strings, breaks, and block boundaries) via a ring buffer. This change adds new modules (\convenience.rs\, \helpers.rs\, \ring.rs\) to support features like consistent/inconsistent breaking, visual alignment, and hard breaks, effectively replacing or augmenting the previous formatting logic in this location with a more robust, state-driven printer.

crates/fmt/src/pp · high confidence

The Anvil server infrastructure has been restructured to separate concerns, introducing dedicated \HttpEthRpcHandler\ and \PubSubEthRpcHandler\ modules to manage JSON-RPC requests and WebSocket subscriptions, while merging these with a new Beacon REST API router. This change consolidates the server setup logic in \mod.rs\ and explicitly supports subscription types such as logs, new heads, pending transactions, transaction receipts, and syncing within the new handler architecture.

crates/anvil/src/server · high confidence

The formatter in \crates/fmt\ has been rewritten to use the Solar parser instead of the previous implementation. This change introduces a two-pass formatting algorithm that verifies idempotency (ensuring the output remains unchanged after a second formatting pass) and provides a new \DiagnosticsResult\ type to distinguish between successful formatting, warnings, and errors. Users will benefit from more robust parsing and consistent formatting behavior, although this is a significant internal shift in how the formatter operates.

crates/fmt/src · high confidence

The documentation generation engine has been completely rewritten to use the Solar compiler instead of Solang, and the output site is now scaffolded using the Vocs static site generator. This change introduces a new rendering pipeline that produces MDX pages, adds support for implicit NatSpec inheritance from base members, and enables configuration of Git source links and deployment tables. The new system also improves cross-reference resolution, preserves NatSpec characters in fenced code blocks, and handles external library documentation inclusion.

crates/doc/src · high confidence

The coverage analysis in \crates/evm/coverage\ has been rewritten to use the Solar compiler frontend for AST/HIR traversal instead of the previous method. This new implementation introduces a \SourceVisitor\ to collect coverage items, an \anchors\ module to map those items to specific bytecode instructions using source maps, and a \LineCoverageCollector\ inspector to record execution hits. The change also adds support for coverage on empty special functions (constructors, receive, fallback) via execution-based anchors and improves branch handling for ternary operators and nested structures.

crates/evm/coverage · high confidence

The formatter in the \crates/fmt\ crate has been rewritten using a new structured algorithm (Solar), introducing updated formatting behavior for Solidity code. This change adds support for configurable quote styles (default, single, and preserve) for string and hex literals, as demonstrated by the new test data in \LiteralExpression\ and \YulStrings\. It also refines the formatting of mapping types, including better handling of long type names and comments within mapping declarations, and adjusts trailing comma placement in function signatures and return statements.

(repo-wide) · high confidence

The TUI crate now provides a unified application runner that automatically detects whether the environment supports an interactive terminal (checking for CI, stdin, and stdout terminal status) and falls back to line-oriented output when it does not. Additionally, the terminal state is now reliably restored even if the application panics, preventing the user's terminal from being left in a broken raw mode state.

crates/tui · high confidence

The formatter now applies consistent, stable formatting rules to Solidity array expressions and function types. For array literals and slices, the formatter correctly handles multiline layouts, preserves comments within brackets, and manages line breaks for long variable names in slice indices. For function types, the formatter standardizes parameter spacing, return type declarations, and assembly block indentation, ensuring that code like \new uint256\\\ and function signatures with complex return types are formatted uniformly.

crates/fmt/testdata/ArrayExpressions · high confidence

The symbolic execution engine in the EVM runtime has been restructured to improve performance and correctness. Expression nodes are now hash-consed, meaning structurally identical expressions share the same memory representation, which reduces memory usage and speeds up equality checks. A new context (\SymCx\) manages this hash-consing and caches common constants like zero, one, and boolean true/false. Boolean expressions are handled via a dedicated \SymBoolExpr\ type with optimized comparison and constant-folding logic. Model evaluation is now memoized to avoid redundant computations when evaluating constraints against solver models. Additionally, storage mapping keys are now explicitly tracked and compared, improving the accuracy of symbolic state analysis for complex storage layouts.

crates/evm/symbolic/src/runtime/expr · high confidence

The \crates/evm/abi\ crate now includes a regenerated \Console.json\ ABI definition that adds support for new \log\ function signatures, including variants accepting \bytes10\, \bytes11\, \bytes25\, \bytes27\, \bytes29\, \bytes19\, \bytes16\, \bytes12\, \bytes9\, \bytes8\, \bytes7\, \bytes3\, and \bytes1\ types. This update aligns the local ABI with the latest Hardhat console logging capabilities, allowing developers to use these extended logging formats in their smart contracts.

crates/evm/abi · high confidence

The Yul formatter test data in crates/fmt/testdata/Yul has been updated with new expected output files (fmt.sol) and original input files (original.sol). These changes reflect the application of the new structured formatting algorithm, including specific behaviors such as keeping inline if statements within assembly blocks, handling ternary operators in size estimation, and applying the configured number underscore style (thousands separators). Users will see these formatting styles applied when running the formatter on Yul code.

crates/fmt/testdata/Yul · high confidence

The \forge init\ command now includes a \.gitignoreTemplate\ and a \README.md\ in the generated project directory. The \.gitignoreTemplate\ adds standard exclusions for compiler outputs (\cache/\, \out/\), development logs, documentation, and environment files, while preserving necessary broadcast logs. The \README.md\ provides an overview of Foundry's components (Forge, Cast, Anvil, Chisel) and lists common usage commands for building, testing, formatting, and deploying.

crates/forge/assets · high confidence

The default Solidity and Vyper project templates now include updated CI workflow files that pin GitHub Actions to specific commit hashes (e.g., actions/checkout@v7.0.0) and explicitly set minimal permissions (contents: read) to improve security. The Vyper template additionally includes steps to set up Python and install the Vyper compiler (v0.4.3) before running Forge tests, ensuring the CI environment is correctly configured for Vyper projects.

crates/forge/assets/solidity, crates/forge/assets/vyper · high confidence

The formatter now applies consistent styling to Solidity try/catch blocks, including standardizing whitespace around return types, handling multi-line return signatures, and managing comments within catch clauses. This change ensures that try/catch structures are formatted uniformly, regardless of how they were originally written.

crates/fmt/testdata/TryStatement · high confidence

The formatter test suite for function definitions has been updated to reflect refined multiline formatting rules. New test fixtures (\all-params\, \params-always\, \params-multi\) and modifications to existing ones verify that the \multiline\_func\_header\ configuration correctly splits parameters onto separate lines under specific conditions, such as when using the \all\_params\ mode (which splits even single-parameter functions) or the \params\_first\_multi\ mode. These changes ensure the formatter consistently applies line breaks to function signatures based on the configured multiline strategy.

crates/fmt/testdata/FunctionDefinition · high confidence

The formatter now applies consistent spacing and line-break rules to return statements, handling empty returns, single values, multiple values, and method chains. This ensures that code like \return 0x00;\ or multi-line tuple returns is formatted uniformly, improving readability and consistency across Solidity source files.

crates/fmt/testdata/ReturnStatement · high confidence

The Solidity/Yul formatter no longer crashes when processing inline assembly blocks containing switch statements, for loops, or nested if-statements with multiple body statements. Previously, these constructs caused the formatter to fail; they are now formatted correctly with proper indentation and line breaks, while simpler single-statement blocks remain inlined as before.

crates/fmt/testdata/YulInlineBlock · high confidence

The formatter now correctly handles function definitions when the \multiline\_func\_header\ setting is set to \all\ and the line length is configured to 120 characters. Previously, complex function signatures with multiple parameters and return types were not formatted as expected in this specific configuration. This fix ensures that function headers are properly split across multiple lines to respect the line length limit, improving code readability for users with these specific formatting rules.

crates/fmt/testdata/ReprosFunctionDefs · high confidence

The formatter now correctly handles cases where a function attribute comment (e.g., \/\* @use-src ... \*/\) is followed by other comments or line breaks. Previously, blank lines might have been incorrectly inserted or preserved after such attributes; the fix ensures consistent formatting by dropping unnecessary blank lines after function attribute comments, as demonstrated in the new test data for \FnAttributeComment\.

crates/fmt/testdata/FnAttributeComment · high confidence

The formatter now correctly formats function definitions that return function types, collapsing the return signature onto fewer lines (e.g., \returns (function() internal pure returns (uint256))\ instead of spreading it across multiple lines). Additionally, it properly respects \forgefmt: disable-next-line\ comments, ensuring that code marked for exclusion is not reformatted.

crates/fmt/testdata/FunctionDefinitionWithFunctionReturns · high confidence

The formatter now correctly handles indentation when Solidity calls with named arguments are chained across multiple lines. Previously, nested or chained named-call arguments could suffer from double indentation or incorrect nesting levels; the update ensures that the argument list is indented consistently relative to the call chain, preserving user intent for long expressions and boundary cases.

crates/fmt/testdata/NamedCallArgsInChain · high confidence

The formatter now correctly keeps struct field access on the same line when it follows a function call with named arguments, resolving an issue where the field access was incorrectly split to a new line. This ensures that expressions like \\_lzSend({...}).guid\ remain on a single line, improving code readability for Solidity contracts using named arguments in function calls.

crates/fmt/testdata/StructFieldAccess · high confidence

The formatter now correctly handles ternary operators and complex expressions, ensuring proper line breaks and indentation. Specifically, it prevents double-indentation in complex ternary expressions and accounts for ternary operators when estimating line length, resulting in cleaner and more readable Solidity code.

crates/fmt/testdata/IfStatement2 · high confidence

The formatter's handling of \forgefmt: disable\ directives has been refined to better preserve source code structure. Specifically, comments appearing immediately before a disabled item are now kept in place, and spacing between items within a disabled region is maintained. Additionally, the logic for determining which lines are affected by \disable-next-line\ and \disable-next-item\ directives has been corrected to ensure the first and last block lines are handled accurately, preventing unintended formatting changes in these edge cases.

crates/fmt/testdata/InlineDisable · high confidence

The formatter now correctly preserves line comments within complex Solidity structures, specifically inside mapping type definitions (e.g., comments on keys, values, or after the arrow) and within tuple assignments (e.g., comments preceding omitted elements). This ensures that developer annotations are not lost or misplaced during formatting.

crates/fmt/testdata/LineComments · high confidence

The formatter now consistently handles indentation for multiline block comments (/\* ... \*/) in Solidity files. Previously, comments with irregular or mixed indentation were not normalized; the formatter now aligns the continuation lines of these comments relative to the opening delimiter, ensuring consistent and readable output across different coding styles (including tab-based formatting).

crates/fmt/testdata/MixedBlockComments · high confidence

1 commit adding/updating tests in crates/cast/tests/fixtures/safe; Add comprehensive CLI test coverage for cast commands; Add symbolic benchmark suite and gas-report fixtures; Add test data for formatting non-keyword identifiers; Add test suite for cheatcode behavior and configuration; Added CLI integration tests for forge test; Added CLI tests for backtrace, bind, bind-json, and build commands; Added REPL integration tests for Chisel session management and output; Added comprehensive invariant testing E2E tests; Added deterministic replay tests for Base and Tempo EVM networks; Added formatter snapshot tests for layout and comment preservation; Added formatter test cases for Solidity if statements; Added formatter test data for doc comments and unit expressions; Added integration tests for Anvil core functionality and APIs; Added regression test fixtures for formatter edge cases; Added symbolic parity tests against standard fuzzer corpora; Added test cases for complex Solidity call formatting edge cases; Added test cases for dangling-else brace preservation; Added test cases for long if-statement conditions and multiline calls; Added test cases for while statement formatting; Added test coverage for nested named call argument chains; Added test data for new Solidity lints; Added test fixtures for ERC-20, ERC-2612, ERC-4626, and storage layout; Added test fixtures for cheatcode failure scenarios and Base EVM support; Added test fixtures for contract definition formatting; Added test for verified proxy fallback behavior; Added tests for BAL prefill cache logic in fork backend; Added tests for Solidity mutation mutators; Formatter test data for block comments with function signatures added; Formatter test data for block comments with tab indentation support; Formatter test data for comment handling and wrapping; Formatter test data for import directive options; Formatter test data for variable assignment edge cases; Introduce structured cheatcode specification types; Solidity formatter test data for new language features and formatting rules; Updated formatter test data for enum and struct definitions; Updated formatter test data for enum variants; Updated formatter test data for for-statement edge cases; Updated formatter test data for function calls and new expressions; Updated formatter test data for function types and new expressions; Updated formatter test data for named function calls and revert statements; Updated formatter test data for variable definitions; Updated operator expression formatting test data.

This release includes routine dependency maintenance across 47 manifests, featuring weekly \cargo update\ cycles and targeted bumps for key libraries such as \alloy\, \revm\, \ethers\, \svm\, \soldeer\, and \solar\. Additionally, \rustls-webpki\ has been updated to address security advisory RUSTSEC-2026-0098, and \crossbeam-epoch\ has been bumped to resolve RUSTSEC-2026-0204.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 80 → 66 (-13.5)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 81 → 81 (-0.1)
• Architecture 97 → 93 (-3.4)
• Maturity 76 → 66 (-9.9)
• Readiness 88 → 68 (-19.5)
• Security 87 → 90 (+2.3)
• Event-Driven 80 → 80 (+0.0)
• Performance 60 (new)

• Backend::do_mine_block (cognitive 17) (crates/anvil/src/eth/backend/mem/mod.rs)
• BytecodeDependencyCollector::visit_stmt (cognitive 16) (crates/common/src/preprocessor/deps.rs)
• Change coupling clique: eth.rs, op.rs, tempo.rs (crates/evm/core/src/evm/eth.rs)
• Change coupling: api.rs ↔ cheats.rs (crates/anvil/src/eth/api.rs)
• Change coupling: creation_code.rs ↔ abi.rs (crates/cast/src/cmd/creation_code.rs)
• ClassTooLong: Backend (crates/anvil/src/eth/backend/mem/mod.rs)
• ClassTooLong: CastSubcommand (crates/cast/src/opts.rs)
• ClassTooLong: ConstraintContext (crates/evm/symbolic/src/runtime/solver/opt.rs)
• ClassTooLong: SmtLibSubprocessSolver (crates/evm/symbolic/src/runtime/solver.rs)
• ConstraintContext::normalize_bool (cyclomatic 16) (crates/evm/symbolic/src/runtime/solver/opt.rs)
• ConstraintContext::upper_bound_constraint (cognitive 20) (crates/evm/symbolic/src/runtime/solver/opt.rs)
• ConstraintContext::upper_bound_constraint (cyclomatic 21) (crates/evm/symbolic/src/runtime/solver/opt.rs)
• Documentation: no contributor guidance
• Documentation: no installation or build instructions
• Documentation: no project overview
• Documentation: no usage examples
• Duplicated block (10 lines × 2) (crates/evm/symbolic/src/runtime/solver/hard_arith_fallback.rs)
• Duplicated block (10 lines × 2) (crates/forge/src/cmd/selectors.rs)
• Duplicated block (10–13 lines × 2) (crates/anvil/src/eth/backend/mem/mod.rs)
• Duplicated block (11–12 lines × 2) (crates/anvil/src/eth/backend/mem/mod.rs)
• …and 120 more

• Ambiguous naming: evm_set_time and evm_set_next_block_timestamp appear to perform similar time-manipulation operations. It is unclear if one sets the global clock and the other sets the next block's timestamp, or if they are redundant aliases.
• Analyzer::reads (cyclomatic 20) (crates/lint/src/sol/gas/write_after_write.rs)
• Backend::apply_genesis (cognitive 25) (crates/anvil/src/eth/backend/mem/mod.rs)
• Backend::apply_genesis (cyclomatic 16) (crates/anvil/src/eth/backend/mem/mod.rs)
• Backend::do_mine_block_locked (cognitive 20) (crates/anvil/src/eth/backend/mem/mod.rs)
• Backend::do_mine_block_locked (cyclomatic 17) (crates/anvil/src/eth/backend/mem/mod.rs)
• Backend::parse_transaction_request (cognitive 16) (crates/anvil/src/eth/backend/mem/mod.rs)
• Backend::transact (cognitive 17) (crates/evm/core/src/backend/mod.rs)
• Backend::validate_pool_transaction (cyclomatic 20) (crates/anvil/src/eth/backend/mem/mod.rs)
• BytecodeDependencyCollector::visit_expr (cognitive 42) (crates/common/src/preprocessor/deps.rs)
• BytecodeDependencyCollector::visit_expr (cyclomatic 22) (crates/common/src/preprocessor/deps.rs)
• Change coupling: eth.rs ↔ op.rs (crates/evm/core/src/evm/eth.rs)
• Change coupling: eth.rs ↔ tempo.rs (crates/evm/core/src/evm/eth.rs)
• ClassTooLong: ConstraintContext (crates/evm/symbolic/src/runtime/solver/normalize/mod.rs)
• ClassTooLong: FoundryTransactionRequest (crates/primitives/src/transaction/request.rs)
• ClassTooLong: SmtLibSubprocessSolver (crates/evm/symbolic/src/runtime/solver/mod.rs)
• ConstraintContext::bounded_bool_value (cognitive 21) (crates/evm/symbolic/src/runtime/solver/normalize/mod.rs)
• ConstraintContext::normalize_bool (cyclomatic 20) (crates/evm/symbolic/src/runtime/solver/normalize/mod.rs)
• ConstraintContext::normalize_signed_add_comparison (cognitive 21) (crates/evm/symbolic/src/runtime/solver/normalize/mod.rs)
• ConstraintContext::normalize_signed_add_comparison (cyclomatic 18) (crates/evm/symbolic/src/runtime/solver/normalize/mod.rs)
• …and 145 more

• 240 commits — 110 feature/other, 130 fixes

• crates/anvil — 43 commits
• crates/evm — 34 commits
• (root) — 32 commits
• crates/forge — 27 commits
• crates/cast — 22 commits
• .github/workflows — 15 commits
• crates/common — 11 commits
• crates/fmt — 10 commits
• crates/cheatcodes — 9 commits
• crates/lint — 6 commits
• .github/scripts — 3 commits
• crates/config — 2 commits
• crates/script — 2 commits
• docs/dev — 2 commits
• editors/vscode — 2 commits
• editors/zed — 2 commits
• .changelog/anvil-safe-finalized-non-zero-genesis.md — 1 commit
• .changelog/bump-alloy-2.5.0.md — 1 commit
• .changelog/flashloan-loop-repeated-pull.md — 1 commit
• .changelog/nested-broadcast-nonces.md — 1 commit

• fix: fix(anvil): allow future-start log filters (#17122)
• fix: fix(anvil): bound fork identity probe latency (#16833)
• fix: fix(anvil): correct trace_* request defaults (#17078)
• fix: fix(anvil): derive deposit nonce from pre-execution state (#16940)
• fix: fix(anvil): drop dependent transactions (#17021)
• fix: fix(anvil): drop queued nonce dependents (#17028)
• fix: fix(anvil): estimate precompile gas correctly (#17043)
• fix: fix(anvil): fix latest read isolation (#16368)
• fix: fix(anvil): preserve Tempo fork account state (#16811)
• fix: fix(anvil): prune stale mappings on state load (#17064)
• fix: fix(anvil): reject zero reorg depth with transactions (#16951)
• fix: fix(anvil): report removed logs on revert (#17020)
• fix: fix(anvil): resolve block tags against genesis number (#16923)
• fix: fix(anvil): restore next timestamp on revert (#17065)
• fix: fix(anvil): restore txpool on snapshot revert (#17044)
• fix: fix(anvil): restrict config export permissions (#17026)
• fix: fix(anvil): return null from trace_transaction for an unknown hash (#17089)
• fix: fix(anvil): rewind Monad profile on rollback (#16810)
• fix: fix(anvil): run fork backend handler on its own thread (#17058)
• fix: fix(anvil): safe/finalized tags assume genesis is block 0 (#16883)
• …and 220 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

foundry-rs/foundry was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.