Update hevm to 9ba5e52fc7ec7ae6f7f3a25d5ee426625d2aa9d (#1487)

* Update `hevm` to `9ba5e52fc7ec7ae6f7f3a25d5ee426625d2aa9d`

* CLAUDE.md: document import order

* tree-wide: sort imports

* Fix symbolic tests after hevm update

* update the fetching code for the new hevm

* improved rpc fetching

---------

Co-authored-by: gustavo-grieco <gustavo.grieco+github@gmail.com>

Author: elopez

CLAUDE.md

@@ -72,6 +72,27 @@ cabal --enable-profiling run echidna -- contract.sol +RTS -p -s
 - Main config types in `lib/Echidna/Types/Config.hs`
 - Supports campaign, UI, transaction, and Solidity-specific settings
 
+## Code Style
+
+### Import Organization
+Imports should be organized into three groups, separated by blank lines, with imports **alphabetically ordered** within each group:
+
+1. **System and 3rd-party imports**: Standard library and external dependencies (alphabetically ordered)
+2. **EVM imports**: Modules from `hevm` (e.g., `EVM.*`, `EVM.Types.*`) (alphabetically ordered)
+3. **Echidna imports**: Internal modules from this project (e.g., `Echidna.*`) (alphabetically ordered)
+
+Example:
+```haskell
+import Control.Monad (when)
+import Data.Text (Text)
+
+import EVM (VM)
+import EVM.Types (Addr)
+
+import Echidna.ABI (genAbiCall)
+import Echidna.Types.Campaign (Campaign)
+```
+
 ## Important Development Notes
 
 - The project uses GHC2021 language standard with several extensions enabled

flake.nix

@@ -54,8 +54,8 @@
           (pkgs.haskellPackages.callCabal2nix "hevm" (pkgs.fetchFromGitHub {
             owner = "ethereum";
             repo = "hevm";
-            rev = "0d9e2744903d160b175cd9e727660b493d9fac6f";
-            sha256 = "sha256-SYqhjlvGKdWf55JjGZ8BPFtXqbkL81os5FB9j4Nj40A=";
+            rev = "9ba5e52fc7ec7ae6f7f3a25d5ee426625d2aa9d3";
+            sha256 = "sha256-5ZWsXtmZsMw2el4cuR9T+qrySTra6Lcaty/RrLOQ2hU=";
           }) { secp256k1 = pkgs.secp256k1; })
           ([
             pkgs.haskell.lib.compose.dontCheck

lib/Echidna.hs

@@ -3,41 +3,40 @@ module Echidna where
 import Control.Concurrent (newChan)
 import Control.Monad.Catch (MonadThrow(..))
 import Control.Monad.IO.Class (liftIO)
-import Control.Monad.ST (RealWorld)
 import Data.IORef (newIORef)
 import Data.List (find, nub)
 import Data.List.NonEmpty (NonEmpty)
 import Data.List.NonEmpty qualified as NE
 import Data.Map.Strict qualified as Map
 import Data.Maybe (mapMaybe)
 import Data.Set qualified as Set
+import Data.Text qualified as T
 import System.FilePath ((</>))
+import System.IO (stderr, hPutStrLn)
 
 import EVM (cheatCode)
 import EVM.ABI (AbiValue(AbiAddress))
 import EVM.Dapp (dappInfo)
+import EVM.Effects (TTY(..), ReadConfig(..), defaultConfig)
 import EVM.Fetch qualified
 import EVM.Solidity (BuildOutput(..), Contracts(Contracts), Method(..), Mutability(..), SolcContract(..))
 import EVM.Types hiding (Env)
-import EVM.Effects (TTY(..), ReadConfig(..), defaultConfig)
-import Data.Text qualified as T
-import System.IO (stderr, hPutStrLn)
 
 import Echidna.ABI
 import Echidna.Onchain as Onchain
 import Echidna.Output.Corpus
-import Echidna.SourceMapping (findSrcForReal)
-import Echidna.SourceAnalysis.Slither
 import Echidna.Solidity
+import Echidna.SourceAnalysis.Slither
+import Echidna.SourceMapping (findSrcForReal)
 import Echidna.SymExec.Symbolic (forceAddr)
 import Echidna.Types.Campaign
 import Echidna.Types.Config
 import Echidna.Types.Random
+import Echidna.Types.Signature (ContractName)
 import Echidna.Types.Solidity
+import Echidna.Types.Test (EchidnaTest)
 import Echidna.Types.Tx
 import Echidna.Types.World
-import Echidna.Types.Test (EchidnaTest)
-import Echidna.Types.Signature (ContractName)
 
 -- | This function is used to prepare, process, compile and initialize smart contracts for testing.
 -- It takes:
@@ -56,7 +55,7 @@ prepareContract
   -> BuildOutput
   -> Maybe ContractName
   -> Seed
-  -> IO (VM Concrete RealWorld, Env, GenDict)
+  -> IO (VM Concrete, Env, GenDict)
 prepareContract cfg solFiles buildOutput selectedContract seed = do
   let solConf = cfg.solConf
       (Contracts contractMap) = buildOutput.contracts

lib/Echidna/ABI.hs

@@ -7,19 +7,19 @@ import Data.Binary.Put (runPut, putWord32be)
 import Data.BinaryWord (unsignedWord)
 import Data.Bits (bit)
 import Data.Bool (bool)
-import Data.ByteString.Lazy as BSLazy (toStrict)
 import Data.ByteString (ByteString)
 import Data.ByteString qualified as BS
+import Data.ByteString.Lazy as BSLazy (toStrict)
 import Data.DoubleWord (Int256, Word256)
 import Data.Foldable (toList)
-import Data.Map (Map)
-import Data.Map qualified as Map
-import Data.Set (Set)
-import Data.Set qualified as Set
 import Data.List (intercalate)
 import Data.List.NonEmpty (NonEmpty)
 import Data.List.NonEmpty qualified as NE
+import Data.Map (Map)
+import Data.Map qualified as Map
 import Data.Maybe (fromMaybe, catMaybes)
+import Data.Set (Set)
+import Data.Set qualified as Set
 import Data.Text (Text)
 import Data.Text qualified as T
 import Data.Text.Encoding (encodeUtf8)

lib/Echidna/Campaign.hs

@@ -11,16 +11,15 @@ import Control.Monad.Random.Strict (MonadRandom, RandT, evalRandT)
 import Control.Monad.Reader (MonadReader, asks, liftIO, ask)
 import Control.Monad.State.Strict
   (MonadState(..), StateT(..), gets, MonadIO, modify')
-import Control.Monad.ST (RealWorld)
 import Control.Monad.Trans (lift)
 import Data.Binary.Get (runGetOrFail)
 import Data.ByteString.Lazy qualified as LBS
-import Data.IORef (readIORef, atomicModifyIORef', writeIORef)
 import Data.Foldable (foldlM)
+import Data.IORef (readIORef, atomicModifyIORef', writeIORef)
 import Data.List qualified as List
 import Data.List.NonEmpty qualified as NEList
-import Data.Map qualified as Map
 import Data.Map (Map, (\\))
+import Data.Map qualified as Map
 import Data.Maybe (isJust, mapMaybe, fromJust)
 import Data.Set (Set)
 import Data.Set qualified as Set
@@ -32,8 +31,8 @@ import System.Random (mkStdGen)
 import EVM (cheatCode)
 import EVM.ABI (getAbi, AbiType(AbiAddressType, AbiTupleType), AbiValue(AbiAddress, AbiTuple), abiValueType)
 import EVM.Dapp (DappInfo(..))
-import EVM.Types hiding (Env, Frame(state), Gas)
 import EVM.Solidity (SolcContract(..), Method(..))
+import EVM.Types hiding (Env, Frame(state), Gas)
 
 import Echidna.ABI
 import Echidna.Events (extractEventValues)
@@ -42,15 +41,15 @@ import Echidna.Mutator.Corpus
 import Echidna.Shrink (shrinkTest)
 import Echidna.Solidity (chooseContract)
 import Echidna.SymExec.Common (extractTxs, extractErrors)
-import Echidna.SymExec.Symbolic (forceAddr)
 import Echidna.SymExec.Exploration (exploreContract, getTargetMethodFromTx, getRandomTargetMethod)
+import Echidna.SymExec.Symbolic (forceAddr)
 import Echidna.SymExec.Verification (verifyMethod, isSuitableToVerifyMethod)
 import Echidna.Test
 import Echidna.Transaction
 import Echidna.Types.Campaign
+import Echidna.Types.Config
 import Echidna.Types.Corpus (Corpus, corpusSize)
 import Echidna.Types.Coverage (coverageStats)
-import Echidna.Types.Config
 import Echidna.Types.Random (rElem)
 import Echidna.Types.Signature (FunctionName)
 import Echidna.Types.Test
@@ -73,7 +72,7 @@ isSuccessful =
 -- contain minimized corpus without sequences that didn't increase the coverage.
 replayCorpus
   :: (MonadIO m, MonadThrow m, MonadRandom m, MonadReader Env m, MonadState WorkerState m)
-  => VM Concrete RealWorld -- ^ VM to start replaying from
+  => VM Concrete -- ^ VM to start replaying from
   -> [(FilePath, [Tx])] -- ^ corpus to replay
   -> m ()
 replayCorpus vm txSeqs =
@@ -93,7 +92,7 @@ runWorker
   => WorkerType
   -> StateT WorkerState m ()
   -- ^ Callback to run after each state update (for instrumentation)
-  -> VM Concrete RealWorld -- ^ Initial VM state
+  -> VM Concrete -- ^ Initial VM state
   -> GenDict -- ^ Generation dictionary
   -> Int     -- ^ Worker id starting from 0
   -> [(FilePath, [Tx])]
@@ -110,7 +109,7 @@ runSymWorker
   :: (MonadIO m, MonadThrow m, MonadReader Env m)
   => StateT WorkerState m ()
   -- ^ Callback to run after each state update (for instrumentation)
-  -> VM Concrete RealWorld -- ^ Initial VM state
+  -> VM Concrete -- ^ Initial VM state
   -> GenDict -- ^ Generation dictionary
   -> Int     -- ^ Worker id starting from 0
   -> [(FilePath, [Tx])]
@@ -324,7 +323,7 @@ runFuzzWorker
   :: (MonadIO m, MonadThrow m, MonadReader Env m)
   => StateT WorkerState m ()
   -- ^ Callback to run after each state update (for instrumentation)
-  -> VM Concrete RealWorld -- ^ Initial VM state
+  -> VM Concrete -- ^ Initial VM state
   -> GenDict -- ^ Generation dictionary
   -> Int     -- ^ Worker id starting from 0
   -> [(FilePath, [Tx])]
@@ -454,9 +453,9 @@ randseq deployedContracts = do
 -- Returns resulting VM, as well as whether any new coverage was found.
 callseq
   :: (MonadIO m, MonadThrow m, MonadRandom m, MonadReader Env m, MonadState WorkerState m)
-  => VM Concrete RealWorld
+  => VM Concrete
   -> [Tx]
-  -> m (VM Concrete RealWorld, Bool)
+  -> m (VM Concrete, Bool)
 callseq vm txSeq = do
   env <- ask
   -- First, we figure out whether we need to execute with or without coverage
@@ -524,7 +523,7 @@ callseq vm txSeq = do
   -- know the return type for each function called. If yes, try to parse the
   -- return value as a value of that type. Returns a 'GenDict' style Map.
   returnValues
-    :: [(Tx, VMResult Concrete RealWorld)]
+    :: [(Tx, VMResult Concrete)]
     -> (FunctionName -> Maybe AbiType)
     -> Map AbiType (Set AbiValue)
   returnValues txResults returnTypeOf =
@@ -555,7 +554,7 @@ callseq vm txSeq = do
       getTupleVector _ = error "Not a tuple!"
 
   -- | Add transactions to the corpus, discarding reverted ones
-  addToCorpus :: Int -> [(Tx, VMResult Concrete RealWorld)] -> Corpus -> Corpus
+  addToCorpus :: Int -> [(Tx, VMResult Concrete)] -> Corpus -> Corpus
   addToCorpus n res corpus =
     if null rtxs then corpus else Set.insert (n, rtxs) corpus
     where rtxs = fst <$> res
@@ -564,8 +563,8 @@ callseq vm txSeq = do
 -- executed, saving the transaction if it finds new coverage.
 execTxOptC
   :: (MonadIO m, MonadReader Env m, MonadState WorkerState m, MonadThrow m)
-  => VM Concrete RealWorld -> Tx
-  -> m (VMResult Concrete RealWorld, VM Concrete RealWorld)
+  => VM Concrete -> Tx
+  -> m (VMResult Concrete, VM Concrete)
 execTxOptC vm tx = do
   ((res, grew), vm') <- runStateT (execTxWithCov tx) vm
   when grew $ do
@@ -581,10 +580,10 @@ execTxOptC vm tx = do
 -- of transactions, constantly checking if we've solved any tests.
 evalSeq
   :: (MonadIO m, MonadThrow m, MonadRandom m, MonadReader Env m, MonadState WorkerState m)
-  => VM Concrete RealWorld -- ^ Initial VM
-  -> (VM Concrete RealWorld -> Tx -> m (result, VM Concrete RealWorld))
+  => VM Concrete -- ^ Initial VM
+  -> (VM Concrete -> Tx -> m (result, VM Concrete))
   -> [Tx]
-  -> m ([(Tx, result)], VM Concrete RealWorld)
+  -> m ([(Tx, result)], VM Concrete)
 evalSeq vm0 execFunc = go vm0 [] where
   go vm executedSoFar toExecute = do
     -- NOTE: we do reverse here because we build up this list by prepending,
@@ -627,7 +626,7 @@ findFailedTests = do
 -- | Update an open test after checking if it is falsified by the 'reproducer'
 updateOpenTest
   :: (MonadIO m, MonadThrow m, MonadRandom m, MonadReader Env m, MonadState WorkerState m)
-  => VM Concrete RealWorld -- ^ VM after applying potential reproducer
+  => VM Concrete -- ^ VM after applying potential reproducer
   -> [Tx] -- ^ potential reproducer
   -> EchidnaTest
   -> m (Maybe EchidnaTest)

lib/Echidna/Config.hs

@@ -13,8 +13,8 @@ import Data.Set qualified as Set
 import Data.Text (isPrefixOf)
 import Data.Yaml qualified as Y
 
-import EVM.Types (VM(..), W256)
 import EVM.Solvers (Solver(..))
+import EVM.Types (VM(..), W256)
 
 import Echidna.Mutator.Corpus (defaultMutationConsts)
 import Echidna.Test

lib/Echidna/Deploy.hs

@@ -15,28 +15,27 @@ import Data.Text.Encoding (encodeUtf8)
 import EVM.Solidity
 import EVM.Types hiding (Env)
 
-import Echidna.Exec (execTx, execTxWithCov)
 import Echidna.Events (extractEvents)
+import Echidna.Exec (execTx, execTxWithCov)
 import Echidna.Types.Campaign (CampaignConf(..))
 import Echidna.Types.Config (Env(..), EConfig(..))
 import Echidna.Types.Solidity (SolException(..))
 import Echidna.Types.Tx (createTx, unlimitedGasPerBlock)
-import Control.Monad.ST (RealWorld)
 
 deployContracts
   :: (MonadIO m, MonadReader Env m, MonadThrow m)
   => [(Addr, SolcContract)]
   -> Addr
-  -> VM Concrete RealWorld
-  -> m (VM Concrete RealWorld)
+  -> VM Concrete
+  -> m (VM Concrete)
 deployContracts cs = deployBytecodes' $ map (\(a, c) -> (a, c.creationCode)) cs
 
 deployBytecodes
   :: (MonadIO m, MonadReader Env m, MonadThrow m)
   => [(Addr, Text)]
   -> Addr
-  -> VM Concrete RealWorld
-  -> m (VM Concrete RealWorld)
+  -> VM Concrete
+  -> m (VM Concrete)
 deployBytecodes cs = deployBytecodes' $
   (\(a, bc) ->
     (a, fromRight (error ("invalid b16 decoding of: " ++ show bc)) $ BS16.decode $ encodeUtf8 bc)
@@ -47,8 +46,8 @@ deployBytecodes'
   :: (MonadIO m, MonadReader Env m, MonadThrow m)
   => [(Addr, ByteString)]
   -> Addr
-  -> VM Concrete RealWorld
-  -> m (VM Concrete RealWorld)
+  -> VM Concrete
+  -> m (VM Concrete)
 deployBytecodes' cs src initialVM = foldM deployOne initialVM cs
   where
   deployOne vm (dst, bytecode) = do

lib/Echidna/Events.hs

@@ -35,7 +35,7 @@ type Events = [Text]
 emptyEvents :: TreePos Empty a
 emptyEvents = fromForest []
 
-extractEvents :: Bool -> DappInfo -> VM Concrete s -> Events
+extractEvents :: Bool -> DappInfo -> VM Concrete -> Events
 extractEvents decodeErrors dappInfo vm =
   let forest = traceForest vm
   in maybeToList (decodeRevert decodeErrors vm)
@@ -78,7 +78,7 @@ extractEvents decodeErrors dappInfo vm =
       _ -> Nothing
 
 -- | Extract all non‑indexed event values emitted between two VM states.
-extractEventValues :: DappInfo -> VM Concrete s -> VM Concrete s -> Map AbiType (Set AbiValue)
+extractEventValues :: DappInfo -> VM Concrete -> VM Concrete -> Map AbiType (Set AbiValue)
 extractEventValues dappInfo vm vm' =
   let
     oldLogs = vm.logs
@@ -113,7 +113,7 @@ maybeContractNameFromCodeHash info codeHash = contractToName <$> maybeContract
   where maybeContract = snd <$> Map.lookup codeHash info.solcByHash
         contractToName c = contractNamePart c.contractName
 
-decodeRevert :: Bool -> VM Concrete s -> Maybe Text
+decodeRevert :: Bool -> VM Concrete -> Maybe Text
 decodeRevert decodeErrors vm =
   case vm.result of
     Just (VMFailure (Revert (ConcreteBuf bs))) -> decodeRevertMsg decodeErrors bs