hex-audit 0.7.0 → 0.8.0

package/dist/skills/fuzz/templates/utils/Clamp.sol

@@ -0,0 +1,223 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity >=0.6.2 <0.9.0;
+
+import {Logger} from "./Logger.sol";
+import {StringUtils} from "./StringUtils.sol";
+
+/// @author Modified from Crytic (https://github.com/crytic/properties/blob/main/contracts/util/PropertiesAsserts.sol)
+contract Clamp is StringUtils {
+    /// @notice Clamps value to be between low and high, both inclusive
+    function clampBetween(
+        uint256 value,
+        uint256 low,
+        uint256 high
+    ) internal returns (uint256) {
+        if (value < low || value > high) {
+            uint256 range = high - low;
+            uint256 ans = low + (value % (range + 1));
+            // When range == type(uint256).max (low=0, high=max), range+1 overflows
+            // to 0 causing division by zero. In that case any value is already in
+            // range, so this branch is only reachable when range < type(uint256).max.
+            string memory valueStr = toString(value);
+            string memory ansStr = toString(ans);
+            bytes memory message = abi.encodePacked(
+                "Clamping value ",
+                valueStr,
+                " to ",
+                ansStr
+            );
+            Logger.logString(string(message));
+            return ans;
+        }
+        return value;
+    }
+
+    /// @notice int256 version of clampBetween
+    function clampBetween(
+        int256 value,
+        int256 low,
+        int256 high
+    ) internal returns (int256) {
+        if (value < low || value > high) {
+            int range = high - low + 1;
+            int clamped = (value - low) % (range);
+            if (clamped < 0) clamped += range;
+            int ans = low + clamped;
+            string memory valueStr = toString(value);
+            string memory ansStr = toString(ans);
+            bytes memory message = abi.encodePacked(
+                "Clamping value ",
+                valueStr,
+                " to ",
+                ansStr
+            );
+            Logger.logString(string(message));
+            return ans;
+        }
+        return value;
+    }
+
+    /// @notice clamps a to be less than b
+    function clampLt(uint256 a, uint256 b) internal returns (uint256) {
+        if (!(a < b)) {
+            if(b == 0) {
+                Logger.logString("clampLt cannot clamp value a to be less than zero. Check your inputs/assumptions.");
+                assert(false);
+            }
+            uint256 value = a % b;
+            string memory aStr = toString(a);
+            string memory valueStr = toString(value);
+            bytes memory message = abi.encodePacked(
+                "Clamping value ",
+                aStr,
+                " to ",
+                valueStr
+            );
+            Logger.logString(string(message));
+            return value;
+        }
+        return a;
+    }
+
+    /// @notice int256 version of clampLt
+    function clampLt(int256 a, int256 b) internal returns (int256) {
+        if (!(a < b)) {
+            if (b == type(int256).min) {
+                Logger.logString("clampLt cannot clamp value a to be less than int256.min. Check your inputs/assumptions.");
+                assert(false);
+            }
+            int256 value = b - 1;
+            string memory aStr = toString(a);
+            string memory valueStr = toString(value);
+            bytes memory message = abi.encodePacked(
+                "Clamping value ",
+                aStr,
+                " to ",
+                valueStr
+            );
+            Logger.logString(string(message));
+            return value;
+        }
+        return a;
+    }
+
+    /// @notice clamps a to be less than or equal to b
+    function clampLte(uint256 a, uint256 b) internal returns (uint256) {
+        if (!(a <= b)) {
+            // When b == type(uint256).max, a <= b is always true so this
+            // branch is unreachable. Safe to use b + 1 without overflow.
+            uint256 value = a % (b + 1);
+            string memory aStr = toString(a);
+            string memory valueStr = toString(value);
+            bytes memory message = abi.encodePacked(
+                "Clamping value ",
+                aStr,
+                " to ",
+                valueStr
+            );
+            Logger.logString(string(message));
+            return value;
+        }
+        return a;
+    }
+
+    /// @notice int256 version of clampLte
+    function clampLte(int256 a, int256 b) internal returns (int256) {
+        if (!(a <= b)) {
+            int256 value = b;
+            string memory aStr = toString(a);
+            string memory valueStr = toString(value);
+            bytes memory message = abi.encodePacked(
+                "Clamping value ",
+                aStr,
+                " to ",
+                valueStr
+            );
+            Logger.logString(string(message));
+            return value;
+        }
+        return a;
+    }
+
+    /// @notice clamps a to be greater than b
+    function clampGt(uint256 a, uint256 b) internal returns (uint256) {
+        if (!(a > b)) {
+            if (b == type(uint256).max) {
+                Logger.logString("clampGt cannot clamp value a to be larger than uint256.max. Check your inputs/assumptions.");
+                assert(false);
+            }
+            uint256 value = b + 1;
+            string memory aStr = toString(a);
+            string memory valueStr = toString(value);
+            bytes memory message = abi.encodePacked(
+                "Clamping value ",
+                aStr,
+                " to ",
+                valueStr
+            );
+            Logger.logString(string(message));
+            return value;
+        } else {
+            return a;
+        }
+    }
+
+    /// @notice int256 version of clampGt
+    function clampGt(int256 a, int256 b) internal returns (int256) {
+        if (!(a > b)) {
+            if (b == type(int256).max) {
+                Logger.logString("clampGt cannot clamp value a to be larger than int256.max. Check your inputs/assumptions.");
+                assert(false);
+            }
+            int256 value = b + 1;
+            string memory aStr = toString(a);
+            string memory valueStr = toString(value);
+            bytes memory message = abi.encodePacked(
+                "Clamping value ",
+                aStr,
+                " to ",
+                valueStr
+            );
+            Logger.logString(string(message));
+            return value;
+        } else {
+            return a;
+        }
+    }
+
+    /// @notice clamps a to be greater than or equal to b
+    function clampGte(uint256 a, uint256 b) internal returns (uint256) {
+        if (!(a >= b)) {
+            uint256 value = b;
+            string memory aStr = toString(a);
+            string memory valueStr = toString(value);
+            bytes memory message = abi.encodePacked(
+                "Clamping value ",
+                aStr,
+                " to ",
+                valueStr
+            );
+            Logger.logString(string(message));
+            return value;
+        }
+        return a;
+    }
+
+    /// @notice int256 version of clampGte
+    function clampGte(int256 a, int256 b) internal returns (int256) {
+        if (!(a >= b)) {
+            int256 value = b;
+            string memory aStr = toString(a);
+            string memory valueStr = toString(value);
+            bytes memory message = abi.encodePacked(
+                "Clamping value ",
+                aStr,
+                " to ",
+                valueStr
+            );
+            Logger.logString(string(message));
+            return value;
+        }
+        return a;
+    }
+}

