feat: add publishMetadataURI (#1492)

**Motivation:**

*Explain here the context, and why you're making that change. What is
the problem you're trying to solve.*

**Modifications:**

*Describe the modifications you've done.*

**Result:**

*After your change, what will change.*

Author: 0xClandestine

src/contracts/core/ReleaseManager.sol

@@ -34,6 +34,7 @@ contract ReleaseManager is Initializable, ReleaseManagerStorage, PermissionContr
     ) external checkCanCall(operatorSet.avs) returns (uint256 releaseId) {
         Release[] storage releases = _operatorSetReleases[operatorSet.key()];
 
+        require(bytes(_operatorSetMetadataURI[operatorSet.key()]).length != 0, MustPublishMetadataURI());
         require(release.upgradeByTime >= block.timestamp, InvalidUpgradeByTime());
 
         // New release id is the length of the array before this call.
@@ -49,6 +50,16 @@ contract ReleaseManager is Initializable, ReleaseManagerStorage, PermissionContr
         emit ReleasePublished(operatorSet, releaseId, release);
     }
 
+    /// @inheritdoc IReleaseManager
+    function publishMetadataURI(
+        OperatorSet calldata operatorSet,
+        string calldata metadataURI
+    ) external checkCanCall(operatorSet.avs) {
+        require(bytes(metadataURI).length != 0, InvalidMetadataURI());
+        _operatorSetMetadataURI[operatorSet.key()] = metadataURI;
+        emit MetadataURIPublished(operatorSet, metadataURI);
+    }
+
     /**
      *
      *                         VIEW FUNCTIONS
@@ -89,4 +100,11 @@ contract ReleaseManager is Initializable, ReleaseManagerStorage, PermissionContr
     function isValidRelease(OperatorSet memory operatorSet, uint256 releaseId) external view returns (bool) {
         return releaseId == getTotalReleases(operatorSet) - 1;
     }
+
+    /// @inheritdoc IReleaseManager
+    function getMetadataURI(
+        OperatorSet memory operatorSet
+    ) external view returns (string memory) {
+        return _operatorSetMetadataURI[operatorSet.key()];
+    }
 }

src/contracts/core/ReleaseManagerStorage.sol

@@ -10,6 +10,9 @@ abstract contract ReleaseManagerStorage is IReleaseManager {
     /// @notice Returns an array of releases for a given operator set.
     mapping(bytes32 operatorSetKey => Release[]) internal _operatorSetReleases;
 
+    /// @notice Returns the metadata URI for a given operator set.
+    mapping(bytes32 operatorSetKey => string metadataURI) internal _operatorSetMetadataURI;
+
     /**
      * @dev This empty reserved space is put in place to allow future versions to add new
      * variables without shifting down storage in the inheritance chain.

src/contracts/interfaces/IReleaseManager.sol

@@ -4,17 +4,23 @@ pragma solidity ^0.8.27;
 import "../libraries/OperatorSetLib.sol";
 
 interface IReleaseManagerErrors {
+    /// @notice Thrown when a metadata URI must be published before publishing a release.
+    error MustPublishMetadataURI();
+
     /// @notice Thrown when the upgrade by time is in the past.
     error InvalidUpgradeByTime();
+
+    /// @notice Thrown when the metadata URI is empty.
+    error InvalidMetadataURI();
 }
 
 interface IReleaseManagerTypes {
     /// @notice Represents a software artifact with its digest and registry URL.
     /// @param digest The hash digest of the artifact.
-    /// @param registryUrl The URL where the artifact can be found.
+    /// @param registry Where the artifact can be found.
     struct Artifact {
         bytes32 digest;
-        string registryUrl;
+        string registry;
     }
 
     /// @notice Represents a release containing multiple artifacts and an upgrade deadline.
@@ -32,6 +38,11 @@ interface IReleaseManagerEvents is IReleaseManagerTypes {
     /// @param releaseId The id of the release that was published.
     /// @param release The release that was published.
     event ReleasePublished(OperatorSet indexed operatorSet, uint256 indexed releaseId, Release release);
+
+    /// @notice Emitted when a metadata URI is published.
+    /// @param operatorSet The operator set this metadata URI is for.
+    /// @param metadataURI The metadata URI that was published.
+    event MetadataURIPublished(OperatorSet indexed operatorSet, string metadataURI);
 }
 
 interface IReleaseManager is IReleaseManagerErrors, IReleaseManagerEvents {
@@ -50,6 +61,11 @@ interface IReleaseManager is IReleaseManagerErrors, IReleaseManagerEvents {
         Release calldata release
     ) external returns (uint256 releaseId);
 
+    /// @notice Publishes a metadata URI for an operator set.
+    /// @param operatorSet The operator set this metadata URI is for.
+    /// @param metadataURI The metadata URI that was published.
+    function publishMetadataURI(OperatorSet calldata operatorSet, string calldata metadataURI) external;
+
     /**
      *
      *                         VIEW FUNCTIONS
@@ -89,4 +105,11 @@ interface IReleaseManager is IReleaseManagerErrors, IReleaseManagerEvents {
     /// @param releaseId The id of the release to check.
     /// @return True if the release is the latest release, false otherwise.
     function isValidRelease(OperatorSet memory operatorSet, uint256 releaseId) external view returns (bool);
+
+    /// @notice Returns the metadata URI for an operator set.
+    /// @param operatorSet The operator set to query.
+    /// @return The metadata URI for the operator set.
+    function getMetadataURI(
+        OperatorSet memory operatorSet
+    ) external view returns (string memory);
 }

src/test/unit/ReleaseManagerUnit.t.sol

@@ -47,13 +47,16 @@ contract ReleaseManagerUnitTests is EigenLayerUnitTestSetup, IReleaseManagerErro
         // Setup default test data
         defaultOperatorSet = OperatorSet(defaultAVS, 0);
 
-        defaultArtifacts.push(Artifact({digest: keccak256("artifact1"), registryUrl: "https://example.com/artifact1"}));
-        defaultArtifacts.push(Artifact({digest: keccak256("artifact2"), registryUrl: "https://example.com/artifact2"}));
+        defaultArtifacts.push(Artifact({digest: keccak256("artifact1"), registry: "https://example.com/artifact1"}));
+        defaultArtifacts.push(Artifact({digest: keccak256("artifact2"), registry: "https://example.com/artifact2"}));
 
         defaultRelease.upgradeByTime = uint32(block.timestamp + 1 days);
 
         cheats.prank(defaultAVS);
         permissionController.setAppointee(defaultAVS, address(this), address(releaseManager), IReleaseManager.publishRelease.selector);
+
+        cheats.prank(defaultAVS);
+        releaseManager.publishMetadataURI(defaultOperatorSet, "https://example.com/metadata");
     }
 
     /// -----------------------------------------------------------------------
@@ -69,7 +72,7 @@ contract ReleaseManagerUnitTests is EigenLayerUnitTestSetup, IReleaseManagerErro
         for (uint i = 0; i < numArtifacts; i++) {
             artifacts[i] = Artifact({
                 digest: keccak256(abi.encodePacked("artifact", i)),
-                registryUrl: string(abi.encodePacked("https://example.com/artifact", i))
+                registry: string(abi.encodePacked("https://example.com/artifact", i))
             });
         }
         return _createRelease(artifacts, upgradeByTime);
@@ -92,7 +95,7 @@ contract ReleaseManagerUnitTests is EigenLayerUnitTestSetup, IReleaseManagerErro
 
         for (uint i = 0; i < actualRelease.artifacts.length; i++) {
             assertEq(actualRelease.artifacts[i].digest, expectedRelease.artifacts[i].digest, "artifact digest mismatch");
-            assertEq(actualRelease.artifacts[i].registryUrl, expectedRelease.artifacts[i].registryUrl, "artifact registryUrl mismatch");
+            assertEq(actualRelease.artifacts[i].registry, expectedRelease.artifacts[i].registry, "artifact registry mismatch");
         }
 
         console.log("Success!".green().bold());
@@ -108,6 +111,14 @@ contract ReleaseManagerUnitTests_Initialization is ReleaseManagerUnitTests {
 }
 
 contract ReleaseManagerUnitTests_publishRelease is ReleaseManagerUnitTests {
+    function test_revert_MustPublishMetadataURI() public {
+        OperatorSet memory operatorSet = OperatorSet(defaultAVS, 1);
+
+        cheats.prank(defaultAVS);
+        vm.expectRevert(IReleaseManagerErrors.MustPublishMetadataURI.selector);
+        releaseManager.publishRelease(operatorSet, defaultRelease);
+    }
+
     function test_revert_InvalidUpgradeByTime() public {
         // Create release with past timestamp
         Release memory pastRelease = _createRelease(defaultArtifacts, uint32(block.timestamp - 1));
@@ -204,6 +215,11 @@ contract ReleaseManagerUnitTests_publishRelease is ReleaseManagerUnitTests {
         OperatorSet memory operatorSet1 = OperatorSet(defaultAVS, operatorSetId1);
         OperatorSet memory operatorSet2 = OperatorSet(defaultAVS, operatorSetId2);
 
+        cheats.prank(operatorSet1.avs);
+        releaseManager.publishMetadataURI(operatorSet1, "https://example.com/metadata");
+        cheats.prank(operatorSet2.avs);
+        releaseManager.publishMetadataURI(operatorSet2, "https://example.com/metadata");
+
         // Publish to first operator set
         uint releaseId1 = _publishRelease(operatorSet1, defaultRelease);
         assertEq(releaseId1, 0, "first release in set1 should be 0");
@@ -247,6 +263,9 @@ contract ReleaseManagerUnitTests_getTotalReleases is ReleaseManagerUnitTests {
     function test_getTotalReleases_differentOperatorSets() public {
         OperatorSet memory operatorSet2 = OperatorSet(defaultAVS, 1);
 
+        cheats.prank(operatorSet2.avs);
+        releaseManager.publishMetadataURI(operatorSet2, "https://example.com/metadata");
+
         // Publish to different sets
         _publishRelease(defaultOperatorSet, defaultRelease);
         _publishRelease(defaultOperatorSet, defaultRelease);
@@ -395,6 +414,11 @@ contract ReleaseManagerUnitTests_EdgeCases is ReleaseManagerUnitTests {
         OperatorSet memory set1 = OperatorSet(defaultAVS, 1);
         OperatorSet memory set2 = OperatorSet(address(0x5678), 0);
 
+        cheats.prank(set1.avs);
+        releaseManager.publishMetadataURI(set1, "https://example.com/metadata");
+        cheats.prank(set2.avs);
+        releaseManager.publishMetadataURI(set2, "https://example.com/metadata");
+
         // Grant permission for second AVS
         cheats.prank(set2.avs);
         permissionController.setAppointee(set2.avs, address(this), address(releaseManager), IReleaseManager.publishRelease.selector);
@@ -474,3 +498,22 @@ contract ReleaseManagerUnitTests_isValidRelease is ReleaseManagerUnitTests {
         assertEq(isLatest, true, "second release should be the latest");
     }
 }
+
+contract ReleaseManagerUnitTests_publishMetadataURI is ReleaseManagerUnitTests {
+    function test_revert_InvalidMetadataURI() public {
+        cheats.prank(defaultAVS);
+        vm.expectRevert(IReleaseManagerErrors.InvalidMetadataURI.selector);
+        releaseManager.publishMetadataURI(defaultOperatorSet, "");
+    }
+
+    function test_publishMetadataURI_Correctness() public {
+        string memory registry = "https://example.com/metadata";
+        cheats.expectEmit(true, true, true, true, address(releaseManager));
+        emit MetadataURIPublished(defaultOperatorSet, registry);
+
+        cheats.prank(defaultAVS);
+        releaseManager.publishMetadataURI(defaultOperatorSet, registry);
+
+        assertEq(releaseManager.getMetadataURI(defaultOperatorSet), registry, "metadata URI not set correctly");
+    }
+}