fix: reclaim pending rewards on stale allocation resize (TRST-R-1)

_resizeAllocation() now checks staleness and reclaims accumulated
pending rewards instead of allowing them to accrue for allocations
that are not performing. Also fixes MockRewardsManager.calcRewards
and reclaimRewards to return realistic values for meaningful test
coverage.

Author: RembrandtK

packages/subgraph-service/contracts/utilities/AllocationManager.sol

@@ -261,7 +261,8 @@ abstract contract AllocationManager is
     /**
      * @notice Resize an allocation
      * @dev Will lock or release tokens in the provision tracker depending on the new allocation size.
-     * Rewards accrued but not issued before the resize will be accounted for as pending rewards.
+     * Rewards accrued but not issued before the resize will be accounted for as pending rewards,
+     * unless the allocation is stale, in which case pending rewards are reclaimed.
      * These will be paid out when the indexer presents a POI.
      *
      * Requirements:
@@ -304,6 +305,13 @@ abstract contract AllocationManager is
             accRewardsPerAllocatedTokenPending
         );
 
+        // If allocation is stale, reclaim pending rewards defensively.
+        // Stale allocations are not performing, so rewards should not accumulate.
+        if (allocation.isStale(maxPOIStaleness)) {
+            _graphRewardsManager().reclaimRewards(RewardsCondition.STALE_POI, _allocationId);
+            _allocations.clearPendingRewards(_allocationId);
+        }
+
         // Update total allocated tokens for the subgraph deployment
         if (_tokens > oldTokens) {
             _subgraphAllocatedTokens[allocation.subgraphDeploymentId] += (_tokens - oldTokens);

packages/subgraph-service/test/unit/mocks/MockRewardsManager.sol

@@ -55,19 +55,29 @@ contract MockRewardsManager is IRewardsManager {
 
     function reclaimRewards(bytes32, address _allocationId) external view returns (uint256) {
         address rewardsIssuer = msg.sender;
-        (bool isActive, , , uint256 tokens, uint256 accRewardsPerAllocatedToken, ) = IRewardsIssuer(rewardsIssuer)
-            .getAllocationData(_allocationId);
+        (
+            bool isActive,
+            ,
+            ,
+            uint256 tokens,
+            uint256 accRewardsPerAllocatedToken,
+            uint256 accRewardsPending
+        ) = IRewardsIssuer(rewardsIssuer).getAllocationData(_allocationId);
 
         if (!isActive) {
             return 0;
         }
 
-        // Calculate accumulated but unclaimed rewards
-        uint256 accRewardsPerTokens = tokens.mulPPM(rewardsPerSignal);
-        uint256 rewards = accRewardsPerTokens - accRewardsPerAllocatedToken;
+        // Mirror real _calcAllocationRewards: pending + delta from current accumulator
+        uint256 newRewards = 0;
+        if (rewardsPerSubgraphAllocationUpdate > accRewardsPerAllocatedToken) {
+            newRewards =
+                ((rewardsPerSubgraphAllocationUpdate - accRewardsPerAllocatedToken) * tokens) /
+                FIXED_POINT_SCALING_FACTOR;
+        }
 
         // Note: We don't mint tokens for reclaimed rewards, they are just discarded
-        return rewards;
+        return accRewardsPending + newRewards;
     }
 
     // -- Getters --
@@ -98,7 +108,9 @@ contract MockRewardsManager is IRewardsManager {
 
     function getRewards(address, address) external view returns (uint256) {}
 
-    function calcRewards(uint256, uint256) external pure returns (uint256) {}
+    function calcRewards(uint256 _tokens, uint256 _accRewardsPerAllocatedToken) external pure returns (uint256) {
+        return (_accRewardsPerAllocatedToken * _tokens) / FIXED_POINT_SCALING_FACTOR;
+    }
 
     function getAllocatedIssuancePerBlock() external view returns (uint256) {}
 

packages/subgraph-service/test/unit/subgraphService/SubgraphService.t.sol

@@ -130,10 +130,8 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
         IAllocation.State memory afterAllocation = subgraphService.getAllocation(_allocationId);
         uint256 accRewardsPerAllocatedTokenDelta = afterAllocation.accRewardsPerAllocatedToken -
             beforeAllocation.accRewardsPerAllocatedToken;
-        uint256 afterAccRewardsPending = rewardsManager.calcRewards(
-            beforeAllocation.tokens,
-            accRewardsPerAllocatedTokenDelta
-        );
+        uint256 afterAccRewardsPending = beforeAllocation.accRewardsPending +
+            rewardsManager.calcRewards(beforeAllocation.tokens, accRewardsPerAllocatedTokenDelta);
 
         // check state
         if (_tokens > beforeAllocation.tokens) {

packages/subgraph-service/test/unit/subgraphService/allocation/resize.t.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.27;
 import { SubgraphServiceTest } from "../SubgraphService.t.sol";
 import { ISubgraphService } from "@graphprotocol/interfaces/contracts/subgraph-service/ISubgraphService.sol";
 import { IAllocationManager } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocationManager.sol";
+import { IAllocation } from "@graphprotocol/interfaces/contracts/subgraph-service/internal/IAllocation.sol";
 import { IGraphPayments } from "@graphprotocol/interfaces/contracts/horizon/IGraphPayments.sol";
 
 contract SubgraphServiceAllocationResizeTest is SubgraphServiceTest {
@@ -105,4 +106,41 @@ contract SubgraphServiceAllocationResizeTest is SubgraphServiceTest {
         );
         subgraphService.resizeAllocation(users.indexer, allocationId, resizeTokens);
     }
+
+    function test_SubgraphService_Allocation_Resize_StaleAllocation_ReclaimsPending(
+        uint256 tokens,
+        uint256 resizeTokens
+    ) public useIndexer useAllocation(tokens) {
+        resizeTokens = bound(resizeTokens, 1, MAX_TOKENS);
+        vm.assume(resizeTokens != tokens);
+
+        // Skip past MAX_POI_STALENESS to make allocation stale
+        skip(MAX_POI_STALENESS + 1);
+
+        mint(users.indexer, resizeTokens);
+        _addToProvision(users.indexer, resizeTokens);
+        subgraphService.resizeAllocation(users.indexer, allocationId, resizeTokens);
+
+        // Pending rewards should be zero after stale resize
+        IAllocation.State memory allocation = subgraphService.getAllocation(allocationId);
+        assertEq(allocation.accRewardsPending, 0);
+        assertEq(allocation.tokens, resizeTokens);
+    }
+
+    function test_SubgraphService_Allocation_Resize_NotStale_PreservesPending(
+        uint256 tokens,
+        uint256 resizeTokens
+    ) public useIndexer useAllocation(tokens) {
+        resizeTokens = bound(resizeTokens, 1, MAX_TOKENS);
+        vm.assume(resizeTokens != tokens);
+
+        mint(users.indexer, resizeTokens);
+        _addToProvision(users.indexer, resizeTokens);
+        subgraphService.resizeAllocation(users.indexer, allocationId, resizeTokens);
+
+        // Pending rewards should be preserved (non-zero) for non-stale allocation
+        IAllocation.State memory allocation = subgraphService.getAllocation(allocationId);
+        uint256 expectedPending = rewardsManager.calcRewards(tokens, REWARDS_PER_SUBGRAPH_ALLOCATION_UPDATE);
+        assertEq(allocation.accRewardsPending, expectedPending);
+    }
 }