package/dist/skills/fuzz/templates/utils/DecimalPrinter.sol

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.6.2 <0.9.0;
+
+library DecimalPrinter {
+    function toDec(uint256 _value) public pure returns (string memory) {
+        return toDec(_value, 18);
+    }
+
+    function toDec(int256 _value) public pure returns (string memory) {
+        return toDec(_value, 18);
+    }
+
+    function toDec(uint256 _value, uint256 decimals) public pure returns (string memory) {
+        uint256 base = 10**decimals;
+        uint256 integerPart = _value / base;
+        uint256 fractionalPart = _value % base;
+
+        string memory integerPartStr = uintToStr(integerPart);
+        string memory fractionalPartStr = uintToStr(fractionalPart);
+
+        // Pad fractional part with leading zeros if necessary
+        uint256 numZeros = decimals - bytes(fractionalPartStr).length;
+        for (uint256 i = 0; i < numZeros; i++) {
+            fractionalPartStr = string(abi.encodePacked("0", fractionalPartStr));
+        }
+
+        string memory result = string(abi.encodePacked(integerPartStr, ".", fractionalPartStr));
+
+        return result;
+    }
+
+    function toDec(int256 _value, uint256 decimals) public pure returns (string memory) {
+        if (_value < 0) {
+            return string(abi.encodePacked("-", toDec(uint256(-_value), decimals)));
+        } else {
+            return toDec(uint256(_value), decimals);
+        }
+    }
+
+    function uintToStr(uint256 _value) private pure returns (string memory) {
+        if (_value == 0) {
+            return "0";
+        }
+
+        uint256 temp = _value;
+        uint256 digits;
+
+        while (temp != 0) {
+            digits++;
+            temp /= 10;
+        }
+
+        bytes memory buffer = new bytes(digits);
+
+        while (_value != 0) {
+            digits--;
+            buffer[digits] = bytes1(uint8(48 + _value % 10));
+            _value /= 10;
+        }
+
+        return string(buffer);
+    }
+}

