fix: [TRST-H-2] Only agreement owner can collect indexing fee

Author: matiasedgeandnode

packages/subgraph-service/contracts/SubgraphService.sol

@@ -298,7 +298,12 @@ contract SubgraphService is
             paymentCollected = _collectIndexingRewards(indexer, data);
         } else if (paymentType == IGraphPayments.PaymentTypes.IndexingFee) {
             (bytes16 agreementId, bytes memory iaCollectionData) = IndexingAgreementDecoder.decodeCollectData(data);
-            paymentCollected = _collectIndexingFees(agreementId, paymentsDestination[indexer], iaCollectionData);
+            paymentCollected = _collectIndexingFees(
+                indexer,
+                agreementId,
+                paymentsDestination[indexer],
+                iaCollectionData
+            );
         } else {
             revert SubgraphServiceInvalidPaymentType(paymentType);
         }
@@ -754,19 +759,22 @@ contract SubgraphService is
      * Emits a {StakeClaimLocked} event.
      * Emits a {IndexingFeesCollectedV1} event.
      *
+     * @param _indexer The address of the indexer
      * @param _agreementId The id of the indexing agreement
      * @param _paymentsDestination The address where the fees should be sent
      * @param _data The indexing agreement collection data
      * @return The amount of fees collected
      */
     function _collectIndexingFees(
+        address _indexer,
         bytes16 _agreementId,
         address _paymentsDestination,
         bytes memory _data
     ) private returns (uint256) {
         (address indexer, uint256 tokensCollected) = IndexingAgreement._getStorageManager().collect(
             _allocations,
             IndexingAgreement.CollectParams({
+                indexer: _indexer,
                 agreementId: _agreementId,
                 currentEpoch: _graphEpochManager().currentEpoch(),
                 receiverDestination: _paymentsDestination,

packages/subgraph-service/contracts/libraries/IndexingAgreement.sol

@@ -75,12 +75,14 @@ library IndexingAgreement {
 
     /**
      * @notice Parameters for collecting indexing fees
+     * @param indexer The address of the indexer
      * @param agreementId The ID of the indexing agreement
      * @param currentEpoch The current epoch
      * @param receiverDestination The address where the collected fees should be sent
      * @param data The encoded data containing the number of entities indexed, proof of indexing, and epoch
      */
     struct CollectParams {
+        address indexer;
         bytes16 agreementId;
         uint256 currentEpoch;
         address receiverDestination;
@@ -523,6 +525,10 @@ library IndexingAgreement {
             wrapper.agreement.allocationId,
             wrapper.collectorAgreement.serviceProvider
         );
+        require(
+            allocation.indexer == params.indexer,
+            IndexingAgreementNotAuthorized(params.agreementId, params.indexer)
+        );
         require(_isCollectable(wrapper), IndexingAgreementNotCollectable(params.agreementId));
 
         require(

packages/subgraph-service/test/unit/subgraphService/indexing-agreement/collect.t.sol

@@ -232,6 +232,35 @@ contract SubgraphServiceIndexingAgreementCollectTest is SubgraphServiceIndexingA
         );
     }
 
+    function test_SubgraphService_CollectIndexingFees_Reverts_WhenIndexingAgreementNotAuthorized(
+        Seed memory seed,
+        uint256 entities,
+        bytes32 poi
+    ) public {
+        Context storage ctx = _newCtx(seed);
+        IndexerState memory indexerState = _withIndexer(ctx);
+        IndexerState memory otherIndexerState = _withIndexer(ctx);
+        IRecurringCollector.SignedRCA memory accepted = _withAcceptedIndexingAgreement(ctx, indexerState);
+
+        vm.assume(otherIndexerState.addr != indexerState.addr);
+
+        resetPrank(otherIndexerState.addr);
+
+        uint256 currentEpochBlock = epochManager.currentEpochBlock();
+
+        bytes memory expectedErr = abi.encodeWithSelector(
+            IndexingAgreement.IndexingAgreementNotAuthorized.selector,
+            accepted.rca.agreementId,
+            otherIndexerState.addr
+        );
+        vm.expectRevert(expectedErr);
+        subgraphService.collect(
+            otherIndexerState.addr,
+            IGraphPayments.PaymentTypes.IndexingFee,
+            _encodeCollectDataV1(accepted.rca.agreementId, entities, poi, currentEpochBlock, bytes(""))
+        );
+    }
+
     function test_SubgraphService_CollectIndexingFees_Reverts_WhenStopService(
         Seed memory seed,
         uint256 entities,