refactor: approved relays, jobs and selectors

.solhintignore

@@ -1,3 +1,2 @@
-solidity/contracts/utils/AutomateReady.sol
-solidity/contracts/utils/Types.sol
+solidity/interfaces/external/**
 *.ignore

solidity/contracts/AutomationVault.sol

@@ -4,7 +4,7 @@ pragma solidity 0.8.19;
 import {IAutomationVault} from '@interfaces/IAutomationVault.sol';
 import {IERC20, SafeERC20} from '@openzeppelin/token/ERC20/utils/SafeERC20.sol';
 import {EnumerableSet} from '@openzeppelin/utils/structs/EnumerableSet.sol';
-import {_ETH, _NULL} from '@utils/Constants.sol';
+import {_ETH, _ALL} from '@utils/Constants.sol';
 
 /**
  * @title  AutomationVault
@@ -23,12 +23,13 @@ contract AutomationVault is IAutomationVault {
   /**
    * @notice Callers that are approved to call a relay
    */
-  mapping(address _relay => EnumerableSet.AddressSet _enabledCallers) internal _relayEnabledCallers;
+  mapping(address _relay => EnumerableSet.AddressSet _enabledCallers) internal _relayCallers;
 
   /**
-   * @notice Selectors that are approved to be called
+   * @notice Relays that are approved to execute jobs with an specific selector
    */
-  mapping(address _job => EnumerableSet.Bytes32Set _enabledSelectors) internal _jobEnabledSelectors;
+  mapping(address _relay => mapping(address _job => EnumerableSet.Bytes32Set _enabledSelectors)) internal
+    _relayJobSelectors;
 
   /**
    * @notice List of approved relays
@@ -43,28 +44,30 @@ contract AutomationVault is IAutomationVault {
   /**
    * @param _owner The address of the owner
    */
