feat: add reclaim addresses for denied rewards in RewardsManager

Add two new addresses to RewardsManager V6 storage that allow denied rewards to be minted to designated reclaim addresses instead of being lost:

- indexerEligibilityReclaimAddress: receives tokens denied due to indexer eligibility
- subgraphDeniedReclaimAddress: receives tokens denied due to subgraph denylist

Both addresses default to zero (disabled) and can be set by governor. When set to non-zero, denied rewards are minted to these addresses instead of being burned. Original denial events are always emitted, with additional reclaim events when minting occurs.

Changes:
- Add setIndexerEligibilityReclaimAddress() and setSubgraphDeniedReclaimAddress() setter functions
- Add corresponding events for address changes and reclaim operations
- Refactor takeRewards() denial logic into helper functions to maintain code quality
- Update IRewardsManager interface (interface ID: 0x731e44f0)
- Add comprehensive test coverage (12 tests)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: RembrandtK

packages/contracts/contracts/rewards/RewardsManager.sol

@@ -108,6 +108,48 @@ contract RewardsManager is RewardsManagerV6Storage, GraphUpgradeable, IERC165, I
         address indexed newRewardsEligibilityOracle
     );
 
+    /**
+     * @notice Emitted when the eligibility reclaim address is set
+     * @param oldEligibilityReclaimAddress Previous eligibility reclaim address
+     * @param newEligibilityReclaimAddress New eligibility reclaim address
+     */
+    event EligibilityReclaimAddressSet(
+        address indexed oldEligibilityReclaimAddress,
+        address indexed newEligibilityReclaimAddress
+    );
+
+    /**
+     * @notice Emitted when the subgraph reclaim address is set
+     * @param oldSubgraphReclaimAddress Previous subgraph reclaim address
+     * @param newSubgraphReclaimAddress New subgraph reclaim address
+     */
+    event SubgraphReclaimAddressSet(
+        address indexed oldSubgraphReclaimAddress,
+        address indexed newSubgraphReclaimAddress
+    );
+
+    /**
+     * @notice Emitted when denied rewards are reclaimed due to eligibility
+     * @param indexer Address of the indexer whose rewards were denied
+     * @param allocationID Address of the allocation
+     * @param amount Amount of rewards reclaimed
+     */
+    event RewardsReclaimedDueToEligibility(address indexed indexer, address indexed allocationID, uint256 amount);
+
+    /**
+     * @notice Emitted when denied rewards are reclaimed due to subgraph denylist
+     * @param indexer Address of the indexer whose rewards were denied
+     * @param allocationID Address of the allocation
+     * @param subgraphDeploymentID Subgraph deployment ID that was denied
+     * @param amount Amount of rewards reclaimed
+     */
+    event RewardsReclaimedDueToSubgraphDenylist(
+        address indexed indexer,
+        address indexed allocationID,
+        bytes32 indexed subgraphDeploymentID,
+        uint256 amount
+    );
+
     // -- Modifiers --
 
     /**
@@ -264,6 +306,30 @@ contract RewardsManager is RewardsManagerV6Storage, GraphUpgradeable, IERC165, I
         }
     }
 
+    /**
+     * @inheritdoc IRewardsManager
+     * @dev Set to zero address to disable eligibility reclaim functionality
+     */
+    function setIndexerEligibilityReclaimAddress(address newEligibilityReclaimAddress) external override onlyGovernor {
+        if (indexerEligibilityReclaimAddress != newEligibilityReclaimAddress) {
+            address oldEligibilityReclaimAddress = indexerEligibilityReclaimAddress;
+            indexerEligibilityReclaimAddress = newEligibilityReclaimAddress;
+            emit EligibilityReclaimAddressSet(oldEligibilityReclaimAddress, newEligibilityReclaimAddress);
+        }
+    }
+
+    /**
+     * @inheritdoc IRewardsManager
+     * @dev Set to zero address to disable subgraph reclaim functionality
+     */
+    function setSubgraphDeniedReclaimAddress(address newSubgraphReclaimAddress) external override onlyGovernor {
+        if (subgraphDeniedReclaimAddress != newSubgraphReclaimAddress) {
+            address oldSubgraphReclaimAddress = subgraphDeniedReclaimAddress;
+            subgraphDeniedReclaimAddress = newSubgraphReclaimAddress;
+            emit SubgraphReclaimAddressSet(oldSubgraphReclaimAddress, newSubgraphReclaimAddress);
+        }
+    }
+
     // -- Denylist --
 
     /**
@@ -494,6 +560,60 @@ contract RewardsManager is RewardsManagerV6Storage, GraphUpgradeable, IERC165, I
         return newAccrued.mul(_tokens).div(FIXED_POINT_SCALING_FACTOR);
     }
 
+    /**
+     * @notice Checks for and handles denial and reclaim of rewards due to subgraph deny list
+     * @dev If denied, emits RewardsDenied event and mints to reclaim address if configured
+     * @param indexer Address of the indexer
+     * @param allocationID Address of the allocation
+     * @param subgraphDeploymentID Subgraph deployment ID
+     * @param rewards Amount of rewards that would be distributed
+     * @return True if rewards are denied, false otherwise
+     */
+    function _rewardsDeniedDueToSubgraphDenyList(
+        address indexer,
+        address allocationID,
+        bytes32 subgraphDeploymentID,
+        uint256 rewards
+    ) private returns (bool) {
+        if (isDenied(subgraphDeploymentID)) {
+            emit RewardsDenied(indexer, allocationID);
+
+            // If a reclaim address is set, mint the denied rewards there
+            if (0 < rewards && subgraphDeniedReclaimAddress != address(0)) {
+                graphToken().mint(subgraphDeniedReclaimAddress, rewards);
+                emit RewardsReclaimedDueToSubgraphDenylist(indexer, allocationID, subgraphDeploymentID, rewards);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @notice Checks for and handles denial and reclaim of rewards due to indexer eligibility
+     * @dev If denied, emits RewardsDeniedDueToEligibility event and mints to reclaim address if configured
+     * @param indexer Address of the indexer
+     * @param allocationID Address of the allocation
+     * @param rewards Amount of rewards that would be distributed
+     * @return True if rewards are denied, false otherwise
+     */
+    function _rewardsDeniedDueToIndexerEligibility(
+        address indexer,
+        address allocationID,
+        uint256 rewards
+    ) private returns (bool) {
+        if (address(rewardsEligibilityOracle) != address(0) && !rewardsEligibilityOracle.isEligible(indexer)) {
+            emit RewardsDeniedDueToEligibility(indexer, allocationID, rewards);
+
+            // If a reclaim address is set, mint the denied rewards there
+            if (0 < rewards && indexerEligibilityReclaimAddress != address(0)) {
+                graphToken().mint(indexerEligibilityReclaimAddress, rewards);
+                emit RewardsReclaimedDueToEligibility(indexer, allocationID, rewards);
+            }
+            return true;
+        }
+        return false;
+    }
+
     /**
      * @inheritdoc IRewardsManager
      * @dev This function can only be called by an authorized rewards issuer which are
@@ -518,31 +638,24 @@ contract RewardsManager is RewardsManagerV6Storage, GraphUpgradeable, IERC165, I
 
         uint256 updatedAccRewardsPerAllocatedToken = onSubgraphAllocationUpdate(subgraphDeploymentID);
 
-        // Do not do rewards on denied subgraph deployments ID
-        if (isDenied(subgraphDeploymentID)) {
-            emit RewardsDenied(indexer, _allocationID);
-            return 0;
-        }
-
         uint256 rewards = 0;
         if (isActive) {
             // Calculate rewards accrued by this allocation
             rewards = accRewardsPending.add(
                 _calcRewards(tokens, accRewardsPerAllocatedToken, updatedAccRewardsPerAllocatedToken)
             );
+        }
 
-            // Do not reward if indexer is not eligible based on rewards eligibility
-            if (address(rewardsEligibilityOracle) != address(0) && !rewardsEligibilityOracle.isEligible(indexer)) {
-                emit RewardsDeniedDueToEligibility(indexer, _allocationID, rewards);
-                return 0;
-            }
+        if (_rewardsDeniedDueToSubgraphDenyList(indexer, _allocationID, subgraphDeploymentID, rewards)) return 0;
 
-            if (rewards > 0) {
-                // Mint directly to rewards issuer for the reward amount
-                // The rewards issuer contract will do bookkeeping of the reward and
-                // assign in proportion to each stakeholder incentive
-                graphToken().mint(rewardsIssuer, rewards);
-            }
+        if (_rewardsDeniedDueToIndexerEligibility(indexer, _allocationID, rewards)) return 0;
+
+        // Mint rewards to the rewards issuer
+        if (rewards > 0) {
+            // Mint directly to rewards issuer for the reward amount
+            // The rewards issuer contract will do bookkeeping of the reward and
+            // assign in proportion to each stakeholder incentive
+            graphToken().mint(rewardsIssuer, rewards);
         }
 
         emit HorizonRewardsAssigned(indexer, _allocationID, rewards);

packages/contracts/contracts/rewards/RewardsManagerStorage.sol

@@ -83,11 +83,15 @@ contract RewardsManagerV5Storage is RewardsManagerV4Storage {
  * @title RewardsManagerV6Storage
  * @author Edge & Node
  * @notice Storage layout for RewardsManager V6
- * Includes support for Rewards Eligibility Oracle and Issuance Allocator.
+ * Includes support for Rewards Eligibility Oracle, Issuance Allocator, and Reclaim Addresses.
  */
 contract RewardsManagerV6Storage is RewardsManagerV5Storage {
     /// @notice Address of the rewards eligibility oracle contract
     IRewardsEligibility public rewardsEligibilityOracle;
     /// @notice Address of the issuance allocator
     IIssuanceAllocationDistribution public issuanceAllocator;
+    /// @notice Address to mint tokens that would be denied due to eligibility
+    address public indexerEligibilityReclaimAddress;
+    /// @notice Address to mint tokens that would be denied due to subgraph denylist
+    address public subgraphDeniedReclaimAddress;
 }

packages/contracts/test/tests/unit/rewards/rewards-interface.test.ts

@@ -57,7 +57,7 @@ describe('RewardsManager interfaces', () => {
     })
 
     it('IRewardsManager should have stable interface ID', () => {
-      expect(IRewardsManager__factory.interfaceId).to.equal('0xa31d8306')
+      expect(IRewardsManager__factory.interfaceId).to.equal('0x731e44f0')
     })
   })