f: agreement versioning WIP

Author: matiasedgeandnode

packages/subgraph-service/contracts/Decoder.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.27;
+
+import { ISubgraphService } from "./interfaces/ISubgraphService.sol";
+
+contract Decoder {
+    function decodeCollectIndexingFeeData(
+        bytes calldata data
+    ) external pure returns (ISubgraphService.IndexingAgreementKey memory, bytes memory) {
+        return abi.decode(data, (ISubgraphService.IndexingAgreementKey, bytes));
+    }
+
+    /**
+     * @notice Decodes the indexing agreement metadata.
+     *
+     * @param data The data to decode. See {ISubgraphService.RCVIndexingAgreementMetadata}
+     * @return The decoded data
+     */
+    function decodeRCVMetadata(
+        bytes calldata data
+    ) external pure returns (ISubgraphService.RCVIndexingAgreementMetadata memory) {
+        return abi.decode(data, (ISubgraphService.RCVIndexingAgreementMetadata));
+    }
+
+    function decodeCollectIndexingFeeDataV1(bytes memory data) external pure returns (uint256 entities, bytes32 poi) {
+        return abi.decode(data, (uint256, bytes32));
+    }
+
+    function decodeAcceptIndexingAgreementTermsV1(
+        bytes memory data
+    ) external pure returns (ISubgraphService.IndexingAgreementTermsV1 memory) {
+        return abi.decode(data, (ISubgraphService.IndexingAgreementTermsV1));
+    }
+
+    function _decodeCollectIndexingFeeData(
+        bytes memory _data
+    ) internal view returns (ISubgraphService.IndexingAgreementKey memory, bytes memory) {
+        try this.decodeCollectIndexingFeeData(_data) returns (
+            ISubgraphService.IndexingAgreementKey memory key,
+            bytes memory data
+        ) {
+            return (key, data);
+        } catch {
+            revert ISubgraphService.SubgraphServiceInvalidCollectIndexingFeeData(_data);
+        }
+    }
+
+    function _decodeRCVMetadata(
+        bytes memory _data
+    ) internal view returns (ISubgraphService.RCVIndexingAgreementMetadata memory) {
+        try this.decodeRCVMetadata(_data) returns (ISubgraphService.RCVIndexingAgreementMetadata memory metadata) {
+            return metadata;
+        } catch {
+            revert ISubgraphService.SubgraphServiceInvalidRCVMetadata(_data);
+        }
+    }
+
+    function _decodeCollectIndexingFeeDataV1(bytes memory _data) internal view returns (uint256, bytes32) {
+        try this.decodeCollectIndexingFeeDataV1(_data) returns (uint256 entities, bytes32 poi) {
+            return (entities, poi);
+        } catch {
+            revert ISubgraphService.SubgraphServiceInvalidCollectIndexingFeeV1Data(_data);
+        }
+    }
+
+    function _decodeAcceptIndexingAgreementTermsV1(
+        bytes memory _data
+    ) internal view returns (ISubgraphService.IndexingAgreementTermsV1 memory) {
+        try this.decodeAcceptIndexingAgreementTermsV1(_data) returns (
+            ISubgraphService.IndexingAgreementTermsV1 memory terms
+        ) {
+            return terms;
+        } catch {
+            revert ISubgraphService.SubgraphServiceInvalidAcceptIndexingAgreementTermsV1(_data);
+        }
+    }
+}

packages/subgraph-service/contracts/DisputeManager.sol

@@ -130,7 +130,7 @@ contract DisputeManager is
     }
 
     /// @inheritdoc IDisputeManager
-    function createIndexingFeeDispute(
+    function createIndexingFeeDisputeV1(
         ISubgraphService.IndexingAgreementKey calldata agreementKey,
         bytes32 poi,
         uint256 entities
@@ -139,7 +139,7 @@ contract DisputeManager is
         _graphToken().pullTokens(msg.sender, disputeDeposit);
 
         // Create a dispute
-        return _createIndexingFeeDisputeWithAgreement(msg.sender, disputeDeposit, agreementKey, poi, entities);
+        return _createIndexingFeeDisputeV1(msg.sender, disputeDeposit, agreementKey, poi, entities);
     }
 
     /// @inheritdoc IDisputeManager
@@ -464,15 +464,15 @@ contract DisputeManager is
     }
 
     /**
-     * @notice Create indexing fee dispute internal function.
+     * @notice Create indexing fee (version 1) dispute internal function.
      * @param _fisherman The fisherman creating the dispute
      * @param _deposit Amount of tokens staked as deposit
      * @param _key The indexing agreement key
      * @param _poi The POI being disputed
      * @param _entities The number of entities disputed
      * @return The dispute id
      */
