Gas report

src/_modules/Context.sol

@@ -3,6 +3,8 @@ pragma solidity >=0.8.13 <0.9.0;
 
 import "./Vulcan.sol";
 import "./Accounts.sol";
+import "./Strings.sol";
+import "../_utils/println.sol";
 
 type Context is bytes32;
 
@@ -69,6 +71,30 @@ library ctxSafe {
     function resumeGasMetering() internal {
         vulcan.hevm.resumeGasMetering();
     }
+
+    function startGasReport(string memory name) internal {
+        if (bytes(name).length > 32) {
+            revert("ctx.startGasReport: Gas report name can't have more than 32 characters");
+        }
+
+        bytes32 b32Name = bytes32(bytes(name));
+        bytes32 slot = keccak256(bytes("vulcan.ctx.gasReport.name"));
+        accounts.setStorage(address(vulcan.hevm), slot, b32Name);
+        bytes32 valueSlot = keccak256(abi.encodePacked("vulcan.ctx.gasReport", b32Name));
+        accounts.setStorage(address(vulcan.hevm), valueSlot, bytes32(gasleft()));
+    }
+
+    function endGasReport() internal view {
+        uint256 gas = gasleft();
+        bytes32 slot = keccak256(bytes("vulcan.ctx.gasReport.name"));
+        bytes32 b32Name = accounts.readStorage(address(vulcan.hevm), slot);
+        bytes32 valueSlot = keccak256(abi.encodePacked("vulcan.ctx.gasReport", b32Name));
+        uint256 prevGas = uint256(accounts.readStorage(address(vulcan.hevm), valueSlot));
+        if (gas > prevGas) {
+            revert("ctx.endGasReport: Gas used can't have a negative value");
+        }
+        println(string.concat("gas(", string(abi.encodePacked(b32Name)), "):", strings.toString(prevGas - gas)));
+    }
 }
 
 library ctx {
@@ -120,6 +146,14 @@ library ctx {
         ctxSafe.resumeGasMetering();
     }
 
+    function startGasReport(string memory name) internal {
+        ctxSafe.startGasReport(name);
+    }
+
+    function endGasReport() internal view {
+        ctxSafe.endGasReport();
+    }
+
     /// @dev Checks whether the current call is a static call or not.
     /// @return True if the current call is a static call, false otherwise.
     function isStaticcall() internal view returns (bool) {

src/_modules/Gas.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "./Vulcan.sol";
+import "./Accounts.sol";
+
+library gas {
+    bytes32 constant GAS_MEASUREMENTS_MAGIC = keccak256("vulcan.gas.measurements.magic");
+
+    function record(string memory name) internal {
+        bytes32 startSlot = keccak256(abi.encode(GAS_MEASUREMENTS_MAGIC, name, "start"));
+        accounts.setStorage(address(vulcan.hevm), startSlot, bytes32(gasleft()));
+    }
+
+    function stopRecord(string memory name) internal returns (uint256) {
+        uint256 endGas = gasleft();
+
+        bytes32 startSlot = keccak256(abi.encode(GAS_MEASUREMENTS_MAGIC, name, "start"));
+        uint256 startGas = uint256(accounts.readStorage(address(vulcan.hevm), startSlot));
+
+        if (endGas > startGas) {
+            revert("gas.stopRecord: Gas used can't have a negative value");
+        }
+
+        bytes32 endSlot = keccak256(abi.encode(GAS_MEASUREMENTS_MAGIC, name, "end"));
+        accounts.setStorage(address(vulcan.hevm), endSlot, bytes32(endGas));
+
+        return startGas - endGas;
+    }
+
+    function getRecord(string memory name) internal view returns (uint256, uint256) {
+        bytes32 startSlot = keccak256(abi.encode(GAS_MEASUREMENTS_MAGIC, name, "start"));
+        uint256 startGas = uint256(accounts.readStorage(address(vulcan.hevm), startSlot));
+
+        bytes32 endSlot = keccak256(abi.encode(GAS_MEASUREMENTS_MAGIC, name, "end"));
+        uint256 endGas = uint256(accounts.readStorage(address(vulcan.hevm), endSlot));
+
+        return (startGas, endGas);
+    }
+
+    function used(string memory name) internal view returns (uint256) {
+        (uint256 startGas, uint256 endGas) = getRecord(name);
+
+        return startGas - endGas;
+    }
+}

src/test.sol

@@ -12,6 +12,7 @@ import {events} from "./_modules/Events.sol";
 import {expect} from "./_modules/Expect.sol";
 import {forks, Fork} from "./_modules/Forks.sol";
 import {fs, FsMetadata} from "./_modules/Fs.sol";
+import {gas} from "./_modules/Gas.sol";
 import {huff, Huffc} from "./_modules/Huff.sol";
 import {json, JsonObject} from "./_modules/Json.sol";
 import {strings} from "./_modules/Strings.sol";

test/_modules/Context.t.sol

@@ -94,6 +94,14 @@ contract ContextTest is Test {
 
         target.value{value: uint256(1337)}();
     }
+
+    function testItCanReportGas() external {
+        ctx.startGasReport("test");
+        for (uint256 i = 0; i < 5; i++) {
+            new MockTarget();
+        }
+        ctx.endGasReport();
+    }
 }
 
 contract MockTarget {

test/_modules/Gas.t.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import {Test, expect, gas} from "../../src/test.sol";
+
+contract GasTest is Test {
+    function testItMeasures() public {
+        string memory name = "test";
+
+        gas.record(name);
+        keccak256(bytes(name));
+        uint256 measurementValue = gas.stopRecord(name);
+
+        expect(measurementValue).toBeGreaterThan(0);
+        expect(measurementValue).toEqual(gas.used(name));
+    }
+}