Merge remote-tracking branch 'origin/chore/VRF-858-rename-packages' i…

…nto chore/VRF-858-rename-packages

contracts/scripts/generate-automation-master-interface.ts

@@ -2,9 +2,9 @@
  * @description this script generates a master interface for interacting with the automation registry
  * @notice run this script with pnpm ts-node ./scripts/generate-automation-master-interface.ts
  */
-import { KeeperRegistry2_2__factory as KeeperRegistry } from '../typechain/factories/KeeperRegistry2_2__factory'
-import { KeeperRegistryLogicA2_2__factory as KeeperRegistryLogicA } from '../typechain/factories/KeeperRegistryLogicA2_2__factory'
-import { KeeperRegistryLogicB2_2__factory as KeeperRegistryLogicB } from '../typechain/factories/KeeperRegistryLogicB2_2__factory'
+import { AutomationRegistry2_2__factory as Registry } from '../typechain/factories/AutomationRegistry2_2__factory'
+import { AutomationRegistryLogicA2_2__factory as RegistryLogicA } from '../typechain/factories/AutomationRegistryLogicA2_2__factory'
+import { AutomationRegistryLogicB2_2__factory as RegistryLogicB } from '../typechain/factories/AutomationRegistryLogicB2_2__factory'
 import { utils } from 'ethers'
 import fs from 'fs'
 import { exec } from 'child_process'
@@ -15,11 +15,7 @@ const tmpDest = `${dest}/tmp.txt`
 
 const combinedABI = []
 const abiSet = new Set()