-    function _createIndexingFeeDisputeWithAgreement(
+    function _createIndexingFeeDisputeV1(
         address _fisherman,
         uint256 _deposit,
         ISubgraphService.IndexingAgreementKey calldata _key,
@@ -494,9 +494,13 @@ contract DisputeManager is
         // Only one dispute at a time
         require(!isDisputeCreated(disputeId), DisputeManagerDisputeAlreadyCreated(disputeId));
 
-        // Agreement must have been collected on
+        // Agreement must have been collected on and be a version 1
         ISubgraphService.IndexingAgreementData memory agreement = _getSubgraphService().getIndexingAgreement(_key);
         require(agreement.lastCollectionAt > 0, DisputeManagerIndexingAgreementNotDisputable(_key));
+        require(
+            agreement.version == ISubgraphService.IndexingAgreementVersion.V1,
+            DisputeManagerIndexingAgreementInvalidVersion(agreement.version)
+        );
 
         // The indexer must be disputable
         IHorizonStaking.Provision memory provision = _graphStaking().getProvision(

packages/subgraph-service/contracts/SubgraphService.sol

@@ -17,6 +17,7 @@ import { DataServiceFees } from "@graphprotocol/horizon/contracts/data-service/e
 import { Directory } from "./utilities/Directory.sol";
 import { AllocationManager } from "./utilities/AllocationManager.sol";
 import { SubgraphServiceV1Storage } from "./SubgraphServiceStorage.sol";
+import { Decoder } from "./Decoder.sol";
 
 import { TokenUtils } from "@graphprotocol/contracts/contracts/utils/TokenUtils.sol";
 import { PPMMath } from "@graphprotocol/horizon/contracts/libraries/PPMMath.sol";
@@ -40,6 +41,7 @@ contract SubgraphService is
     Directory,
     AllocationManager,
     SubgraphServiceV1Storage,
+    Decoder,
     IRewardsIssuer,
     ISubgraphService
 {
@@ -288,11 +290,9 @@ contract SubgraphService is
             );
             paymentCollected = _collectIndexingRewards(allocationId, poi, _delegationRatio);
         } else if (paymentType == IGraphPayments.PaymentTypes.IndexingFee) {
-            (IndexingAgreementKey memory key, uint256 entities, bytes32 poi) = abi.decode(
-                data,
-                (IndexingAgreementKey, uint256, bytes32)
-            );
-            paymentCollected = _collectIndexingFees(key, entities, poi);
+            (IndexingAgreementKey memory key, bytes memory iaCollectionData) = _decodeCollectIndexingFeeData(data);
+
+            paymentCollected = _collectIndexingFees(key, iaCollectionData);
         } else {
             revert SubgraphServiceInvalidPaymentType(paymentType);
         }
@@ -555,6 +555,10 @@ contract SubgraphService is
     mapping(address indexer => mapping(address payer => mapping(bytes16 agreementId => IndexingAgreementData data)))
         public indexingAgreements;
 
+    /// @notice Tracks indexing agreements parameters (V1)
+    mapping(address indexer => mapping(address payer => mapping(bytes16 agreementId => IndexingAgreementTermsV1 data)))
+        public indexingAgreementTermsV1;
+
     /// @notice Lookup agreement key by allocation ID
     mapping(address allocationId => IndexingAgreementKey key) public allocationToActiveAgreementKey;
 
@@ -572,7 +576,7 @@ contract SubgraphService is
      * - Agreement must not have been accepted before
      * - Allocation must not have an agreement already
      *
-     * @dev signedRCV.rcv.metadata is an encoding of {ISubgraphService.RCVMetadata}
+     * @dev signedRCV.rcv.metadata is an encoding of {ISubgraphService.RCVIndexingAgreementMetadata}
      *
      * Emits {IndexingAgreementAccepted} event
      *
@@ -594,22 +598,17 @@ contract SubgraphService is
             SubgraphServiceIndexingAgreementDataServiceMismatch(signedRCV.rcv.dataService)
         );
 
-        RCVMetadata memory metadata;
-        try this.decodeRCVMetadata(signedRCV.rcv.metadata) returns (RCVMetadata memory decoded) {
-            metadata = decoded;
-            _acceptIndexingAgreement(allocationId, signedRCV, decoded);
-        } catch {
-            revert SubgraphServiceInvalidRCVMetadata(signedRCV.rcv.metadata);
-        }
+        RCVIndexingAgreementMetadata memory metadata = _decodeRCVMetadata(signedRCV.rcv.metadata);
+        _acceptIndexingAgreement(allocationId, signedRCV, metadata);
 
         emit IndexingAgreementAccepted(
             signedRCV.rcv.serviceProvider,
             signedRCV.rcv.payer,
             signedRCV.rcv.agreementId,
             allocationId,
             metadata.subgraphDeploymentId,
-            metadata.tokensPerSecond,
-            metadata.tokensPerEntityPerSecond
+            metadata.version,
+            metadata.terms
         );
     }
 
