Refactor Address.sol

contracts/governance/Governor.sol

@@ -278,10 +278,13 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
         address proposer = _msgSender();
         uint256 currentTimepoint = clock();
 
-        uint256 proposerVotes = getVotes(proposer, currentTimepoint - 1);
-        uint256 votesThreshold = proposalThreshold();
-        if (proposerVotes < votesThreshold) {
-            revert GovernorProposerInvalidTreshold(proposer, proposerVotes, votesThreshold);
+        // Avoid stack too deep
+        {
+            uint256 proposerVotes = getVotes(proposer, currentTimepoint - 1);
+            uint256 votesThreshold = proposalThreshold();
+            if (proposerVotes < votesThreshold) {
+                revert GovernorProposerInvalidTreshold(proposer, proposerVotes, votesThreshold);
+            }
         }
 
         uint256 proposalId = hashProposal(targets, values, calldatas, keccak256(bytes(description)));
@@ -382,10 +385,9 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
         bytes[] memory calldatas,
         bytes32 /*descriptionHash*/
     ) internal virtual {
-        string memory errorMessage = "Governor: call reverted without message";
         for (uint256 i = 0; i < targets.length; ++i) {
             (bool success, bytes memory returndata) = targets[i].call{value: values[i]}(calldatas[i]);
-            Address.verifyCallResult(success, returndata, errorMessage);
+            Address.verifyCallResult(success, returndata, _onGovernorCallRevert);
         }
     }
 
@@ -616,7 +618,7 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
      */
     function relay(address target, uint256 value, bytes calldata data) external payable virtual onlyGovernance {
         (bool success, bytes memory returndata) = target.call{value: value}(data);
-        Address.verifyCallResult(success, returndata, "Governor: relay reverted without message");
+        Address.verifyCallResult(success, returndata, _onGovernorCallRevert);
     }
 
     /**
@@ -675,4 +677,11 @@ abstract contract Governor is Context, ERC165, EIP712, IGovernor, IERC721Receive
     function _encodeState(ProposalState proposalState) internal pure returns (bytes32) {
         return bytes32(1 << uint32(proposalState));
     }
+
+    /**
+     * @dev Default revert function for failed executed functions without any other bubbled up reason.
+     */
+    function _onGovernorCallRevert() internal pure {
+        revert GovernorFailedLowLevelCall();
+    }
 }

contracts/governance/IGovernor.sol