package/dist/skills/fuzz/templates/utils/Deployer.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.2 <0.9.0;
+
+// Source: https://solidity-by-example.org/app/deploy-any-contract/
+
+contract Deployer {
+    function deploy(bytes memory _code) internal returns (address addr) {
+        return deploy(_code, 0);
+    }
+
+    function deploy(bytes memory _code, uint256 _value) internal returns (address addr) {
+        assembly {
+            addr := create(_value, add(_code, 0x20), mload(_code))
+        }
+        require(addr != address(0), "Deployer.sol: deploy failed");
+    }
+}

package/dist/skills/fuzz/templates/utils/EnumerableSet.sol

@@ -0,0 +1,206 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
+pragma solidity >=0.6.2 <0.9.0;
+
+/**
+ * @dev Library for managing
+ * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
+ * types.
+ *
+ * Sets have the following properties:
+ *
+ * - Elements are added, removed, and checked for existence in constant time
+ * (O(1)).
+ * - Elements are enumerated in O(n). No guarantees are made on the ordering.
+ *
+ * ```solidity
+ * contract Example {
+ *     // Add the library methods
+ *     using EnumerableSet for EnumerableSet.AddressSet;
+ *
+ *     // Declare a set state variable
+ *     EnumerableSet.AddressSet private mySet;
+ * }
+ * ```
+ *
+ * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
+ * and `uint256` (`UintSet`) are supported.
+ *
+ * [WARNING]
+ * ====
+ * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
+ * unusable.
+ * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
+ *
+ * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
+ * array of EnumerableSet.
+ * ====
+ */
+library EnumerableSet {
+    struct Set {
+        bytes32[] _values;
+        mapping(bytes32 value => uint256) _positions;
+    }
+
+    function _add(Set storage set, bytes32 value) private returns (bool) {
+        if (!_contains(set, value)) {
+            set._values.push(value);
+            set._positions[value] = set._values.length;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function _remove(Set storage set, bytes32 value) private returns (bool) {
+        uint256 position = set._positions[value];
+
+        if (position != 0) {
+            uint256 valueIndex = position - 1;
+            uint256 lastIndex = set._values.length - 1;
+
+            if (valueIndex != lastIndex) {
+                bytes32 lastValue = set._values[lastIndex];
+                set._values[valueIndex] = lastValue;
+                set._positions[lastValue] = position;
+            }
+
+            set._values.pop();
+            delete set._positions[value];
+
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    function _contains(Set storage set, bytes32 value) private view returns (bool) {
+        return set._positions[value] != 0;
+    }
+
+    function _length(Set storage set) private view returns (uint256) {
+        return set._values.length;
+    }
+
+    function _at(Set storage set, uint256 index) private view returns (bytes32) {
+        return set._values[index];
+    }
+
+    function _values(Set storage set) private view returns (bytes32[] memory) {
+        return set._values;
+    }
+
+    // Bytes32Set
+
+    struct Bytes32Set {
+        Set _inner;
+    }
+
+    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
+        return _add(set._inner, value);
+    }
+
+    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
+        return _remove(set._inner, value);
+    }
+
+    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
+        return _contains(set._inner, value);
+    }
+
+    function length(Bytes32Set storage set) internal view returns (uint256) {
+        return _length(set._inner);
+    }
+
+    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
+        return _at(set._inner, index);
+    }
+
+    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
+        bytes32[] memory store = _values(set._inner);
+        bytes32[] memory result;
+
+        /// @solidity memory-safe-assembly
+        assembly {
+            result := store
+        }
+
+        return result;
+    }
+
+    // AddressSet
+
+    struct AddressSet {
+        Set _inner;
+    }
+
+    function add(AddressSet storage set, address value) internal returns (bool) {
+        return _add(set._inner, bytes32(uint256(uint160(value))));
+    }
+
+    function remove(AddressSet storage set, address value) internal returns (bool) {
+        return _remove(set._inner, bytes32(uint256(uint160(value))));
+    }
+
+    function contains(AddressSet storage set, address value) internal view returns (bool) {
+        return _contains(set._inner, bytes32(uint256(uint160(value))));
+    }
+
+    function length(AddressSet storage set) internal view returns (uint256) {
+        return _length(set._inner);
+    }
+
+    function at(AddressSet storage set, uint256 index) internal view returns (address) {
+        return address(uint160(uint256(_at(set._inner, index))));
+    }
+
+    function values(AddressSet storage set) internal view returns (address[] memory) {
+        bytes32[] memory store = _values(set._inner);
+        address[] memory result;
+
+        /// @solidity memory-safe-assembly
+        assembly {
+            result := store
+        }
+
+        return result;
+    }
+
+    // UintSet
+
+    struct UintSet {
+        Set _inner;
+    }
+
+    function add(UintSet storage set, uint256 value) internal returns (bool) {
+        return _add(set._inner, bytes32(value));
+    }
+
+    function remove(UintSet storage set, uint256 value) internal returns (bool) {
+        return _remove(set._inner, bytes32(value));
+    }
+
+    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
+        return _contains(set._inner, bytes32(value));
+    }
+
+    function length(UintSet storage set) internal view returns (uint256) {
+        return _length(set._inner);
+    }
+
+    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
+        return uint256(_at(set._inner, index));
+    }
+
+    function values(UintSet storage set) internal view returns (uint256[] memory) {
+        bytes32[] memory store = _values(set._inner);
+        uint256[] memory result;
+
+        /// @solidity memory-safe-assembly
+        assembly {
+            result := store
+        }
+
+        return result;
+    }
+}