@@ -681,16 +680,6 @@ contract SubgraphService is
         return indexingAgreements[key.indexer][key.payer][key.agreementId];
     }
 
-    /**
-     * @notice Decodes the indexing agreement metadata.
-     *
-     * @param metadata The metadata to decode. See {ISubgraphService.RCVMetadata}
-     * @return The decoded metadata
-     */
-    function decodeRCVMetadata(bytes calldata metadata) public pure returns (RCVMetadata memory) {
-        return abi.decode(metadata, (RCVMetadata));
-    }
-
     /**
      * @notice Collect Indexing fees
      * Stake equal to the amount being collected times the `stakeToFeesRatio` is locked into a stake claim.
@@ -709,53 +698,54 @@ contract SubgraphService is
      *
      * Emits a {StakeClaimsReleased} event, and a {StakeClaimReleased} event for each claim released.
      * Emits a {StakeClaimLocked} event.
-     * Emits a {IndexingFeesCollected} event.
+     * Emits a {IndexingFeesCollectedV1} event.
      *
      * @param _key The indexing agreement key
-     * @param _entities The number of entities indexed
-     * @param _poi The proof of indexing
+     * @param _data The indexing agreement collection data
      * @return The amount of fees collected
      */
-    function _collectIndexingFees(
-        IndexingAgreementKey memory _key,
-        uint256 _entities,
-        bytes32 _poi
-    ) private returns (uint256) {
+    function _collectIndexingFees(IndexingAgreementKey memory _key, bytes memory _data) private returns (uint256) {
         IndexingAgreementData memory agreement = _requireActiveIndexingAgreement(_key);
         Allocation.State memory allocation = _requireValidAllocation(agreement.allocationId, _key.indexer);
 
+        require(
+            agreement.version == IndexingAgreementVersion.V1,
+            SubgraphServiceInvalidIndexingAgreementVersion(agreement.version)
+        );
+        (uint256 entities, bytes32 poi) = _decodeCollectIndexingFeeDataV1(_data);
+
         uint256 tokensCollected = _indexingAgreementCollect(
             _key,
             bytes32(uint256(uint160(agreement.allocationId))),
-            _indexingAgreementTokensToCollect(_key, _entities)
+            _indexingAgreementTokensToCollect(_key, entities)
         );
 
         _releaseAndLockStake(_key.indexer, tokensCollected);
 
-        emit IndexingFeesCollected(
+        emit IndexingFeesCollectedV1(
             _key.indexer,
             _key.payer,
             _key.agreementId,
             agreement.allocationId,
             allocation.subgraphDeploymentId,
             _graphEpochManager().currentEpoch(),
             tokensCollected,
-            _entities,
-            _poi
+            entities,
+            poi
         );
         return tokensCollected;
     }
 
     function _acceptIndexingAgreement(
         address _allocationId,
         IRecurringCollector.SignedRCV calldata _signedRCV,
-        RCVMetadata memory _metadata
+        RCVIndexingAgreementMetadata memory _agreementMetadata
     ) private {
         Allocation.State memory allocation = _requireValidAllocation(_allocationId, _signedRCV.rcv.serviceProvider);
         require(
-            allocation.subgraphDeploymentId == _metadata.subgraphDeploymentId,
+            allocation.subgraphDeploymentId == _agreementMetadata.subgraphDeploymentId,
             SubgraphServiceIndexingAgreementDeploymentIdMismatch(
-                _metadata.subgraphDeploymentId,
+                _agreementMetadata.subgraphDeploymentId,
                 _allocationId,
                 allocation.subgraphDeploymentId
             )
@@ -776,25 +766,37 @@ contract SubgraphService is
         allocationToActiveAgreementKey[_allocationId] = key;
 
         agreement.allocationId = _allocationId;
-        agreement.tokensPerSecond = _metadata.tokensPerSecond;
-        agreement.tokensPerEntityPerSecond = _metadata.tokensPerEntityPerSecond;
         agreement.acceptedAt = block.timestamp;
 
+        require(
+            _agreementMetadata.version == IndexingAgreementVersion.V1,
+            SubgraphServiceInvalidIndexingAgreementVersion(_agreementMetadata.version)
+        );
+        _acceptIndexingAgreementTermsV1(key, _agreementMetadata.terms);
+
         _recurringCollector().accept(_signedRCV);
     }
 
+    function _acceptIndexingAgreementTermsV1(IndexingAgreementKey memory _key, bytes memory _data) private {
+        IndexingAgreementTermsV1 memory agreementTermsV1 = _decodeAcceptIndexingAgreementTermsV1(_data);
+        IndexingAgreementTermsV1 storage termsV1 = _getForUpdateIndexingAgreementTermsV1(_key);
+        termsV1.tokensPerSecond = agreementTermsV1.tokensPerSecond;
+        termsV1.tokensPerEntityPerSecond = agreementTermsV1.tokensPerEntityPerSecond;
+    }
+
     function _indexingAgreementTokensToCollect(
         IndexingAgreementKey memory _key,
         uint256 _entities
     ) private returns (uint256) {
         IndexingAgreementData storage agreement = _getForUpdateIndexingAgreement(_key);
+        IndexingAgreementTermsV1 memory termsV1 = _getIndexingAgreementTermsV1(_key);
 
         uint256 collectionSeconds = block.timestamp;
         collectionSeconds -= agreement.lastCollectionAt > 0 ? agreement.lastCollectionAt : agreement.acceptedAt;
         agreement.lastCollectionAt = block.timestamp;
 
         // FIX-ME: this is bad because it encourages people to collect at max seconds allowed to maximize collection.
-        return collectionSeconds * (agreement.tokensPerSecond + agreement.tokensPerEntityPerSecond * _entities);
+        return collectionSeconds * (termsV1.tokensPerSecond + termsV1.tokensPerEntityPerSecond * _entities);
     }
 
     function _indexingAgreementCollect(
@@ -851,6 +853,18 @@ contract SubgraphService is
         return indexingAgreements[_key.indexer][_key.payer][_key.agreementId];
     }
 
+    function _getForUpdateIndexingAgreementTermsV1(
+        IndexingAgreementKey memory _key
+    ) private view returns (IndexingAgreementTermsV1 storage) {
+        return indexingAgreementTermsV1[_key.indexer][_key.payer][_key.agreementId];
+    }
+
+    function _getIndexingAgreementTermsV1(
+        IndexingAgreementKey memory _key
+    ) private view returns (IndexingAgreementTermsV1 memory) {
+        return indexingAgreementTermsV1[_key.indexer][_key.payer][_key.agreementId];
+    }
+
     function _requireValidAllocation(
         address _allocationId,
         address _indexer

packages/subgraph-service/contracts/interfaces/IDisputeManager.sol

@@ -353,9 +353,16 @@ interface IDisputeManager {
 
     /**
      * @notice Thrown when the Indexing Agreement is not disputable
+     * @param agreementKey The indexing agreement key
      */
     error DisputeManagerIndexingAgreementNotDisputable(ISubgraphService.IndexingAgreementKey agreementKey);
 
+    /**
+     * @notice Thrown when the Indexing Agreement is not disputable
+     * @param version The indexing agreement version
+     */
+    error DisputeManagerIndexingAgreementInvalidVersion(ISubgraphService.IndexingAgreementVersion version);
+
     /**
      * @notice Initialize this contract.
      * @param owner The owner of the contract
@@ -469,8 +476,8 @@ interface IDisputeManager {
     function createIndexingDispute(address allocationId, bytes32 poi) external returns (bytes32);
 
     /**
-     * @notice Create an indexing fee dispute for the arbitrator to resolve.
-     * The disputes are created in reference to an indexing agreement and specifically
+     * @notice Create an indexing fee (version 1) dispute for the arbitrator to resolve.
+     * The disputes are created in reference to a version 1 indexing agreement and specifically
      * a POI and entities provided when collecting that agreement.
      * This function is called by a fisherman and it will pull `disputeDeposit` GRT tokens.
      *
@@ -483,7 +490,7 @@ interface IDisputeManager {
      * @param entities The number of entities disputed
      * @return The dispute id
      */
-    function createIndexingFeeDispute(
+    function createIndexingFeeDisputeV1(
         ISubgraphService.IndexingAgreementKey calldata agreementKey,
         bytes32 poi,
         uint256 entities