@@ -52,7 +52,7 @@ abstract contract IGovernor is IERC165, IERC6372 {
      * @dev The `proposalId` is duplicated.
      */
     error GovernorDuplicatedProposal(uint256 proposalId);
-    
+
     /**
      * @dev The `proposalId` doesn't exist.
      */
@@ -77,6 +77,11 @@ abstract contract IGovernor is IERC165, IERC6372 {
      */
     error GovernorProposerInvalidTreshold(address proposer, uint256 votes, uint256 threshold);
 
+    /**
+     * @dev A low level call failed without any further reason.
+     */
+    error GovernorFailedLowLevelCall();
+
     /**
      * @dev Emitted when a proposal is created.
      */

contracts/governance/extensions/GovernorCountingSimple.sol

@@ -30,9 +30,9 @@ abstract contract GovernorCountingSimple is Governor {
     mapping(uint256 => ProposalVote) private _proposalVotes;
 
     /**
-     * @dev Vote type is not in the {VoteType} enum. Matches Governor Bravo definition.
+     * @dev Vote type is not in the {VoteType} enum.
      */
-    error InvalidVoteType();
+    error GovernorInvalidVoteType();
 
     /**
      * @dev See {IGovernor-COUNTING_MODE}.
@@ -101,7 +101,7 @@ abstract contract GovernorCountingSimple is Governor {
         } else if (support == uint8(VoteType.Abstain)) {
             proposalVote.abstainVotes += weight;
         } else {
-            revert InvalidVoteType();
+            revert GovernorInvalidVoteType();
         }
     }
 }

contracts/mocks/token/ERC721ConsecutiveMock.sol

@@ -3,7 +3,6 @@
 pragma solidity ^0.8.0;
 
 import "../../token/ERC721/extensions/ERC721Consecutive.sol";
-import "../../token/ERC721/extensions/ERC721Enumerable.sol";
 import "../../token/ERC721/extensions/ERC721Pausable.sol";
 import "../../token/ERC721/extensions/ERC721Votes.sol";
 

contracts/token/ERC20/utils/SafeERC20.sol

@@ -24,6 +24,11 @@ library SafeERC20 {
      */
     error ERC20UnsuccessfulOperation(address token);
 
+    /**
+     * @dev A low level call failed without any further reason.
+     */
+    error ERC20FailedLowLevelCall();
+
     /**
      * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
      * non-reverting calls are assumed to be successful.
@@ -110,7 +115,7 @@ library SafeERC20 {
         // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
         // the target address contains contract code and also asserts for success in the low-level call.
 
-        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
+        bytes memory returndata = address(token).functionCall(data, onERC20CallRevert);
         if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
             revert ERC20UnsuccessfulOperation(address(token));
         }
@@ -132,4 +137,8 @@ library SafeERC20 {
         (bool success, bytes memory returndata) = address(token).call(data);
         return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
     }
+
+    function onERC20CallRevert() internal pure {
+        revert ERC20FailedLowLevelCall();
+    }
 }

contracts/token/ERC721/extensions/ERC721Enumerable.sol

@@ -34,7 +34,7 @@ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
     /**
      * @dev Batch mint is not allowed.
      */
-    error ERC721ForbiddenBatchMint();
+    error ERC721EnumerableForbiddenBatchMint();
 
     /**
      * @dev See {IERC165-supportsInterface}.
@@ -83,7 +83,7 @@ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
 
         if (batchSize > 1) {
             // Will only trigger during construction. Batch transferring (minting) is not available afterwards.
-            revert ERC721ForbiddenBatchMint();
+            revert ERC721EnumerableForbiddenBatchMint();
         }
 
         uint256 tokenId = firstTokenId;

contracts/utils/Address.sol

@@ -10,17 +10,28 @@ library Address {
     /**
      * @dev The ETH balance of the account is not enough to perform the operation.
      */
-    error ETHInsufficientBalance(address account);
+    error AddressInsufficientBalance(address account);
 
     /**
      * @dev A call to `target` failed. The `target` may have reverted.
      */
-    error FailedCall(address target);
+    error AddressFailedCall(address target);
+
+    /**
+     * @dev A low level call failed without any further reason.
+     */
+    error AddressFailedLowLevelCall();
 
     /**
      * @dev There's no code at `target` (is not a contract).
      */
-    error EmptyCode(address target);
+    error AddressEmptyCode(address target);
+
+    /**
+     * @dev A revert was expected but didn't happen. This is caused if the
+     * custom revert function provided didn't revert.
+     */
+    error AddressExpectedRevert();
 
     /**
      * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
@@ -40,12 +51,12 @@ library Address {
      */
     function sendValue(address payable recipient, uint256 amount) internal {
         if (address(this).balance < amount) {
-            revert ETHInsufficientBalance(address(this));
+            revert AddressInsufficientBalance(address(this));
         }
 
         (bool success, ) = recipient.call{value: amount}("");
         if (!success) {
-            revert FailedCall(recipient);
+            revert AddressFailedCall(recipient);
         }
     }
 
@@ -68,21 +79,25 @@ library Address {
      * _Available since v3.1._
      */
     function functionCall(address target, bytes memory data) internal returns (bytes memory) {
-        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
+        return functionCallWithValue(target, data, 0, defaultOnRevert);
     }
 
     /**
-     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
-     * `errorMessage` as a fallback revert reason when `target` reverts.
+     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with an
+     * `onRevert` function as a fallback when `target` reverts.
+     *
+     * Requirements:
+     *
+     * - `onRevert` must be a reverting function.
      *
      * _Available since v3.1._
      */
     function functionCall(
         address target,
         bytes memory data,
-        string memory errorMessage
+        function() internal pure onRevert
     ) internal returns (bytes memory) {
-        return functionCallWithValue(target, data, 0, errorMessage);
+        return functionCallWithValue(target, data, 0, onRevert);
     }
 
     /**
@@ -97,26 +112,30 @@ library Address {
      * _Available since v3.1._
      */
     function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
-        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
+        return functionCallWithValue(target, data, value, defaultOnRevert);
     }
 
     /**
      * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
-     * with `errorMessage` as a fallback revert reason when `target` reverts.
+     * with an `onRevert` function as a fallback revert reason when `target` reverts.
+     *
+     * Requirements:
+     *
+     * - `onRevert` must be a reverting function.
      *
      * _Available since v3.1._
      */
     function functionCallWithValue(
         address target,
         bytes memory data,
         uint256 value,
-        string memory errorMessage
+        function() internal pure onRevert
     ) internal returns (bytes memory) {
         if (address(this).balance < value) {
-            revert ETHInsufficientBalance(address(this));
+            revert AddressInsufficientBalance(address(this));
         }
         (bool success, bytes memory returndata) = target.call{value: value}(data);
-        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+        return verifyCallResultFromTarget(target, success, returndata, onRevert);
     }
 
     /**
@@ -126,7 +145,7 @@ library Address {
      * _Available since v3.3._
      */
     function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
-        return functionStaticCall(target, data, "Address: low-level static call failed");
+        return functionStaticCall(target, data, defaultOnRevert);
     }
 
     /**
@@ -138,10 +157,10 @@ library Address {
     function functionStaticCall(
         address target,
         bytes memory data,
-        string memory errorMessage
+        function() internal pure onRevert
     ) internal view returns (bytes memory) {
         (bool success, bytes memory returndata) = target.staticcall(data);
-        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+        return verifyCallResultFromTarget(target, success, returndata, onRevert);
     }
 
     /**
@@ -151,7 +170,7 @@ library Address {
      * _Available since v3.4._
      */
     function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
-        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
+        return functionDelegateCall(target, data, defaultOnRevert);
     }
 
     /**
@@ -163,57 +182,64 @@ library Address {
     function functionDelegateCall(
         address target,
         bytes memory data,
-        string memory errorMessage
+        function() internal pure onRevert
     ) internal returns (bytes memory) {
         (bool success, bytes memory returndata) = target.delegatecall(data);
-        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
+        return verifyCallResultFromTarget(target, success, returndata, onRevert);
     }
 
     /**
      * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
-     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
+     * the revert reason or using the provided `onRevert`) in case of unsuccessful call or if target was not a contract.
      *
      * _Available since v4.8._
      */
     function verifyCallResultFromTarget(
         address target,
         bool success,
         bytes memory returndata,
-        string memory errorMessage
+        function() internal pure onRevert
     ) internal view returns (bytes memory) {
         if (success) {
             if (returndata.length == 0) {
                 // only check if target is a contract if the call was successful and the return data is empty
                 // otherwise we already know that it was a contract
                 if (target.code.length == 0) {
-                    revert EmptyCode(target);
+                    revert AddressEmptyCode(target);
                 }
             }
             return returndata;
         } else {
-            _revert(returndata, errorMessage);
+            _revert(returndata, onRevert);
         }
     }
 
     /**
      * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
-     * revert reason or using the provided one.
+     * revert reason or using the provided `onRevert`.
      *
      * _Available since v4.3._
      */
     function verifyCallResult(
         bool success,
         bytes memory returndata,
-        string memory errorMessage
+        function() internal pure onRevert
     ) internal pure returns (bytes memory) {
         if (success) {
             return returndata;
         } else {
-            _revert(returndata, errorMessage);
+            _revert(returndata, onRevert);
         }
     }
 
-    function _revert(bytes memory returndata, string memory errorMessage) private pure {
+    /**
+     * @dev Default reverting function when no `onRevert` is provided in a function call.
+     */
+    function defaultOnRevert() internal pure {
+        revert AddressFailedLowLevelCall();
+    }
+
+    function _revert(bytes memory returndata, function() internal pure onRevert) private pure {
         // Look for revert reason and bubble it up if present
         if (returndata.length > 0) {
             // The easiest way to bubble the revert reason is using memory via assembly
@@ -223,7 +249,8 @@ library Address {
                 revert(add(32, returndata), returndata_size)
             }
         } else {
-            revert(errorMessage);
+            onRevert();
+            revert AddressExpectedRevert();
         }
     }
 }