package/dist/skills/fuzz/templates/utils/Hevm.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Unlicense
+pragma solidity >=0.6.2 <0.9.0;
+
+// source: https://github.com/crytic/properties/blob/main/contracts/util/IHevm.sol
+
+interface IHevm {
+    // Set block.timestamp to newTimestamp
+    function warp(uint256 newTimestamp) external;
+
+    // Set block.number to newNumber
+    function roll(uint256 newNumber) external;
+
+    // Add the condition b to the assumption base for the current branch
+    // This function is almost identical to require
+    function assume(bool b) external;
+
+    // Sets the eth balance of usr to amt
+    function deal(address usr, uint256 amt) external;
+
+    // Loads a storage slot from an address
+    function load(address where, bytes32 slot) external returns (bytes32);
+
+    // Stores a value to an address' storage slot
+    function store(address where, bytes32 slot, bytes32 value) external;
+
+    // Signs data (privateKey, digest) => (v, r, s)
+    function sign(
+        uint256 privateKey,
+        bytes32 digest
+    ) external returns (uint8 v, bytes32 r, bytes32 s);
+
+    // Gets address for a given private key
+    function addr(uint256 privateKey) external returns (address addr);
+
+    // Performs a foreign function call via terminal
+    function ffi(
+        string[] calldata inputs
+    ) external returns (bytes memory result);
+
+    // Performs the next smart contract call with specified msg.sender
+    function prank(address newSender) external;
+
+    // Creates a new fork with the given endpoint and the latest block and returns the identifier of the fork
+    function createFork(string calldata urlOrAlias) external returns (uint256);
+
+    // Takes a fork identifier created by createFork and sets the corresponding forked state as active
+    function selectFork(uint256 forkId) external;
+
+    // Returns the identifier of the current fork
+    function activeFork() external returns (uint256);
+
+    // Labels the address in traces
+    function label(address addr, string calldata label) external;
+
+    // Sets msg.sender to the specified sender until stopPrank() is called
+    function startPrank(address sender) external;
+
+    // Resets msg.sender to the default sender
+    function stopPrank() external;
+}
+
+IHevm constant vm = IHevm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);