-  constructor(address _owner) payable {
+  constructor(address _owner) {
     owner = _owner;
   }
 
   /// @inheritdoc IAutomationVault
-  function relayEnabledCallers(address _relay) external view returns (address[] memory _enabledCallers) {
-    _enabledCallers = _relayEnabledCallers[_relay].values();
+  function getRelayData(
+    address _relay,
+    address _job
+  ) public view returns (address[] memory _callers, bytes32[] memory _selectors) {
+    // Get the list of callers
+    _callers = _relayCallers[_relay].values();
+
+    // Get the list of selectors
+    _selectors = _relayJobSelectors[_relay][_job].values();
   }
 
   /// @inheritdoc IAutomationVault
-  function jobEnabledSelectors(address _job) external view returns (bytes32[] memory _enabledSelectors) {
-    _enabledSelectors = _jobEnabledSelectors[_job].values();
+  function relays() external view returns (address[] memory _listRelays) {
+    _listRelays = _relays.values();
   }
 
   /// @inheritdoc IAutomationVault
-  function relays() external view returns (address[] memory __relays) {
-    __relays = _relays.values();
-  }
-
-  /// @inheritdoc IAutomationVault
-  function jobs() external view returns (address[] memory __jobs) {
-    __jobs = _jobs.values();
+  function jobs() external view returns (address[] memory _listJobs) {
+    _listJobs = _jobs.values();
   }
 
   /// @inheritdoc IAutomationVault
@@ -81,7 +84,7 @@ contract AutomationVault is IAutomationVault {
   }
 
   /// @inheritdoc IAutomationVault
-  function withdrawFunds(address _token, uint256 _amount, address _receiver) external payable onlyOwner {
+  function withdrawFunds(address _token, uint256 _amount, address _receiver) external onlyOwner {
     // If the token is ETH, transfer the funds to the receiver, otherwise transfer the tokens
     if (_token == _ETH) {
       (bool _success,) = _receiver.call{value: _amount}('');
@@ -95,9 +98,12 @@ contract AutomationVault is IAutomationVault {
   }
 
   /// @inheritdoc IAutomationVault
-  function approveRelayCallers(address _relay, address[] calldata _callers) external onlyOwner {
-    // Get the list of enabled callers for the relay
-    EnumerableSet.AddressSet storage _enabledCallers = _relayEnabledCallers[_relay];
+  function approveRelayData(
+    address _relay,
+    address[] calldata _callers,
+    IAutomationVault.JobData[] calldata _jobsData
+  ) external onlyOwner {
+    if (_relay == address(0)) revert AutomationVault_RelayZero();
 
     // If the relay is not approved, add it to the list of relays
     if (_relays.add(_relay)) {
@@ -106,135 +112,143 @@ contract AutomationVault is IAutomationVault {
 
     // Iterate over the callers to approve them
     for (uint256 _i; _i < _callers.length;) {
-      if (_enabledCallers.add(_callers[_i])) {
+      if (_relayCallers[_relay].add(_callers[_i])) {
         emit ApproveRelayCaller(_relay, _callers[_i]);
       }
 
       unchecked {
         ++_i;
       }
     }
-  }
 
-  /// @inheritdoc IAutomationVault
-  function revokeRelayCallers(address _relay, address[] calldata _callers) external onlyOwner {
-    // Get the list of enabled callers for the relay
-    EnumerableSet.AddressSet storage _enabledCallers = _relayEnabledCallers[_relay];
+    // Iterate over the jobs to approve them and their selectors
+    for (uint256 _i; _i < _jobsData.length;) {
+      IAutomationVault.JobData memory _jobData = _jobsData[_i];
 
-    // Iterate over the callers to revoke them
-    for (uint256 _i; _i < _callers.length;) {
-      if (_enabledCallers.remove(_callers[_i])) {
-        emit RevokeRelayCaller(_relay, _callers[_i]);
+      // If the job is not approved, add it to the list of relays
+      if (_jobs.add(_jobData.job)) {
+        emit ApproveJob(_jobData.job);
+      }
+
+      // Iterate over the selectors to approve them
+      for (uint256 _j; _j < _jobData.functionSelectors.length;) {
+        if (_relayJobSelectors[_relay][_jobData.job].add(_jobData.functionSelectors[_j])) {
+          emit ApproveJobSelector(_jobData.job, _jobData.functionSelectors[_j]);
+        }
+
+        unchecked {
+          ++_j;
+        }
       }
 
       unchecked {
         ++_i;
       }
     }
-
-    // If the relay has no more callers, remove it from the list of relays
-    if (_enabledCallers.length() == 0) {
-      _relays.remove(_relay);
-      emit RevokeRelay(_relay);
-    }
   }
 
   /// @inheritdoc IAutomationVault
-  function approveJobSelectors(address _job, bytes4[] calldata _functionSelectors) external onlyOwner {
-    // Get the list of enabled selectors for the job
-    EnumerableSet.Bytes32Set storage _enabledSelectors = _jobEnabledSelectors[_job];
-
-    // If the job is not approved, add it to the list of jobs
-    if (_jobs.add(_job)) {
-      emit ApproveJob(_job);
-    }
+  function revokeRelayData(
+    address _relay,
+    address[] calldata _callers,
+    IAutomationVault.JobData[] calldata _jobsData
+  ) external onlyOwner {
+    if (_relay == address(0)) revert AutomationVault_RelayZero();
 
-    // Iterate over the selectors to approve them
-    for (uint256 _i; _i < _functionSelectors.length;) {
-      if (_enabledSelectors.add(_functionSelectors[_i])) {
-        emit ApproveJobSelector(_job, _functionSelectors[_i]);
+    // Iterate over the callers to revoke them
+    for (uint256 _i; _i < _callers.length;) {
+      if (_relayCallers[_relay].remove(_callers[_i])) {
+        emit RevokeRelayCaller(_relay, _callers[_i]);
       }
 
       unchecked {
         ++_i;
       }
+
+      // If the relay has no enabled callers, remove it from the list of relays
+      if (_relayCallers[_relay].length() == 0) {
+        _relays.remove(_relay);
+        emit RevokeRelay(_relay);
+      }
     }
-  }
 
-  /// @inheritdoc IAutomationVault
-  function revokeJobSelectors(address _job, bytes4[] calldata _functionSelectors) external onlyOwner {
-    // Get the list of enabled selectors for the job
-    EnumerableSet.Bytes32Set storage _enabledSelectors = _jobEnabledSelectors[_job];
-
-    // Iterate over the selectors to revoke them
-    for (uint256 _i; _i < _functionSelectors.length;) {
-      if (_enabledSelectors.remove(_functionSelectors[_i])) {
-        emit RevokeJobSelector(_job, _functionSelectors[_i]);
+    // Iterate over the jobs to revoke them and their selectors
+    for (uint256 _i; _i < _jobsData.length;) {
+      IAutomationVault.JobData memory _jobData = _jobsData[_i];
+
+      // Iterate over the selectors to revoke them
+      for (uint256 _j; _j < _jobData.functionSelectors.length;) {
+        if (_relayJobSelectors[_relay][_jobData.job].remove(_jobData.functionSelectors[_j])) {
+          emit RevokeJobSelector(_jobData.job, _jobData.functionSelectors[_j]);
+        }
+
+        unchecked {
+          ++_j;
+        }
+      }
+
+      if (_relayJobSelectors[_relay][_jobData.job].length() == 0) {
+        _jobs.remove(_jobData.job);
+        emit RevokeJob(_jobData.job);
       }
 
       unchecked {
         ++_i;
       }
     }
-
-    // If the job has no more selectors, remove it from the list of jobs
-    if (_enabledSelectors.length() == 0) {
-      _jobs.remove(_job);
-      emit RevokeJob(_job);
-    }
   }
 
   /// @inheritdoc IAutomationVault
-  function exec(address _relayCaller, ExecData[] calldata _execData, FeeData[] calldata _feeData) external payable {
+  function exec(address _relayCaller, ExecData[] calldata _execData, FeeData[] calldata _feeData) external {
     // Check that the specific caller is approved to call the relay
-    if (!_relayEnabledCallers[msg.sender].contains(_relayCaller) && !_relayEnabledCallers[msg.sender].contains(_NULL)) {
+    if (!_relayCallers[msg.sender].contains(_relayCaller) && !_relayCallers[msg.sender].contains(_ALL)) {
       revert AutomationVault_NotApprovedRelayCaller();
     }
 
     // Create the exec data needed variables
-    ExecData memory _execDatum;
+    ExecData memory _dataToExecute;
     uint256 _dataLength = _execData.length;
     uint256 _i;
     bool _success;
 
     // Iterate over the exec data to execute the jobs
     for (_i; _i < _dataLength;) {
-      _execDatum = _execData[_i];
+      _dataToExecute = _execData[_i];
 
       // Check that the selector is approved to be called
-      if (!_jobEnabledSelectors[_execDatum.job].contains(bytes4(_execDatum.jobData))) {
+      if (!_relayJobSelectors[msg.sender][_dataToExecute.job].contains(bytes4(_dataToExecute.jobData))) {
         revert AutomationVault_NotApprovedJobSelector();
       }
-      (_success,) = _execDatum.job.call(_execDatum.jobData);
+      (_success,) = _dataToExecute.job.call(_dataToExecute.jobData);
       if (!_success) revert AutomationVault_ExecFailed();
 
       // Emit the event
-      emit JobExecuted(msg.sender, _relayCaller, _execDatum.job, _execDatum.jobData);
+      emit JobExecuted(msg.sender, _relayCaller, _dataToExecute.job, _dataToExecute.jobData);
 
       unchecked {
         ++_i;
       }
     }
 
     // Create the fee data needed variables
-    FeeData memory _feeDatum;
+    FeeData memory _dataToFee;
     _dataLength = _feeData.length;
     _i = 0;
 
     // Iterate over the fee data to issue the payments
     for (_i; _i < _dataLength;) {
-      _feeDatum = _feeData[_i];
+      _dataToFee = _feeData[_i];
 
       // If the token is ETH, transfer the funds to the receiver, otherwise transfer the tokens
-      if (_feeDatum.feeToken == _ETH) {
-        (_success,) = _feeDatum.feeRecipient.call{value: _feeDatum.fee}('');
+      if (_dataToFee.feeToken == _ETH) {
+        (_success,) = _dataToFee.feeRecipient.call{value: _dataToFee.fee}('');
         if (!_success) revert AutomationVault_ETHTransferFailed();
       } else {
-        IERC20(_feeDatum.feeToken).safeTransfer(_feeDatum.feeRecipient, _feeDatum.fee);
+        IERC20(_dataToFee.feeToken).safeTransfer(_dataToFee.feeRecipient, _dataToFee.fee);
       }
 
       // Emit the event
-      emit IssuePayment(msg.sender, _relayCaller, _feeDatum.feeRecipient, _feeDatum.feeToken, _feeDatum.fee);
+      emit IssuePayment(msg.sender, _relayCaller, _dataToFee.feeRecipient, _dataToFee.feeToken, _dataToFee.fee);
 
       unchecked {
         ++_i;
@@ -247,7 +261,7 @@ contract AutomationVault is IAutomationVault {
    */
   modifier onlyOwner() {
     address _owner = owner;
-    if (msg.sender != _owner) revert AutomationVault_OnlyOwner(_owner);
+    if (msg.sender != _owner) revert AutomationVault_OnlyOwner();
     _;
   }
 
@@ -256,7 +270,7 @@ contract AutomationVault is IAutomationVault {
    */
   modifier onlyPendingOwner() {
     address _pendingOwner = pendingOwner;
-    if (msg.sender != _pendingOwner) revert AutomationVault_OnlyPendingOwner(_pendingOwner);
+    if (msg.sender != _pendingOwner) revert AutomationVault_OnlyPendingOwner();
     _;
   }
 

solidity/contracts/AutomationVaultFactory.sol

@@ -49,9 +49,9 @@ contract AutomationVaultFactory is IAutomationVaultFactory {
   }
 
   /// @inheritdoc IAutomationVaultFactory
-  function deployAutomationVault(address _owner) external returns (IAutomationVault _automationVault) {
+  function deployAutomationVault(address _owner, uint256 _salt) external returns (IAutomationVault _automationVault) {
     // Create the new automation vault with the owner
-    _automationVault = new AutomationVault(_owner);
+    _automationVault = new AutomationVault{salt: keccak256(abi.encodePacked(msg.sender, _salt))}(_owner);
 
     // Add the automation vault to the list of automation vaults
     _automationVaults.add(address(_automationVault));

solidity/contracts/Keep3rBondedRelay.sol

@@ -17,7 +17,7 @@ contract Keep3rBondedRelay is IKeep3rBondedRelay {
   /// @inheritdoc IKeep3rBondedRelay
   function setAutomationVaultRequirements(
     IAutomationVault _automationVault,
-    IKeep3rBondedRelay.Requirements memory _requirements
+    IKeep3rBondedRelay.Requirements calldata _requirements
   ) external {
     if (_automationVault.owner() != msg.sender) revert Keep3rBondedRelay_NotVaultOwner();