fixup: lint

Author: matiasedgeandnode

packages/horizon/contracts/payments/collectors/GraphTallyCollector.sol

@@ -10,7 +10,6 @@ import { PPMMath } from "../../libraries/PPMMath.sol";
 
 import { GraphDirectory } from "../../utilities/GraphDirectory.sol";
 import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
-import { MessageHashUtils } from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
 
 /**
  * @title GraphTallyCollector contract

packages/horizon/contracts/utilities/Authorizable.sol

@@ -20,84 +20,91 @@ abstract contract Authorizable is IAuthorizable {
     uint256 public immutable REVOKE_AUTHORIZATION_THAWING_PERIOD;
 
     /// @notice Authorization details for authorizer-signer pairs
-    mapping(address signer => Authorization authorization) private authorizations;
+    mapping(address signer => Authorization authorization) private _authorizations;
 
     /**
-     * @notice Constructs a new instance of the Authorizable contract.
-     * @param _revokeAuthorizationThawingPeriod The duration (in seconds) for which an authorization is thawing before it can be revoked.
+     * @dev Revert if the caller has not authorized the signer
      */
-    constructor(uint256 _revokeAuthorizationThawingPeriod) {
-        REVOKE_AUTHORIZATION_THAWING_PERIOD = _revokeAuthorizationThawingPeriod;
+    modifier onlyAuthorized(address signer) {
+        _requireAuthorized(msg.sender, signer);
+        _;
     }
 
     /**
-     * @dev Revert if the caller has not authorized the signer
+     * @notice Constructs a new instance of the Authorizable contract.
+     * @param revokeAuthorizationThawingPeriod The duration (in seconds) for which an authorization is thawing before it can be revoked.
      */
-    modifier onlyAuthorized(address _signer) {
-        _requireAuthorized(msg.sender, _signer);
-        _;
+    constructor(uint256 revokeAuthorizationThawingPeriod) {
+        REVOKE_AUTHORIZATION_THAWING_PERIOD = revokeAuthorizationThawingPeriod;
     }
 
     /**
      * See {IAuthorizable.authorizeSigner}.
      */
-    function authorizeSigner(address _signer, uint256 _proofDeadline, bytes calldata _proof) external {
+    function authorizeSigner(address signer, uint256 proofDeadline, bytes calldata proof) external {
         require(
-            authorizations[_signer].authorizer == address(0),
+            _authorizations[signer].authorizer == address(0),
             AuthorizableSignerAlreadyAuthorized(
-                authorizations[_signer].authorizer,
-                _signer,
-                authorizations[_signer].revoked
+                _authorizations[signer].authorizer,
+                signer,
+                _authorizations[signer].revoked
             )
         );
-        _verifyAuthorizationProof(_proof, _proofDeadline, _signer);
-        authorizations[_signer].authorizer = msg.sender;
-        emit SignerAuthorized(msg.sender, _signer);
+        _verifyAuthorizationProof(proof, proofDeadline, signer);
+        _authorizations[signer].authorizer = msg.sender;
+        emit SignerAuthorized(msg.sender, signer);
     }
 
     /**
      * See {IAuthorizable.thawSigner}.
      */
-    function thawSigner(address _signer) external onlyAuthorized(_signer) {
-        authorizations[_signer].thawEndTimestamp = block.timestamp + REVOKE_AUTHORIZATION_THAWING_PERIOD;
-        emit SignerThawing(msg.sender, _signer, authorizations[_signer].thawEndTimestamp);
+    function thawSigner(address signer) external onlyAuthorized(signer) {
+        _authorizations[signer].thawEndTimestamp = block.timestamp + REVOKE_AUTHORIZATION_THAWING_PERIOD;
+        emit SignerThawing(msg.sender, signer, _authorizations[signer].thawEndTimestamp);
     }
 
     /**
      * See {IAuthorizable.cancelThawSigner}.
      */
-    function cancelThawSigner(address _signer) external onlyAuthorized(_signer) {
-        require(authorizations[_signer].thawEndTimestamp > 0, AuthorizableSignerNotThawing(_signer));
-        uint256 thawEnd = authorizations[_signer].thawEndTimestamp;
-        authorizations[_signer].thawEndTimestamp = 0;
-        emit SignerThawCanceled(msg.sender, _signer, thawEnd);
+    function cancelThawSigner(address signer) external onlyAuthorized(signer) {
+        require(_authorizations[signer].thawEndTimestamp > 0, AuthorizableSignerNotThawing(signer));
+        uint256 thawEnd = _authorizations[signer].thawEndTimestamp;
+        _authorizations[signer].thawEndTimestamp = 0;
+        emit SignerThawCanceled(msg.sender, signer, thawEnd);
     }
 
     /**
      * See {IAuthorizable.revokeAuthorizedSigner}.
      */
-    function revokeAuthorizedSigner(address _signer) external onlyAuthorized(_signer) {
-        uint256 thawEndTimestamp = authorizations[_signer].thawEndTimestamp;
-        require(thawEndTimestamp > 0, AuthorizableSignerNotThawing(_signer));
+    function revokeAuthorizedSigner(address signer) external onlyAuthorized(signer) {
+        uint256 thawEndTimestamp = _authorizations[signer].thawEndTimestamp;
+        require(thawEndTimestamp > 0, AuthorizableSignerNotThawing(signer));
         require(thawEndTimestamp <= block.timestamp, AuthorizableSignerStillThawing(block.timestamp, thawEndTimestamp));
-        authorizations[_signer].revoked = true;
-        emit SignerRevoked(msg.sender, _signer);
+        _authorizations[signer].revoked = true;
+        emit SignerRevoked(msg.sender, signer);
+    }
+
+    /**
+     * See {IAuthorizable.getThawEnd}.
+     */
+    function getThawEnd(address signer) external view returns (uint256) {
+        return _authorizations[signer].thawEndTimestamp;
     }
 
     /**
      * See {IAuthorizable.isAuthorized}.
      */
-    function isAuthorized(address _authorizer, address _signer) external view returns (bool) {
-        return _isAuthorized(_authorizer, _signer);
+    function isAuthorized(address authorizer, address signer) external view returns (bool) {
+        return _isAuthorized(authorizer, signer);
     }
 
     /**
      * See {IAuthorizable.isAuthorized}.
      */
     function _isAuthorized(address _authorizer, address _signer) internal view returns (bool) {
         return (_authorizer != address(0) &&
-            authorizations[_signer].authorizer == _authorizer &&
-            !authorizations[_signer].revoked);
+            _authorizations[_signer].authorizer == _authorizer &&
+            !_authorizations[_signer].revoked);
     }
 
     /**
@@ -109,13 +116,6 @@ abstract contract Authorizable is IAuthorizable {
         require(_isAuthorized(_authorizer, _signer), AuthorizableSignerNotAuthorized(_authorizer, _signer));
     }
 
-    /**
-     * See {IAuthorizable.getThawEnd}.
-     */
-    function getThawEnd(address _signer) external view returns (uint256) {
-        return authorizations[_signer].thawEndTimestamp;
-    }
-
     /**
      * @notice Verify the authorization proof provided by the authorizer
      * @param _proof The proof provided by the authorizer