Merge branch 'master' into fixed-sym-exec

Author: elopez

CHANGELOG.md

@@ -1,9 +1,18 @@
-## Unreleased
+## 2.2.7
 
 * feat: show which project is being fuzzed (#1381)
+* feat: keyboard navigation for the UI (Tab, PgUp, PgDown, arrows) (#1386)
+* feat: gas/s reporting on text mode (#1392)
 * ARM64 Docker containers (#1352)
+* ARM64 Linux builds (#1377)
 * Fix worker crashes when shrinking empty reproducers (#1378)
-* Upgrade `hevm` to reduce memory usage on certain scenarios (#1346)
+* Fix shrinking sometimes not progressing (#1399)
+* Fix gas accounting; it was not considering the intrinsic cost of transactions (#1392)
+* Fix issue collecting deployed contract addresses into the dictionary (#1400)
+* Improved UI responsiveness (#1387)
+* Update `hevm` to reduce memory usage on certain scenarios (#1346)
+* Update `hevm` to fix multiple deployments under `prank`ing cheatcodes (#1377)
+* Echidna is now built with GHC 9.8.4 (#1377)
 
 ## 2.2.6
 

flake.nix

@@ -55,7 +55,7 @@
           (pkgs.haskellPackages.callCabal2nix "hevm" (pkgs.fetchFromGitHub {
             owner = "ethereum";
             repo = "hevm";
-            rev = "2931f09fcbbca68911421fbe2f2f21ebebdb5332";
+            rev = "release/0.55.0";
             sha256 = "sha256-DVwQisTwgSjZQkQSn5s7ZN3SS1z2EfISA6Lw0ruUg6Y=";
           }) { secp256k1 = pkgs.secp256k1; })
           ([

lib/Echidna/ABI.hs

@@ -55,7 +55,7 @@ mkValidAbiUInt i x = if x < bit i then Just $ AbiUInt i x else Nothing
 
 makeNumAbiValues :: Integer -> [AbiValue]
 makeNumAbiValues i =
-  let l f = f <$> commonTypeSizes <*> fmap fromIntegral ([i-1..i+1] ++ [(-i)-1 .. (-i)+1])
+  let l f = f <$> commonTypeSizes <*> fmap fromIntegral ([i-3..i+3] ++ [(-i)-3 .. (-i)+3])
   in catMaybes (l mkValidAbiInt ++ l mkValidAbiUInt)
 
 makeArrayAbiValues :: ByteString -> [AbiValue]
@@ -218,7 +218,7 @@ fixAbiInt n x =
      else AbiInt n (x `mod` (2 ^ (n - 1) - 1))
 
 -- | Given a way to generate random 'Word8's and a 'ByteString' b of length l,
--- generate between 0 and 2l 'Word8's and add insert them into b at random indices.
+-- generate between 0 and 2l 'Word8's and insert them into b at random indices.
 addChars :: MonadRandom m => m Word8 -> ByteString -> m ByteString
 addChars c b = foldM withR b . enumFromTo 0 =<< rand where
   rand       = getRandomR (0, BS.length b - 1)

lib/Echidna/Campaign.hs

@@ -543,7 +543,7 @@ callseq vm txSeq = do
             _ -> Nothing
         _ -> Nothing
 
-  -- | Add transactions to the corpus discarding reverted ones
+  -- | Add transactions to the corpus, discarding reverted ones
   addToCorpus :: Int -> [(Tx, (VMResult Concrete RealWorld, Gas))] -> Corpus -> Corpus
   addToCorpus n res corpus =
     if null rtxs then corpus else Set.insert (n, rtxs) corpus
@@ -567,7 +567,7 @@ execTxOptC vm tx = do
   pure (res, vm')
 
 -- | Given current `gasInfo` and a sequence of executed transactions, updates
--- information on highest gas usage for each call
+-- information on the highest gas usage for each call
 updateGasInfo
   :: [(Tx, (VMResult Concrete RealWorld, Gas))]
   -> [Tx]
@@ -607,8 +607,8 @@ evalSeq vm0 execFunc = go vm0 [] where
         -- NOTE: we don't use the intermediate VMs, just the last one. If any of
         -- the intermediate VMs are needed, they can be put next to the result
         -- of each transaction - `m ([(Tx, result, VM)])`
-        (remaining, _vm) <- go vm' (tx:executedSoFar) remainingTxs
-        pure ((tx, result) : remaining, vm')
+        (remaining, vm'') <- go vm' (tx:executedSoFar) remainingTxs
+        pure ((tx, result) : remaining, vm'')
 
 -- | Update tests based on the return value from the given function.
 -- Nothing skips the update.

lib/Echidna/Shrink.hs

@@ -30,7 +30,7 @@ shrinkTest
 shrinkTest vm test = do
   env <- ask
   case test.state of
-    -- If we run out of tries to shrink, return the sequence as we have them
+    -- If we run out of tries to shrink, return the sequence as we have it
     Large i | i >= env.cfg.campaignConf.shrinkLimit && not (isOptimizationTest test) ->
       pure $ Just test { state = Solved }
     Large i ->
@@ -116,7 +116,7 @@ shrinkSeq vm f v txs = do
     -- | Simplify a sequence of transactions reducing the complexity of its arguments (using shrinkTx)
     -- and then reducing its sender (using shrinkSender)
     shrunk = mapM (shrinkSender <=< shrinkTx) txs
-    -- | Simplifiy a sequence of transactions randomly dropping one transaction (with uniform selection)
+    -- | Simplify a sequence of transactions randomly dropping one transaction (with uniform selection)
     shorten = (\i -> take i txs ++ drop (i + 1) txs) <$> getRandomR (0, length txs)
 
 -- | Given a transaction, replace the sender of the transaction by another one
@@ -128,6 +128,6 @@ shrinkSender x = do
   let orderedSenders = List.sort $ Set.toList senderSet
   case List.elemIndex x.src orderedSenders of
     Just i | i > 0 -> do
-      sender <- uniform (take i orderedSenders)
+      sender <- uniform (take (i+1) orderedSenders)
       pure x{src = sender}
     _ -> pure x

lib/Echidna/Solidity.hs

@@ -97,7 +97,7 @@ compileContracts solConf fp = do
     -- | OS-specific path to the "null" file, which accepts writes without storing them
     nullFilePath :: String
     nullFilePath = if os == "mingw32" then "\\\\.\\NUL" else "/dev/null"
-  -- clean up previous artifacts
+  -- clean up previous artifact files
   removeJsonFiles "crytic-export"
   mconcat . NE.toList <$> mapM compileOne fp
 

lib/Echidna/Transaction.hs

@@ -6,27 +6,29 @@ module Echidna.Transaction where
 import Optics.Core
 import Optics.State.Operators
 
-import Control.Monad (join)
+import Control.Monad (join, when)
 import Control.Monad.IO.Class (MonadIO, liftIO)
 import Control.Monad.Random.Strict (MonadRandom, getRandomR, uniform)
 import Control.Monad.Reader (MonadReader, ask)
 import Control.Monad.State.Strict (MonadState, gets, modify', execState)
 import Control.Monad.ST (RealWorld)
+import Data.ByteString qualified as BS
 import Data.Map (Map, toList)
 import Data.Maybe (catMaybes)
 import Data.Set (Set)
 import Data.Set qualified as Set
 import Data.Vector qualified as V
 
-import EVM (initialContract, loadContract, resetState)
+import EVM (ceilDiv, initialContract, loadContract, resetState)
 import EVM.ABI (abiValueType)
-import EVM.Types hiding (Env, VMOpts(timestamp, gasprice))
+import EVM.FeeSchedule (FeeSchedule(..))
+import EVM.Types hiding (Env, Gas, VMOpts(timestamp, gasprice))
 
 import Echidna.ABI
 import Echidna.Orphans.JSON ()
 import Echidna.SourceMapping (lookupUsingCodehash)
 import Echidna.SymExec.Symbolic (forceWord, forceAddr)
-import Echidna.Types (fromEVM)
+import Echidna.Types (fromEVM, Gas)
 import Echidna.Types.Config (Env(..), EConfig(..))
 import Echidna.Types.Random
 import Echidna.Types.Signature
@@ -177,25 +179,49 @@ setupTx tx@Tx{call} = fromEVM $ do
     , block = advanceBlock vm.block tx.delay
     , tx = vm.tx { gasprice = tx.gasprice, origin = LitAddr tx.src }
     }
-  case call of
-    SolCreate bc -> do
-      #env % #contracts % at (LitAddr tx.dst) .=
-        Just (initialContract (InitCode bc mempty) & set #balance (Lit tx.value))
-      modify' $ execState $ loadContract (LitAddr tx.dst)
-      #state % #code .= RuntimeCode (ConcreteRuntimeCode bc)
-    SolCall cd -> do
-      incrementBalance
-      modify' $ execState $ loadContract (LitAddr tx.dst)
-      #state % #calldata .= ConcreteBuf (encode cd)
-    SolCalldata cd -> do
-      incrementBalance
-      modify' $ execState $ loadContract (LitAddr tx.dst)
-      #state % #calldata .= ConcreteBuf cd
+  when isCreate $ do
+    #env % #contracts % at (LitAddr tx.dst) .=
+      Just (initialContract (InitCode calldata mempty) & set #balance (Lit tx.value))
+    modify' $ execState $ loadContract (LitAddr tx.dst)
+    #state % #code .= RuntimeCode (ConcreteRuntimeCode calldata)
+  when isCall $ do
+    incrementBalance
+    modify' $ execState $ loadContract (LitAddr tx.dst)
+    #state % #calldata .= ConcreteBuf calldata
+  modify' $ \vm ->
+    let intrinsicGas = txGasCost vm.block.schedule isCreate calldata
+        burned = min intrinsicGas vm.state.gas
+    in vm & #state % #gas %!~ subtract burned
+          & #burned %!~ (+ burned)
   where
     incrementBalance = #env % #contracts % ix (LitAddr tx.dst) % #balance %= (\v -> Lit $ forceWord v + tx.value)
     encode (n, vs) = abiCalldata (encodeSig (n, abiValueType <$> vs)) $ V.fromList vs
+    isCall = case call of
+      SolCall _ -> True
+      SolCalldata _ -> True
+      _ -> False
+    isCreate = case call of
+      SolCreate _ -> True
+      _ -> False
+    calldata = case call of
+      SolCreate bc -> bc
+      SolCall cd -> encode cd
+      SolCalldata cd -> cd
 
 advanceBlock :: Block -> (W256, W256) -> Block
 advanceBlock blk (t,b) =
   blk { timestamp = Lit (forceWord blk.timestamp + t)
-      , number = Lit $ forceWord blk.number + b }
+      , number = Lit (forceWord blk.number + b) }
+
+-- | Calculate transaction gas cost for Echidna Tx
+-- Adapted from HEVM's txGasCost function
+txGasCost :: FeeSchedule Gas -> Bool -> BS.ByteString -> Gas
+txGasCost fs isCreate calldata = baseCost + zeroCost + nonZeroCost
+  where
+    zeroBytes = BS.count 0 calldata
+    nonZeroBytes = BS.length calldata - zeroBytes
+    baseCost = fs.g_transaction
+      + (if isCreate then fs.g_txcreate + initcodeCost else 0)
+    zeroCost = fs.g_txdatazero * fromIntegral zeroBytes
+    nonZeroCost = fs.g_txdatanonzero * fromIntegral nonZeroBytes
+    initcodeCost = fs.g_initcodeword * fromIntegral (ceilDiv (BS.length calldata) 32)

lib/Echidna/Types/Campaign.hs

@@ -36,7 +36,7 @@ data CampaignConf = CampaignConf
   , corpusDir          :: Maybe FilePath
     -- ^ Directory to load and save lists of transactions
   , mutConsts          :: MutationConsts Integer
-    -- ^ Directory to load and save lists of transactions
+    -- ^ Mutation constants for fuzzing
   , coverageFormats    :: [CoverageFileType]
     -- ^ List of file formats to save coverage reports
   , workers            :: Maybe Word8

lib/Echidna/Types/Solidity.hs

@@ -51,7 +51,7 @@ instance Show SolException where
     NoCryticCompile        -> "crytic-compile not installed or not found in PATH. To install it, run:\n   pip install crytic-compile"
     InvalidMethodFilters f -> "Applying the filter " ++ show f ++ " to the methods produces an empty list. Are you filtering the correct functions using `filterFunctions` or fuzzing the correct contract?"
     SetUpCallFailed        -> "Calling the setUp() function failed (revert, out-of-gas, sending ether to a non-payable constructor, etc.)"
-    DeploymentFailed a t   -> "Deploying the contract " ++ show a ++ " failed (revert, out-of-gas, sending ether to an non-payable constructor, etc.):\n" ++ unpack t
+    DeploymentFailed a t   -> "Deploying the contract " ++ show a ++ " failed (revert, out-of-gas, sending ether to a non-payable constructor, etc.):\n" ++ unpack t
     OutdatedSolcVersion v  -> "Solc version " ++ toString v ++ " detected. Echidna doesn't support versions of solc before " ++ toString minSupportedSolcVersion ++ ". Please use a newer version."
 
 

lib/Echidna/UI.hs

@@ -55,6 +55,12 @@ data UIEvent =
                       (Map Addr (Map W256 (Maybe W256)))
   | EventReceived (LocalTime, CampaignEvent)
 
+-- | Gas tracking state for calculating gas consumption rate
+data GasTracker = GasTracker
+  { lastUpdateTime :: LocalTime
+  , totalGasConsumed :: Int
+  }
+
 -- | Set up and run an Echidna 'Campaign' and display interactive UI or
 -- print non-interactive output in desired format at the end
 ui
@@ -176,10 +182,14 @@ ui vm dict initialCorpus cliSelectedContract = do
       let forwardEvent ev = putStrLn =<< runReaderT (ppLogLine vm ev) env
       uiEventsForwarderStopVar <- spawnListener forwardEvent
 
+      -- Track last update time and gas for delta calculation
+      startTime <- liftIO getTimestamp
+      lastUpdateRef <- liftIO $ newIORef $ GasTracker startTime 0
+
       let printStatus = do
             states <- liftIO $ workerStates workers
             time <- timePrefix <$> getTimestamp
-            line <- statusLine env states
+            line <- statusLine env states lastUpdateRef
             putStrLn $ time <> "[status] " <> line
             hFlush stdout
 
@@ -196,7 +206,7 @@ ui vm dict initialCorpus cliSelectedContract = do
 
       liftIO $ killThread ticker
 
-      -- print final status regardless the last scheduled update
+      -- print final status regardless of the last scheduled update
       liftIO printStatus
 
       when (isJust conf.campaignConf.serverPort) $ do
@@ -295,7 +305,7 @@ monitor = do
         state <- get
         let updatedState = state { campaigns = c', status = Running, now, tests }
         newWidget <- liftIO $ runReaderT (campaignStatus updatedState) env
-        -- purposedly using lazy modify here, so unnecesary widget states don't get computed
+        -- intentionally using lazy modify here, so unnecessary widget states don't get computed
         modify $ const updatedState { campaignWidget = newWidget }
       AppEvent (FetchCacheUpdated contracts slots) ->
         modify' $ \state ->
@@ -381,15 +391,27 @@ isTerminal = hNowSupportsANSI stdout
 statusLine
   :: Env
   -> [WorkerState]
+  -> IORef GasTracker  -- Gas consumption tracking state
   -> IO String
-statusLine env states = do
+statusLine env states lastUpdateRef = do
   tests <- traverse readIORef env.testRefs
   (points, _) <- coverageStats env.coverageRefInit env.coverageRefRuntime
   corpus <- readIORef env.corpusRef
+  now <- getTimestamp
   let totalCalls = sum ((.ncalls) <$> states)
+  let totalGas = sum ((.totalGas) <$> states)
+
+  -- Calculate delta-based gas/s
+  gasTracker <- readIORef lastUpdateRef
+  let deltaTime = round $ diffLocalTime now gasTracker.lastUpdateTime
+  let deltaGas = totalGas - gasTracker.totalGasConsumed
+  let gasPerSecond = if deltaTime > 0 then deltaGas `div` deltaTime else 0
+  writeIORef lastUpdateRef $ GasTracker now totalGas
+
   pure $ "tests: " <> show (length $ filter didFail tests) <> "/" <> show (length tests)
     <> ", fuzzing: " <> show totalCalls <> "/" <> show env.cfg.campaignConf.testLimit
     <> ", values: " <> show ((.value) <$> filter isOptimizationTest tests)
     <> ", cov: " <> show points
     <> ", corpus: " <> show (Corpus.corpusSize corpus)
+    <> ", gas/s: " <> show gasPerSecond