Add deprecateCapability

.changeset/beige-papayas-develop.md

@@ -0,0 +1,5 @@
+---
+"chainlink": patch
+---
+
+#internal

.changeset/early-cats-check.md

@@ -0,0 +1,5 @@
+---
+"chainlink": patch
+---
+
+#internal

contracts/.changeset/bright-dingos-attend.md

@@ -0,0 +1,5 @@
+---
+"@chainlink/contracts": patch
+---
+
+#internal

contracts/.changeset/plenty-ligers-joke.md

@@ -0,0 +1,5 @@
+---
+"@chainlink/contracts": patch
+---
+
+#internal

contracts/src/v0.8/keystone/CapabilityRegistry.sol

@@ -74,6 +74,16 @@ contract CapabilityRegistry is OwnerIsCreator, TypeAndVersionInterface {
   /// exists.
   error CapabilityAlreadyExists();
 
+  /// @notice This error is thrown when a capability with the provided ID is
+  /// not found.
+  /// @param capabilityId The ID used for the lookup.
+  error CapabilityDoesNotExist(bytes32 capabilityId);
+
+  /// @notice This error is thrown when trying to deprecate a capability that
+  /// is already deprecated.
+  /// @param capabilityId The ID of the capability that is already deprecated.
+  error CapabilityIsDeprecated(bytes32 capabilityId);
+
   /// @notice This error is thrown when trying to add a capability with a
   /// configuration contract that does not implement the required interface.
   /// @param proposedConfigurationContract The address of the proposed
@@ -101,8 +111,13 @@ contract CapabilityRegistry is OwnerIsCreator, TypeAndVersionInterface {
   /// @param capabilityId The ID of the newly added capability
   event CapabilityAdded(bytes32 indexed capabilityId);
 
+  /// @notice This event is emitted when a capability is deprecated
+  /// @param capabilityId The ID of the deprecated capability
+  event CapabilityDeprecated(bytes32 indexed capabilityId);
+
   mapping(bytes32 => Capability) private s_capabilities;
   EnumerableSet.Bytes32Set private s_capabilityIds;
+  EnumerableSet.Bytes32Set private s_deprecatedCapabilityIds;
 
   /// @notice Mapping of node operators
   mapping(uint256 nodeOperatorId => NodeOperator) private s_nodeOperators;
@@ -189,13 +204,57 @@ contract CapabilityRegistry is OwnerIsCreator, TypeAndVersionInterface {
     emit CapabilityAdded(capabilityId);
   }
 
+  /// @notice Deprecates a capability by adding it to the deprecated list
+  /// @param capabilityId The ID of the capability to deprecate
+  function deprecateCapability(bytes32 capabilityId) external onlyOwner {
+    if (!s_capabilityIds.contains(capabilityId)) revert CapabilityDoesNotExist(capabilityId);
+    if (s_deprecatedCapabilityIds.contains(capabilityId)) revert CapabilityIsDeprecated(capabilityId);
+
+    s_deprecatedCapabilityIds.add(capabilityId);
+    emit CapabilityDeprecated(capabilityId);
+  }
+
   function getCapability(bytes32 capabilityID) public view returns (Capability memory) {
     return s_capabilities[capabilityID];
   }
 
+  /// @notice Returns all capabilities. This operation will copy capabilities
+  /// to memory, which can be quite expensive. This is designed to mostly be
+  /// used by view accessors that are queried without any gas fees.
+  /// @return Capability[] An array of capabilities
+  function getCapabilities() external view returns (Capability[] memory) {
+    bytes32[] memory capabilityIds = s_capabilityIds.values();
+
+    // Solidity does not support dynamic arrays in memory, so we create a
+    // fixed-size array and copy the capabilities into it.
+    Capability[] memory capabilities = new Capability[](capabilityIds.length - s_deprecatedCapabilityIds.length());
+
+    // We need to keep track of the new index because we are skipping
+    // deprecated capabilities.
+    uint256 newIndex;
+
+    for (uint256 i; i < capabilityIds.length; ++i) {
+      bytes32 capabilityId = capabilityIds[i];
+
+      if (!s_deprecatedCapabilityIds.contains(capabilityId)) {
+        capabilities[newIndex] = getCapability(capabilityId);
+        newIndex++;
+      }
+    }
+
+    return capabilities;
+  }
+
   /// @notice This functions returns a Capability ID packed into a bytes32 for cheaper access
   /// @return bytes32 A unique identifier for the capability
   function getCapabilityID(bytes32 capabilityType, bytes32 version) public pure returns (bytes32) {
     return keccak256(abi.encodePacked(capabilityType, version));
   }
+
+  /// @notice Returns whether a capability is deprecated
+  /// @param capabilityId The ID of the capability to check
+  /// @return bool True if the capability is deprecated, false otherwise
+  function isCapabilityDeprecated(bytes32 capabilityId) external view returns (bool) {
+    return s_deprecatedCapabilityIds.contains(capabilityId);
+  }
 }

contracts/src/v0.8/keystone/test/BaseTest.t.sol

@@ -9,11 +9,27 @@ import {CapabilityRegistry} from "../CapabilityRegistry.sol";
 contract BaseTest is Test, Constants {
   CapabilityRegistry internal s_capabilityRegistry;
   CapabilityConfigurationContract internal s_capabilityConfigurationContract;
+  CapabilityRegistry.Capability internal s_basicCapability;
+  CapabilityRegistry.Capability internal s_capabilityWithConfigurationContract;
 
   function setUp() public virtual {
     vm.startPrank(ADMIN);
     s_capabilityRegistry = new CapabilityRegistry();
     s_capabilityConfigurationContract = new CapabilityConfigurationContract();
+
+    s_basicCapability = CapabilityRegistry.Capability({
+      capabilityType: "data-streams-reports",
+      version: "1.0.0",
+      responseType: CapabilityRegistry.CapabilityResponseType.REPORT,
+      configurationContract: address(0)
+    });
+
+    s_capabilityWithConfigurationContract = CapabilityRegistry.Capability({
+      capabilityType: "read-ethereum-mainnet-gas-price",
+      version: "1.0.2",
+      responseType: CapabilityRegistry.CapabilityResponseType.OBSERVATION_IDENTICAL,
+      configurationContract: address(s_capabilityConfigurationContract)
+    });
   }
 
   function _getNodeOperators() internal view returns (CapabilityRegistry.NodeOperator[] memory) {

contracts/src/v0.8/keystone/test/CapabilityRegistry_AddCapabilityTest.t.sol

@@ -7,83 +7,67 @@ import {CapabilityConfigurationContract} from "./mocks/CapabilityConfigurationCo
 import {CapabilityRegistry} from "../CapabilityRegistry.sol";
 
 contract CapabilityRegistry_AddCapabilityTest is BaseTest {
-  CapabilityRegistry.Capability private basicCapability =
-    CapabilityRegistry.Capability({
-      capabilityType: "data-streams-reports",
-      version: "1.0.0",
-      responseType: CapabilityRegistry.CapabilityResponseType.REPORT,
-      configurationContract: address(0)
-    });
-
-  CapabilityRegistry.Capability private capabilityWithConfigurationContract =
-    CapabilityRegistry.Capability({
-      capabilityType: "read-ethereum-mainnet-gas-price",
-      version: "1.0.2",
-      responseType: CapabilityRegistry.CapabilityResponseType.OBSERVATION_IDENTICAL,
-      configurationContract: address(s_capabilityConfigurationContract)
-    });
-
   function test_RevertWhen_CalledByNonAdmin() public {
     changePrank(STRANGER);
 
     vm.expectRevert("Only callable by owner");
-    s_capabilityRegistry.addCapability(basicCapability);
+    s_capabilityRegistry.addCapability(s_basicCapability);
   }
 
   function test_RevertWhen_CapabilityExists() public {
     // Successfully add the capability the first time
-    s_capabilityRegistry.addCapability(basicCapability);
+    s_capabilityRegistry.addCapability(s_basicCapability);
 
     // Try to add the same capability again
     vm.expectRevert(CapabilityRegistry.CapabilityAlreadyExists.selector);
-    s_capabilityRegistry.addCapability(basicCapability);
+    s_capabilityRegistry.addCapability(s_basicCapability);
   }
 
   function test_RevertWhen_ConfigurationContractNotDeployed() public {
     address nonExistentContract = address(1);
-    capabilityWithConfigurationContract.configurationContract = nonExistentContract;
+    s_capabilityWithConfigurationContract.configurationContract = nonExistentContract;
 
     vm.expectRevert(
       abi.encodeWithSelector(
         CapabilityRegistry.InvalidCapabilityConfigurationContractInterface.selector,
         nonExistentContract
       )
     );
-    s_capabilityRegistry.addCapability(capabilityWithConfigurationContract);
+    s_capabilityRegistry.addCapability(s_capabilityWithConfigurationContract);
   }
 
   function test_RevertWhen_ConfigurationContractDoesNotMatchInterface() public {
     CapabilityRegistry contractWithoutERC165 = new CapabilityRegistry();
 
     vm.expectRevert();
-    capabilityWithConfigurationContract.configurationContract = address(contractWithoutERC165);
-    s_capabilityRegistry.addCapability(capabilityWithConfigurationContract);
+    s_capabilityWithConfigurationContract.configurationContract = address(contractWithoutERC165);
+    s_capabilityRegistry.addCapability(s_capabilityWithConfigurationContract);
   }
 
   function test_AddCapability_NoConfigurationContract() public {
-    s_capabilityRegistry.addCapability(basicCapability);
+    s_capabilityRegistry.addCapability(s_basicCapability);
 
     bytes32 capabilityId = s_capabilityRegistry.getCapabilityID(bytes32("data-streams-reports"), bytes32("1.0.0"));
     CapabilityRegistry.Capability memory storedCapability = s_capabilityRegistry.getCapability(capabilityId);
 
-    assertEq(storedCapability.capabilityType, basicCapability.capabilityType);
-    assertEq(storedCapability.version, basicCapability.version);
-    assertEq(uint256(storedCapability.responseType), uint256(basicCapability.responseType));
-    assertEq(storedCapability.configurationContract, basicCapability.configurationContract);
+    assertEq(storedCapability.capabilityType, s_basicCapability.capabilityType);
+    assertEq(storedCapability.version, s_basicCapability.version);
+    assertEq(uint256(storedCapability.responseType), uint256(s_basicCapability.responseType));
+    assertEq(storedCapability.configurationContract, s_basicCapability.configurationContract);
   }
 
   function test_AddCapability_WithConfiguration() public {
-    s_capabilityRegistry.addCapability(capabilityWithConfigurationContract);
+    s_capabilityRegistry.addCapability(s_capabilityWithConfigurationContract);
 
     bytes32 capabilityId = s_capabilityRegistry.getCapabilityID(
-      bytes32(capabilityWithConfigurationContract.capabilityType),
-      bytes32(capabilityWithConfigurationContract.version)
+      bytes32(s_capabilityWithConfigurationContract.capabilityType),
+      bytes32(s_capabilityWithConfigurationContract.version)
     );
     CapabilityRegistry.Capability memory storedCapability = s_capabilityRegistry.getCapability(capabilityId);
 
-    assertEq(storedCapability.capabilityType, capabilityWithConfigurationContract.capabilityType);
-    assertEq(storedCapability.version, capabilityWithConfigurationContract.version);
-    assertEq(uint256(storedCapability.responseType), uint256(capabilityWithConfigurationContract.responseType));
-    assertEq(storedCapability.configurationContract, capabilityWithConfigurationContract.configurationContract);
+    assertEq(storedCapability.capabilityType, s_capabilityWithConfigurationContract.capabilityType);
+    assertEq(storedCapability.version, s_capabilityWithConfigurationContract.version);
+    assertEq(uint256(storedCapability.responseType), uint256(s_capabilityWithConfigurationContract.responseType));
+    assertEq(storedCapability.configurationContract, s_capabilityWithConfigurationContract.configurationContract);
   }
 }

contracts/src/v0.8/keystone/test/CapabilityRegistry_DeprecateCapability.t.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import {BaseTest} from "./BaseTest.t.sol";
+
+import {CapabilityRegistry} from "../CapabilityRegistry.sol";
+
+contract CapabilityRegistry_AddCapabilityTest is BaseTest {
+  event CapabilityDeprecated(bytes32 indexed capabilityId);
+
+  function setUp() public override {
+    BaseTest.setUp();
+
+    s_capabilityRegistry.addCapability(s_basicCapability);
+    s_capabilityRegistry.addCapability(s_capabilityWithConfigurationContract);
+  }
+
+  function test_RevertWhen_CalledByNonAdmin() public {
+    changePrank(STRANGER);
+    bytes32 capabilityId = s_capabilityRegistry.getCapabilityID(
+      s_basicCapability.capabilityType,
+      s_basicCapability.version
+    );
+
+    vm.expectRevert("Only callable by owner");
+    s_capabilityRegistry.deprecateCapability(capabilityId);
+  }
+
+  function test_RevertWhen_CapabilityDoesNotExist() public {
+    bytes32 capabilityId = s_capabilityRegistry.getCapabilityID("non-existent-capability", "1.0.0");
+
+    vm.expectRevert(abi.encodeWithSelector(CapabilityRegistry.CapabilityDoesNotExist.selector, capabilityId));
+    s_capabilityRegistry.deprecateCapability(capabilityId);
+  }
+
+  function test_RevertWhen_CapabilityIsDeprecated() public {
+    bytes32 capabilityId = s_capabilityRegistry.getCapabilityID(
+      s_basicCapability.capabilityType,
+      s_basicCapability.version
+    );
+
+    s_capabilityRegistry.deprecateCapability(capabilityId);
+
+    vm.expectRevert(abi.encodeWithSelector(CapabilityRegistry.CapabilityIsDeprecated.selector, capabilityId));
+    s_capabilityRegistry.deprecateCapability(capabilityId);
+  }
+
+  function test_DeprecatesCapability() public {
+    bytes32 capabilityId = s_capabilityRegistry.getCapabilityID(
+      s_basicCapability.capabilityType,
+      s_basicCapability.version
+    );
+
+    s_capabilityRegistry.deprecateCapability(capabilityId);
+
+    assertEq(s_capabilityRegistry.isCapabilityDeprecated(capabilityId), true);
+  }
+
+  function test_EmitsEvent() public {
+    bytes32 capabilityId = s_capabilityRegistry.getCapabilityID(
+      s_basicCapability.capabilityType,
+      s_basicCapability.version
+    );
+
+    vm.expectEmit(address(s_capabilityRegistry));
+    emit CapabilityDeprecated(capabilityId);
+    s_capabilityRegistry.deprecateCapability(capabilityId);
+  }
+}

contracts/src/v0.8/keystone/test/CapabilityRegistry_GetCapabilityIds.t.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import {BaseTest} from "./BaseTest.t.sol";
+import {CapabilityRegistry} from "../CapabilityRegistry.sol";
+
+contract CapabilityRegistry_GetCapabilitiesTest is BaseTest {
+  function setUp() public override {
+    BaseTest.setUp();
+
+    s_capabilityRegistry.addCapability(s_basicCapability);
+    s_capabilityRegistry.addCapability(s_capabilityWithConfigurationContract);
+  }
+
+  function test_ReturnsCapabilities() public {
+    CapabilityRegistry.Capability[] memory capabilities = s_capabilityRegistry.getCapabilities();
+
+    assertEq(capabilities.length, 2);
+
+    assertEq(capabilities[0].capabilityType, "data-streams-reports");
+    assertEq(capabilities[0].version, "1.0.0");
+    assertEq(uint256(capabilities[0].responseType), uint256(CapabilityRegistry.CapabilityResponseType.REPORT));
+    assertEq(capabilities[0].configurationContract, address(0));
+
+    assertEq(capabilities[1].capabilityType, "read-ethereum-mainnet-gas-price");
+    assertEq(capabilities[1].version, "1.0.2");
+    assertEq(
+      uint256(capabilities[1].responseType),
+      uint256(CapabilityRegistry.CapabilityResponseType.OBSERVATION_IDENTICAL)
+    );
+    assertEq(capabilities[1].configurationContract, address(s_capabilityConfigurationContract));
+  }
+
+  function test_ExcludesDeprecatedCapabilities() public {
+    bytes32 capabilityId = s_capabilityRegistry.getCapabilityID(
+      s_basicCapability.capabilityType,
+      s_basicCapability.version
+    );
+    s_capabilityRegistry.deprecateCapability(capabilityId);
+
+    CapabilityRegistry.Capability[] memory capabilities = s_capabilityRegistry.getCapabilities();
+    assertEq(capabilities.length, 1);
+
+    assertEq(capabilities[0].capabilityType, "read-ethereum-mainnet-gas-price");
+    assertEq(capabilities[0].version, "1.0.2");
+    assertEq(
+      uint256(capabilities[0].responseType),
+      uint256(CapabilityRegistry.CapabilityResponseType.OBSERVATION_IDENTICAL)
+    );
+    assertEq(capabilities[0].configurationContract, address(s_capabilityConfigurationContract));
+  }
+}

contracts/src/v0.8/keystone/test/Constants.t.sol

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.19;
 
-import {Test} from "forge-std/Test.sol";
-
 contract Constants {
   address internal ADMIN = address(1);
   address internal STRANGER = address(2);

contracts/src/v0.8/keystone/test/mocks/CapabilityConfigurationContract.sol

@@ -10,4 +10,8 @@ contract CapabilityConfigurationContract is ICapabilityConfiguration, ERC165 {
   function getCapabilityConfiguration(uint256 donId) external view returns (bytes memory configuration) {
     return s_donConfiguration[donId];
   }
+
+  function supportsInterface(bytes4 interfaceId) public pure override returns (bool) {
+    return interfaceId == this.getCapabilityConfiguration.selector;
+  }
 }