-const abis = [
-  KeeperRegistry.abi,
-  KeeperRegistryLogicA.abi,
-  KeeperRegistryLogicB.abi,
-]
+const abis = [Registry.abi, RegistryLogicA.abi, RegistryLogicB.abi]
 
 for (const abi of abis) {
   for (const entry of abi) {

contracts/src/v0.8/automation/dev/v2_2/AutomationRegistryBase2_2.sol

@@ -740,7 +740,7 @@ abstract contract AutomationRegistryBase2_2 is ConfirmedOwner, ExecutionPreventi
       if (!_validateConditionalTrigger(upkeepId, rawTrigger, transmitInfo)) return (false, dedupID);
     } else if (transmitInfo.triggerType == Trigger.LOG) {
       bool valid;
-      (valid, dedupID) = _validateLogTrigger(upkeepId, rawTrigger, transmitInfo);
+      (valid, dedupID) = _validateLogTrigger(upkeepId, rawTrigger);
       if (!valid) return (false, dedupID);
     } else {
       revert InvalidTriggerType();
@@ -789,11 +789,7 @@ abstract contract AutomationRegistryBase2_2 is ConfirmedOwner, ExecutionPreventi
     return true;
   }
 
-  function _validateLogTrigger(
-    uint256 upkeepId,
-    bytes memory rawTrigger,
-    UpkeepTransmitInfo memory transmitInfo
-  ) internal returns (bool, bytes32) {
+  function _validateLogTrigger(uint256 upkeepId, bytes memory rawTrigger) internal returns (bool, bytes32) {
     LogTrigger memory trigger = abi.decode(rawTrigger, (LogTrigger));
     bytes32 dedupID = keccak256(abi.encodePacked(upkeepId, trigger.logBlockHash, trigger.txHash, trigger.logIndex));
     if (

contracts/src/v0.8/functions/dev/v1_X/accessControl/TermsOfServiceAllowList.sol

@@ -20,7 +20,7 @@ contract TermsOfServiceAllowList is ITermsOfServiceAllowList, IAccessController,
   string public constant override typeAndVersion = "Functions Terms of Service Allow List v1.1.0";
 
   EnumerableSet.AddressSet private s_allowedSenders;
-  mapping(address => bool) private s_blockedSenders;
+  EnumerableSet.AddressSet private s_blockedSenders;
 
   event AddedAccess(address user);
   event BlockedAccess(address user);
@@ -29,6 +29,7 @@ contract TermsOfServiceAllowList is ITermsOfServiceAllowList, IAccessController,
   error InvalidSignature();
   error InvalidUsage();
   error RecipientIsBlocked();
+  error InvalidCalldata();
 
   TermsOfServiceAllowListConfig private s_config;
 
@@ -70,7 +71,7 @@ contract TermsOfServiceAllowList is ITermsOfServiceAllowList, IAccessController,
 
   /// @inheritdoc ITermsOfServiceAllowList
   function acceptTermsOfService(address acceptor, address recipient, bytes32 r, bytes32 s, uint8 v) external override {
-    if (s_blockedSenders[recipient]) {
+    if (s_blockedSenders.contains(recipient)) {
       revert RecipientIsBlocked();
     }
 
@@ -101,6 +102,32 @@ contract TermsOfServiceAllowList is ITermsOfServiceAllowList, IAccessController,
     return s_allowedSenders.values();
   }
 
+  /// @inheritdoc ITermsOfServiceAllowList
+  function getAllowedSendersCount() external view override returns (uint64) {
+    return uint64(s_allowedSenders.length());
+  }
+
+  /// @inheritdoc ITermsOfServiceAllowList
+  function getAllowedSendersInRange(
+    uint64 allowedSenderIdxStart,
+    uint64 allowedSenderIdxEnd
+  ) external view override returns (address[] memory allowedSenders) {
+    if (
+      allowedSenderIdxStart > allowedSenderIdxEnd ||
+      allowedSenderIdxEnd >= s_allowedSenders.length() ||
+      s_allowedSenders.length() == 0
+    ) {
+      revert InvalidCalldata();
+    }
+
+    allowedSenders = new address[]((allowedSenderIdxEnd - allowedSenderIdxStart) + 1);
+    for (uint256 i = 0; i <= allowedSenderIdxEnd - allowedSenderIdxStart; ++i) {
+      allowedSenders[i] = s_allowedSenders.at(uint256(allowedSenderIdxStart + i));
+    }
+
+    return allowedSenders;
+  }
+
   /// @inheritdoc IAccessController
   function hasAccess(address user, bytes calldata /* data */) external view override returns (bool) {
     if (!s_config.enabled) {
@@ -118,19 +145,45 @@ contract TermsOfServiceAllowList is ITermsOfServiceAllowList, IAccessController,
     if (!s_config.enabled) {
       return false;
     }
-    return s_blockedSenders[sender];
+    return s_blockedSenders.contains(sender);
   }
 
   /// @inheritdoc ITermsOfServiceAllowList
   function blockSender(address sender) external override onlyOwner {
     s_allowedSenders.remove(sender);
-    s_blockedSenders[sender] = true;
+    s_blockedSenders.add(sender);
     emit BlockedAccess(sender);
   }
 
   /// @inheritdoc ITermsOfServiceAllowList
   function unblockSender(address sender) external override onlyOwner {
-    s_blockedSenders[sender] = false;
+    s_blockedSenders.remove(sender);
     emit UnblockedAccess(sender);
   }
+
+  /// @inheritdoc ITermsOfServiceAllowList
+  function getBlockedSendersCount() external view override returns (uint64) {
+    return uint64(s_blockedSenders.length());
+  }
+
+  /// @inheritdoc ITermsOfServiceAllowList
+  function getBlockedSendersInRange(
+    uint64 blockedSenderIdxStart,
+    uint64 blockedSenderIdxEnd
+  ) external view override returns (address[] memory blockedSenders) {
+    if (
+      blockedSenderIdxStart > blockedSenderIdxEnd ||
+      blockedSenderIdxEnd >= s_blockedSenders.length() ||
+      s_blockedSenders.length() == 0
+    ) {
+      revert InvalidCalldata();
+    }
+
+    blockedSenders = new address[]((blockedSenderIdxEnd - blockedSenderIdxStart) + 1);
+    for (uint256 i = 0; i <= blockedSenderIdxEnd - blockedSenderIdxStart; ++i) {
+      blockedSenders[i] = s_blockedSenders.at(uint256(blockedSenderIdxStart + i));
+    }
+
+    return blockedSenders;
+  }
 }

contracts/src/v0.8/functions/dev/v1_X/accessControl/interfaces/ITermsOfServiceAllowList.sol

@@ -22,6 +22,22 @@ interface ITermsOfServiceAllowList {
   /// @return addresses - all allowed addresses
   function getAllAllowedSenders() external view returns (address[] memory);
 
+  /// @notice Get details about the total number of allowed senders
+  /// @return count - total number of allowed senders in the system
+  function getAllowedSendersCount() external view returns (uint64);
+
+  /// @notice Retrieve a list of allowed senders using an inclusive range
+  /// @dev WARNING: getAllowedSendersInRange uses EnumerableSet .length() and .at() methods to iterate over the list
+  /// without the need for an extra mapping. These method can not guarantee the ordering when new elements are added.
+  /// Evaluate if eventual consistency will satisfy your usecase before using it.
+  /// @param allowedSenderIdxStart - index of the allowed sender to start the range at
+  /// @param allowedSenderIdxEnd - index of the allowed sender to end the range at
+  /// @return allowedSenders - allowed addresses in the range provided
+  function getAllowedSendersInRange(
+    uint64 allowedSenderIdxStart,
+    uint64 allowedSenderIdxEnd
+  ) external view returns (address[] memory allowedSenders);
+
   /// @notice Allows access to the sender based on acceptance of the Terms of Service
   /// @param acceptor - The wallet address that has accepted the Terms of Service on the UI
   /// @param recipient - The recipient address that the acceptor is taking responsibility for
@@ -37,6 +53,22 @@ interface ITermsOfServiceAllowList {
   /// @notice Re-allows a previously blocked sender to accept the Terms of Service
   /// @param sender - Address of the sender to unblock
   function unblockSender(address sender) external;
+
+  /// @notice Get details about the total number of blocked senders
+  /// @return count - total number of blocked senders in the system
+  function getBlockedSendersCount() external view returns (uint64);
+
+  /// @notice Retrieve a list of blocked senders using an inclusive range
+  /// @dev WARNING: getBlockedSendersInRange uses EnumerableSet .length() and .at() methods to iterate over the list
+  /// without the need for an extra mapping. These method can not guarantee the ordering when new elements are added.
+  /// Evaluate if eventual consistency will satisfy your usecase before using it.
+  /// @param blockedSenderIdxStart - index of the blocked sender to start the range at
+  /// @param blockedSenderIdxEnd - index of the blocked sender to end the range at
+  /// @return blockedSenders - blocked addresses in the range provided
+  function getBlockedSendersInRange(
+    uint64 blockedSenderIdxStart,
+    uint64 blockedSenderIdxEnd
+  ) external view returns (address[] memory blockedSenders);
 }
 
 // ================================================================

contracts/src/v0.8/functions/tests/v1_X/FunctionsTermsOfServiceAllowList.t.sol

@@ -247,6 +247,69 @@ contract FunctionsTermsOfServiceAllowList_GetAllAllowedSenders is FunctionsOwner
   }
 }
 
+/// @notice #getAllowedSendersCount
+contract FunctionsTermsOfServiceAllowList_GetAllowedSendersCount is FunctionsOwnerAcceptTermsOfServiceSetup {
+  function test_GetAllowedSendersCount_Success() public {
+    // Send as stranger
+    vm.stopPrank();
+    vm.startPrank(STRANGER_ADDRESS);
+
+    uint96 allowedSendersCount = s_termsOfServiceAllowList.getAllowedSendersCount();
+    // One allowed sender was made during setup
+    assertEq(allowedSendersCount, 1);
+  }
+}
+
+/// @notice #getAllowedSendersInRange
+contract FunctionsTermsOfServiceAllowList_GetAllowedSendersInRange is FunctionsOwnerAcceptTermsOfServiceSetup {
+  function test_GetAllowedSendersInRange_Success() public {
+    // Send as stranger
+    vm.stopPrank();
+    vm.startPrank(STRANGER_ADDRESS);
+
+    address[] memory expectedSenders = new address[](1);
+    expectedSenders[0] = OWNER_ADDRESS;
+
+    assertEq(s_termsOfServiceAllowList.getAllowedSendersInRange(0, 0), expectedSenders);
+  }
+
+  function test_GetAllowedSendersInRange_RevertIfAllowedSendersIsEmpty() public {
+    // setup a new empty s_termsOfServiceAllowList
+    FunctionsRoutesSetup.setUp();
+
+    // Send as stranger
+    vm.stopPrank();
+    vm.startPrank(STRANGER_ADDRESS);
+
+    uint64 AllowedSendersCount = s_termsOfServiceAllowList.getAllowedSendersCount();
+    uint64 expected = 0;
+    assertEq(AllowedSendersCount, expected);
+
+    vm.expectRevert(TermsOfServiceAllowList.InvalidCalldata.selector);
+    s_termsOfServiceAllowList.getAllowedSendersInRange(0, 0);
+  }
+
+  function test_GetAllowedSendersInRange_RevertIfStartIsAfterEnd() public {
+    // Send as stranger
+    vm.stopPrank();
+    vm.startPrank(STRANGER_ADDRESS);
+
+    vm.expectRevert(TermsOfServiceAllowList.InvalidCalldata.selector);
+
+    s_termsOfServiceAllowList.getAllowedSendersInRange(1, 0);
+  }
+
+  function test_GetAllowedSendersInRange_RevertIfEndIsAfterLastAllowedSender() public {
+    // Send as stranger
+    vm.stopPrank();
+    vm.startPrank(STRANGER_ADDRESS);
+
+    uint64 AllowedSendersCount = s_termsOfServiceAllowList.getAllowedSendersCount();
+    vm.expectRevert(TermsOfServiceAllowList.InvalidCalldata.selector);
+    s_termsOfServiceAllowList.getAllowedSendersInRange(1, AllowedSendersCount + 1);
+  }
+}
+
 /// @notice #hasAccess
 contract FunctionsTermsOfServiceAllowList_HasAccess is FunctionsRoutesSetup {
   function test_HasAccess_FalseWhenEnabled() public {
@@ -373,3 +436,78 @@ contract FunctionsTermsOfServiceAllowList_UnblockSender is FunctionsRoutesSetup
     s_termsOfServiceAllowList.acceptTermsOfService(STRANGER_ADDRESS, STRANGER_ADDRESS, r, s, v);
   }
 }
+
+/// @notice #getBlockedSendersCount
+contract FunctionsTermsOfServiceAllowList_GetBlockedSendersCount is FunctionsRoutesSetup {
+  function setUp() public virtual override {
+    FunctionsRoutesSetup.setUp();
+
+    s_termsOfServiceAllowList.blockSender(STRANGER_ADDRESS);
+  }
+
+  function test_GetBlockedSendersCount_Success() public {
+    // Send as stranger
+    vm.stopPrank();
+    vm.startPrank(STRANGER_ADDRESS);
+
+    uint96 blockedSendersCount = s_termsOfServiceAllowList.getBlockedSendersCount();
+    // One blocked sender was made during setup
+    assertEq(blockedSendersCount, 1);
+  }
+}
+
+/// @notice #getBlockedSendersInRange
+contract FunctionsTermsOfServiceAllowList_GetBlockedSendersInRange is FunctionsRoutesSetup {
+  function setUp() public virtual override {
+    FunctionsRoutesSetup.setUp();
+
+    s_termsOfServiceAllowList.blockSender(STRANGER_ADDRESS);
+  }
+
+  function test_GetBlockedSendersInRange_Success() public {
+    // Send as stranger
+    vm.stopPrank();
+    vm.startPrank(STRANGER_ADDRESS);
+
+    address[] memory expectedBlockedSenders = new address[](1);
+    expectedBlockedSenders[0] = STRANGER_ADDRESS;
+
+    assertEq(s_termsOfServiceAllowList.getBlockedSendersInRange(0, 0), expectedBlockedSenders);
+  }
+
+  function test_GetBlockedSendersInRange_RevertIfAllowedSendersIsEmpty() public {
+    // setup a new empty s_termsOfServiceBlockList
+    FunctionsRoutesSetup.setUp();
+
+    // Send as stranger
+    vm.stopPrank();
+    vm.startPrank(STRANGER_ADDRESS);
+
+    uint64 BlockedSendersCount = s_termsOfServiceAllowList.getBlockedSendersCount();
+    uint64 expected = 0;
+    assertEq(BlockedSendersCount, expected);
+
+    vm.expectRevert(TermsOfServiceAllowList.InvalidCalldata.selector);
+    s_termsOfServiceAllowList.getBlockedSendersInRange(0, 0);
+  }
+
+  function test_GetBlockedSendersInRange_RevertIfStartIsAfterEnd() public {
+    // Send as stranger
+    vm.stopPrank();
+    vm.startPrank(STRANGER_ADDRESS);
+
+    vm.expectRevert(TermsOfServiceAllowList.InvalidCalldata.selector);
+
+    s_termsOfServiceAllowList.getBlockedSendersInRange(1, 0);
+  }
+
+  function test_GetBlockedSendersInRange_RevertIfEndIsAfterLastAllowedSender() public {
+    // Send as stranger
+    vm.stopPrank();
+    vm.startPrank(STRANGER_ADDRESS);
+
+    uint64 BlockedSendersCount = s_termsOfServiceAllowList.getBlockedSendersCount();
+    vm.expectRevert(TermsOfServiceAllowList.InvalidCalldata.selector);
+    s_termsOfServiceAllowList.getBlockedSendersInRange(1, BlockedSendersCount + 1);
+  }
+}