Merge pull request #1392 from crytic/gas-per-second-text

Show gas/s metric in non-interactive mode

Author: elopez

CHANGELOG.md

@@ -2,10 +2,12 @@
 
 * 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)
 * 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)

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.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) }
+
+-- | 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/UI.hs

@@ -53,6 +53,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
@@ -174,10 +180,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
 
@@ -379,15 +389,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
 

src/test/Tests/Integration.hs

@@ -92,6 +92,8 @@ integrationTests = testGroup "Solidity Integration Testing"
       ]
   , testContract "basic/gaslimit.sol"  Nothing
       [ ("echidna_gaslimit passed",                passed      "echidna_gaslimit") ]
+  , testContract "basic/gasleft.sol"     (Just "basic/gasleft.yaml")
+      [ ("unexpected gas left",                   passed      "echidna_expected_gasleft") ]
   ,  testContractV "basic/killed.sol"      (Just (< solcV (0,8,0))) (Just "basic/killed.yaml")
       [ ("echidna_still_alive failed",             solved      "echidna_still_alive") ]
   ,  checkConstructorConditions "basic/codesize.sol"

tests/solidity/basic/gasleft.sol

@@ -0,0 +1,6 @@
+contract C {
+  function echidna_expected_gasleft() public returns (bool) {
+    uint256 left = gasleft();
+    return left > 2000 && left < 5000;
+  }
+}

tests/solidity/basic/gasleft.yaml

@@ -0,0 +1,2 @@
+testLimit: 10
+propMaxGas: 25000

tests/solidity/basic/gasuse.yaml

@@ -1,3 +1,3 @@
-testLimit: 5000
+testLimit: 10000
 testMaxGas: 4294967295
 estimateGas: true

tests/solidity/basic/propGasLimit.yaml

@@ -1 +1 @@
-propMaxGas: 20000
+propMaxGas: 40000