Merge pull request #1403 from crytic/feat-rm-estimategas

Drop `estimateGas` support

Author: elopez

CHANGELOG.md

@@ -1,5 +1,6 @@
 ## Unreleased
-* Dropped Etheno support
+* Dropped Etheno support (#1402)
+* Dropped `estimateGas` support and auxiliary code (#1403)
 
 ## 2.2.7
 

README.md

@@ -15,7 +15,6 @@ More seriously, Echidna is a Haskell program designed for fuzzing/property-based
 * Interactive terminal UI, text-only or JSON output
 * Automatic test case minimization for quick triage
 * Seamless integration into the development workflow
-* Maximum gas usage reporting of the fuzzing campaign
 
 .. and [a beautiful high-resolution handcrafted logo](https://raw.githubusercontent.com/crytic/echidna/master/echidna.png).
 
@@ -123,8 +122,7 @@ Campaign = {
   "error"        : string?,
   "tests"        : [Test],
   "seed"         : number,
-  "coverage"     : Coverage,
-  "gas_info"     : [GasInfo]
+  "coverage"     : Coverage
 }
 Test = {
   "contract"     : string,
@@ -143,9 +141,7 @@ Transaction = {
 }
 ```
 
-`Coverage` is a dict describing certain coverage-increasing calls.
-Each `GasInfo` entry is a tuple that describes how maximal
-gas usage was achieved, and is also not too important. These interfaces are
+`Coverage` is a dict describing certain coverage-increasing calls. These interfaces are
 subject to change to be slightly more user-friendly at a later date. `testType`
 will either be `property` or `assertion`, and `status` always takes on either
 `fuzzing`, `shrinking`, `solved`, `passed`, or `error`.

lib/Echidna/Campaign.hs

@@ -40,7 +40,6 @@ import Echidna.Symbolic (forceAddr)
 import Echidna.SymExec (createSymTx)
 import Echidna.Test
 import Echidna.Transaction
-import Echidna.Types (Gas)
 import Echidna.Types.Campaign
 import Echidna.Types.Corpus (Corpus, corpusSize)
 import Echidna.Types.Coverage (coverageStats)
@@ -130,7 +129,6 @@ runSymWorker callback vm dict workerId initialCorpus name = do
   effectiveGenDict = dict { defSeed = effectiveSeed }
   initialState =
     WorkerState { workerId
-                , gasInfo = mempty
                 , genDict = effectiveGenDict
                 , newCoverage = False
                 , ncallseqs = 0
@@ -208,7 +206,6 @@ runFuzzWorker callback vm dict workerId initialCorpus testLimit = do
     effectiveGenDict = dict { defSeed = effectiveSeed }
     initialState =
       WorkerState { workerId
-                  , gasInfo = mempty
                   , genDict = effectiveGenDict
                   , newCoverage = False
                   , ncallseqs = 0
@@ -368,7 +365,7 @@ callseq vm txSeq = do
       -- and construct a set to union to the constants table
       diffs = Map.fromList [(AbiAddressType, Set.fromList $ AbiAddress . forceAddr <$> newAddrs)]
       -- Now we try to parse the return values as solidity constants, and add them to 'GenDict'
-      resultMap = returnValues (map (\(t, (vr, _)) -> (t, vr)) results) workerState.genDict.rTypes
+      resultMap = returnValues results workerState.genDict.rTypes
       -- union the return results with the new addresses
       additions = Map.unionWith Set.union diffs resultMap
       -- append to the constants dictionary
@@ -381,11 +378,6 @@ callseq vm txSeq = do
     -- Update the worker state
     in workerState
       { genDict = updatedDict
-        -- Update the gas estimation
-      , gasInfo =
-          if conf.estimateGas
-             then updateGasInfo results [] workerState.gasInfo
-             else workerState.gasInfo
         -- Reset the new coverage flag
       , newCoverage = False
         -- Keep track of the number of calls to `callseq`
@@ -418,7 +410,7 @@ callseq vm txSeq = do
         _ -> Nothing
 
   -- | Add transactions to the corpus, discarding reverted ones
-  addToCorpus :: Int -> [(Tx, (VMResult Concrete RealWorld, Gas))] -> Corpus -> Corpus
+  addToCorpus :: Int -> [(Tx, VMResult Concrete RealWorld)] -> Corpus -> Corpus
   addToCorpus n res corpus =
     if null rtxs then corpus else Set.insert (n, rtxs) corpus
     where rtxs = fst <$> res
@@ -428,7 +420,7 @@ callseq vm txSeq = do
 execTxOptC
   :: (MonadIO m, MonadReader Env m, MonadState WorkerState m, MonadThrow m)
   => VM Concrete RealWorld -> Tx
-  -> m ((VMResult Concrete RealWorld, Gas), VM Concrete RealWorld)
+  -> m (VMResult Concrete RealWorld, VM Concrete RealWorld)
 execTxOptC vm tx = do
   ((res, grew), vm') <- runStateT (execTxWithCov tx) vm
   when grew $ do
@@ -440,25 +432,6 @@ execTxOptC vm tx = do
       in workerState { newCoverage = True, genDict = dict' }
   pure (res, vm')
 
--- | Given current `gasInfo` and a sequence of executed transactions, updates
--- information on the highest gas usage for each call
-updateGasInfo
-  :: [(Tx, (VMResult Concrete RealWorld, Gas))]
-  -> [Tx]
-  -> Map Text (Gas, [Tx])
-  -> Map Text (Gas, [Tx])
-updateGasInfo [] _ gi = gi
-updateGasInfo ((tx@Tx{call = SolCall (f, _)}, (_, used')):txs) tseq gi =
-  case mused of
-    Nothing -> rec
-    Just (used, _) | used' > used -> rec
-    Just (used, otseq) | (used' == used) && (length otseq > length tseq') -> rec
-    _ -> updateGasInfo txs tseq' gi
-  where mused = Map.lookup f gi
-        tseq' = tx:tseq
-        rec   = updateGasInfo txs tseq' (Map.insert f (used', reverse tseq') gi)
-updateGasInfo ((t, _):ts) tseq gi = updateGasInfo ts (t:tseq) gi
-
 -- | Given an initial 'VM' state and a way to run transactions, evaluate a list
 -- of transactions, constantly checking if we've solved any tests.
 evalSeq

lib/Echidna/Config.hs

@@ -88,7 +88,6 @@ instance FromJSON EConfigWithUsage where
       campaignConfParser = CampaignConf
         <$> v ..:? "testLimit" ..!= defaultTestLimit
         <*> v ..:? "stopOnFail" ..!= False
-        <*> v ..:? "estimateGas" ..!= False
         <*> v ..:? "seqLen" ..!= defaultSequenceLength
         <*> v ..:? "shrinkLimit" ..!= defaultShrinkLimit
         <*> (v ..:? "coverage" <&> \case Just False -> Nothing;  _ -> Just mempty)

lib/Echidna/Exec.hs

@@ -37,7 +37,7 @@ import Echidna.Onchain (safeFetchContractFrom, safeFetchSlotFrom)
 import Echidna.SourceMapping (lookupUsingCodehashOrInsert)
 import Echidna.Symbolic (forceBuf)
 import Echidna.Transaction
-import Echidna.Types (ExecException(..), Gas, fromEVM, emptyAccount)
+import Echidna.Types (ExecException(..), fromEVM, emptyAccount)
 import Echidna.Types.Config (Env(..), EConfig(..), UIConf(..), OperationMode(..), OutputFormat(Text))
 import Echidna.Types.Coverage (CoverageInfo)
 import Echidna.Types.Solidity (SolConf(..))
@@ -84,24 +84,22 @@ execTxWith
   :: (MonadIO m, MonadState (VM Concrete RealWorld) m, MonadReader Env m, MonadThrow m)
   => m (VMResult Concrete RealWorld)
   -> Tx
-  -> m (VMResult Concrete RealWorld, Gas)
+  -> m (VMResult Concrete RealWorld)
 execTxWith executeTx tx = do
   vm <- get
   if hasSelfdestructed vm tx.dst then
-    pure (VMFailure (Revert (ConcreteBuf "")), 0)
+    pure $ VMFailure (Revert (ConcreteBuf ""))
   else do
     #traces .= emptyEvents
     vmBeforeTx <- get
     setupTx tx
     case tx.call of
-      NoCall -> pure (VMSuccess (ConcreteBuf ""), 0)
+      NoCall -> pure $ VMSuccess (ConcreteBuf "")
       _ -> do
-        gasLeftBeforeTx <- gets (.state.gas)
         vmResult <- runFully
-        gasLeftAfterTx <- gets (.state.gas)
         handleErrorsAndConstruction vmResult vmBeforeTx
         fromEVM clearTStorages
-        pure (vmResult, gasLeftBeforeTx - gasLeftAfterTx)
+        pure vmResult
   where
   runFully = do
     config <- asks (.cfg)
@@ -240,7 +238,7 @@ execTx
   :: (MonadIO m, MonadReader Env m, MonadThrow m)
   => VM Concrete RealWorld
   -> Tx
-  -> m ((VMResult Concrete RealWorld, Gas), VM Concrete RealWorld)
+  -> m (VMResult Concrete RealWorld, VM Concrete RealWorld)
 execTx vm tx = runStateT (execTxWith (fromEVM (exec defaultConfig)) tx) vm
 
 -- | A type alias for the context we carry while executing instructions
@@ -250,7 +248,7 @@ type CoverageContext = (Bool, Maybe (VMut.IOVector CoverageInfo, Int))
 execTxWithCov
   :: (MonadIO m, MonadState (VM Concrete RealWorld) m, MonadReader Env m, MonadThrow m)
   => Tx
-  -> m ((VMResult Concrete RealWorld, Gas), Bool)
+  -> m (VMResult Concrete RealWorld, Bool)
 execTxWithCov tx = do
   env <- ask
 
@@ -263,7 +261,7 @@ execTxWithCov tx = do
   -- Update the last valid location with the transaction result
   grew' <- liftIO $ case lastLoc of
     Just (vec, pc) -> do
-      let txResultBit = fromEnum $ getResult $ fst r
+      let txResultBit = fromEnum $ getResult r
       VMut.read vec pc >>= \case
         (opIx, depths, txResults) | not (txResults `testBit` txResultBit) -> do
           VMut.write vec pc (opIx, depths, txResults `setBit` txResultBit)

lib/Echidna/Output/JSON.hs

@@ -17,7 +17,6 @@ import EVM.Dapp (DappInfo)
 
 import Echidna.ABI (ppAbiValue, GenDict(..))
 import Echidna.Events (Events, extractEvents)
-import Echidna.Types (Gas)
 import Echidna.Types.Campaign (WorkerState(..))
 import Echidna.Types.Config (Env(..))
 import Echidna.Types.Coverage (CoverageInfo, mergeCoverageMaps)
@@ -31,7 +30,6 @@ data Campaign = Campaign
   , _tests :: [Test]
   , seed :: Int
   , coverage :: Map String [CoverageInfo]
-  , gasInfo :: [(Text, (Gas, [Tx]))]
   }
 
 instance ToJSON Campaign where
@@ -41,7 +39,6 @@ instance ToJSON Campaign where
     , "tests" .= _tests
     , "seed" .= seed
     , "coverage" .= coverage
-    , "gas_info" .= gasInfo
     ]
 
 data Test = Test
@@ -112,7 +109,6 @@ encodeCampaign env workerStates = do
     , _tests = mapTest env.dapp <$> tests
     , seed = seed
     , coverage = Map.mapKeys (("0x" ++) . (`showHex` "")) $ VU.toList <$> frozenCov
-    , gasInfo = Map.toList $ Map.unionsWith max ((.gasInfo) <$> workerStates)
     }
 
 mapTest :: DappInfo -> EchidnaTest -> Test

lib/Echidna/Types/Campaign.hs

@@ -2,7 +2,6 @@ module Echidna.Types.Campaign where
 
 import Control.Concurrent (ThreadId)
 import Data.Aeson
-import Data.Map (Map)
 import Data.Text (Text)
 import Data.Text qualified as T
 import Data.Word (Word8, Word16)
@@ -20,8 +19,6 @@ data CampaignConf = CampaignConf
     -- ^ Maximum number of function calls to execute while fuzzing
   , stopOnFail         :: Bool
     -- ^ Whether to stop the campaign immediately if any property fails
-  , estimateGas        :: Bool
-    -- ^ Whether to collect gas usage statistics
   , seqLen             :: Int
     -- ^ Number of calls between state resets (e.g. \"every 10 calls,
     -- reset the state to avoid unrecoverable states/save memory\"
@@ -158,8 +155,6 @@ ppWorkerEvent = \case
 data WorkerState = WorkerState
   { workerId    :: !Int
     -- ^ Worker ID starting from 0
-  , gasInfo     :: !(Map Text (Gas, [Tx]))
-    -- ^ Worst case gas (NOTE: we don't always record this)
   , genDict     :: !GenDict
     -- ^ Generation dictionary
   , newCoverage :: !Bool
@@ -178,7 +173,6 @@ data WorkerState = WorkerState
 initialWorkerState :: WorkerState
 initialWorkerState =
   WorkerState { workerId = 0
-              , gasInfo = mempty
               , genDict = emptyDict
               , newCoverage = False
               , ncallseqs = 0

lib/Echidna/UI.hs

@@ -163,7 +163,7 @@ ui vm dict initialCorpus cliSelectedContract = do
       liftIO $ killThread ticker
 
       states <- workerStates workers
-      liftIO . putStrLn =<< ppCampaign vm states
+      liftIO . putStrLn =<< ppCampaign states
 
       pure states
 
@@ -218,7 +218,7 @@ ui vm dict initialCorpus cliSelectedContract = do
         JSON ->
           liftIO $ BS.putStr =<< Echidna.Output.JSON.encodeCampaign env states
         Text -> do
-          liftIO . putStrLn =<< ppCampaign vm states
+          liftIO . putStrLn =<< ppCampaign  states
         None ->
           pure ()
       pure states

lib/Echidna/UI/Report.hs

@@ -4,8 +4,7 @@ import Control.Monad (forM)
 import Control.Monad.Reader (MonadReader, MonadIO (liftIO), asks, ask)
 import Control.Monad.ST (RealWorld)
 import Data.IORef (readIORef, atomicModifyIORef')
-import Data.List (intercalate, nub, sortOn)
-import Data.Map (toList)
+import Data.List (nub)
 import Data.Map qualified as Map
 import Data.Maybe (catMaybes, fromJust, fromMaybe)
 import Data.Text (Text, unpack)
@@ -17,7 +16,6 @@ import Echidna.ABI (GenDict(..), encodeSig)
 import Echidna.Pretty (ppTxCall)
 import Echidna.SourceMapping (findSrcByMetadata, lookupCodehash)
 import Echidna.Symbolic (forceWord)
-import Echidna.Types (Gas)
 import Echidna.Types.Campaign
 import Echidna.Types.Config
 import Echidna.Types.Corpus (corpusSize)
@@ -53,18 +51,16 @@ ppSeed :: [WorkerState] -> String
 ppSeed [] = "unknown" -- should not happen
 ppSeed (campaign:_) = show campaign.genDict.defSeed
 
-ppCampaign :: (MonadIO m, MonadReader Env m) => VM Concrete RealWorld -> [WorkerState] -> m String
-ppCampaign vm workerStates = do
+ppCampaign :: (MonadIO m, MonadReader Env m) => [WorkerState] -> m String
+ppCampaign workerStates = do
   tests <- liftIO . traverse readIORef =<< asks (.testRefs)
   testsPrinted <- ppTests tests
-  gasInfoPrinted <- ppGasInfo vm workerStates
   coveragePrinted <- ppCoverage
   let seedPrinted = "Seed: " <> ppSeed workerStates
   corpusPrinted <- ppCorpus
   let callsPrinted = ppTotalCalls workerStates
   pure $ unlines
     [ testsPrinted
-    , gasInfoPrinted
     , coveragePrinted
     , corpusPrinted
     , seedPrinted
@@ -141,22 +137,6 @@ ppCorpus = do
   corpus <- liftIO . readIORef =<< asks (.corpusRef)
   pure $ "Corpus size: " <> show (corpusSize corpus)
 
--- | Pretty-print the gas usage information a 'Campaign' has obtained.
-ppGasInfo :: (MonadReader Env m, MonadIO m) => VM Concrete RealWorld -> [WorkerState] -> m String
-ppGasInfo vm workerStates = do
-  let gasInfo = Map.unionsWith max ((.gasInfo) <$> workerStates)
-  items <- mapM (ppGasOne vm) $ sortOn (\(_, (n, _)) -> n) $ toList gasInfo
-  pure $ intercalate "" items
-
--- | Pretty-print the gas usage for a function.
-ppGasOne :: (MonadReader Env m, MonadIO m) => VM Concrete RealWorld -> (Text, (Gas, [Tx])) -> m String
-ppGasOne _  ("", _)      = pure ""
-ppGasOne vm (func, (gas, txs)) = do
-  let header = "\n" <> unpack func <> " used a maximum of " <> show gas <> " gas\n"
-               <> "  Call sequence:\n"
-  prettyTxs <- mapM (ppTx vm $ length (nub $ (.src) <$> txs) /= 1) txs
-  pure $ header <> unlines (("    " <>) <$> prettyTxs)
-
 -- | Pretty-print the status of a solved test.
 ppFail :: (MonadReader Env m, MonadIO m) => Maybe (Int, Int) -> VM Concrete RealWorld -> [Tx] -> m String
 ppFail _ _ []  = pure "failed with no transactions made ⁉️ "

src/test/Common.hs

@@ -14,8 +14,6 @@ module Common
   , solvedWith
   , solvedWithout
   , solvedUsing
-  , getGas
-  , gasInRange
   , countCorpus
   , overrideQuiet
   , loadSolTests
@@ -44,7 +42,6 @@ import Echidna.Config (parseConfig, defaultConfig)
 import Echidna.Campaign (runWorker)
 import Echidna.Solidity (selectMainContract, mkTests, loadSpecified, compileContracts)
 import Echidna.Test (checkETest)
-import Echidna.Types (Gas)
 import Echidna.Types.Config (Env(..), EConfig(..), EConfigWithUsage(..))
 import Echidna.Types.Campaign
 import Echidna.Types.Signature (ContractName)
@@ -237,15 +234,6 @@ solvedWithout :: TxCall -> Text -> (Env, WorkerState) -> IO Bool
 solvedWithout tx t final =
   maybe False (all $ (/= tx) . (.call)) <$> solnFor t final
 
-getGas :: Text -> WorkerState -> Maybe (Gas, [Tx])
-getGas t camp = Map.lookup t camp.gasInfo
-
-gasInRange :: Text -> Gas -> Gas -> (Env, WorkerState) -> IO Bool
-gasInRange t l h (_, workerState) = do
-  pure $ case getGas t workerState of
-    Just (g, _) -> g >= l && g <= h
-    _           -> False
-
 countCorpus :: Int -> (Env, WorkerState) -> IO Bool
 countCorpus n (env, _) = do
   corpus <- readIORef env.corpusRef