fix: remove redundant getAllocation & getLegacyAllocation functions.

Author: MoonBoi9001

packages/subgraph-service/contracts/DisputeManager.sol

@@ -431,7 +431,7 @@ contract DisputeManager is
         // Get attestation signer. Indexers signs with the allocationId
         address allocationId = _recoverSigner(attestation);
 
-        Allocation.State memory alloc = subgraphService.getAllocation(allocationId);
+        Allocation.State memory alloc = subgraphService.allocations(allocationId);
         require(alloc.indexer != address(0), DisputeManagerIndexerNotFound(allocationId));
         require(
             alloc.subgraphDeploymentId == attestation.subgraphDeploymentId,
@@ -533,7 +533,7 @@ contract DisputeManager is
         require(!isDisputeCreated(disputeId), DisputeManagerDisputeAlreadyCreated(disputeId));
 
         // Allocation must exist
-        Allocation.State memory alloc = subgraphService.getAllocation(_allocationId);
+        Allocation.State memory alloc = subgraphService.allocations(_allocationId);
         address indexer = alloc.indexer;
         require(indexer != address(0), DisputeManagerIndexerNotFound(_allocationId));
 

packages/subgraph-service/contracts/SubgraphService.sol

@@ -400,18 +400,11 @@ contract SubgraphService is
         emit CurationCutSet(curationCut);
     }
 
-    /**
-     * @notice See {ISubgraphService.getAllocation}
-     */
-    function getAllocation(address allocationId) external view override returns (Allocation.State memory) {
-        return allocations[allocationId];
-    }
-
     /**
      * @notice Get allocation data to calculate rewards issuance
      * @dev Implements {IRewardsIssuer.getAllocationData}
-     * @dev Note that this is slightly different than {getAllocation}. It returns an
-     * unstructured subset of the allocation data, which is the minimum required to mint rewards.
+     * @dev Note Returns an unstructured subset of the allocation data,
+     * which is the minimum required to mint rewards.
      *
      * Should only be used by the {RewardsManager}.
      *
@@ -457,13 +450,6 @@ contract SubgraphService is
         return allocations[allocationId].isOpen();
     }
 
-    /**
-     * @notice See {ISubgraphService.getLegacyAllocation}
-     */
-    function getLegacyAllocation(address allocationId) external view override returns (LegacyAllocation.State memory) {
-        return legacyAllocations[allocationId];
-    }
-
     /**
      * @notice See {ISubgraphService.encodeAllocationProof}
      */

packages/subgraph-service/contracts/SubgraphServiceStorage.sol

@@ -12,4 +12,10 @@ abstract contract SubgraphServiceV1Storage {
 
     /// @notice The cut curators take from query fee payments
     uint256 public curationFeesCut;
+
+    /// @notice Allocations managed by the service
+    mapping(address => Allocation.State) public allocations;
+
+    /// @notice Legacy allocations managed by the service
+    mapping(address => LegacyAllocation.State) public legacyAllocations;
 }

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

@@ -217,20 +217,6 @@ interface ISubgraphService is IDataServiceFees {
      */
     function setRewardsDestination(address rewardsDestination) external;
 
-    /**
-     * @notice Gets the details of an allocation
-     * For legacy allocations use {getLegacyAllocation}
-     * @param allocationId The id of the allocation
-     */
-    function getAllocation(address allocationId) external view returns (Allocation.State memory);
-
-    /**
-     * @notice Gets the details of a legacy allocation
-     * For non-legacy allocations use {getAllocation}
-     * @param allocationId The id of the allocation
-     */
-    function getLegacyAllocation(address allocationId) external view returns (LegacyAllocation.State memory);
-
     /**
      * @notice Encodes the allocation proof for EIP712 signing
      * @param indexer The address of the indexer

packages/subgraph-service/test/disputeManager/DisputeManager.t.sol

@@ -69,7 +69,7 @@ contract DisputeManagerTest is SubgraphServiceSharedTest {
         bytes32 expectedDisputeId = keccak256(abi.encodePacked(_allocationId, _poi));
         uint256 disputeDeposit = disputeManager.disputeDeposit();
         uint256 beforeFishermanBalance = token.balanceOf(fisherman);
-        Allocation.State memory alloc = subgraphService.getAllocation(_allocationId);
+        Allocation.State memory alloc = subgraphService.allocations(_allocationId);
         uint256 stakeSnapshot = disputeManager.getStakeSnapshot(alloc.indexer);
 
         // Approve the dispute deposit

packages/subgraph-service/test/shared/SubgraphServiceShared.t.sol

@@ -111,7 +111,7 @@ abstract contract SubgraphServiceSharedTest is HorizonStakingSharedTest {
         subgraphService.startService(_indexer, _data);
 
         // Check allocation data
-        Allocation.State memory allocation = subgraphService.getAllocation(allocationId);
+        Allocation.State memory allocation = subgraphService.allocations(allocationId);
         assertEq(allocation.tokens, tokens);
         assertEq(allocation.indexer, _indexer);
         assertEq(allocation.subgraphDeploymentId, subgraphDeploymentId);
@@ -130,7 +130,7 @@ abstract contract SubgraphServiceSharedTest is HorizonStakingSharedTest {
         address allocationId = abi.decode(_data, (address));
         assertTrue(subgraphService.isActiveAllocation(allocationId));
 
-        Allocation.State memory allocation = subgraphService.getAllocation(allocationId);
+        Allocation.State memory allocation = subgraphService.allocations(allocationId);
         uint256 previousSubgraphAllocatedTokens = subgraphService.getSubgraphAllocatedTokens(allocation.subgraphDeploymentId);
 
         vm.expectEmit(address(subgraphService));
@@ -141,7 +141,7 @@ abstract contract SubgraphServiceSharedTest is HorizonStakingSharedTest {
         subgraphService.stopService(_indexer, _data);
 
         // update allocation
-        allocation = subgraphService.getAllocation(allocationId);
+        allocation = subgraphService.allocations(allocationId);
 
         // check allocation
         assertEq(allocation.closedAt, block.timestamp);

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

@@ -104,7 +104,7 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
 
     function _resizeAllocation(address _indexer, address _allocationId, uint256 _tokens) internal {
         // before state
-        Allocation.State memory beforeAllocation = subgraphService.getAllocation(_allocationId);
+        Allocation.State memory beforeAllocation = subgraphService.allocations(_allocationId);
         bytes32 subgraphDeploymentId = beforeAllocation.subgraphDeploymentId;
         uint256 beforeSubgraphAllocatedTokens = subgraphService.getSubgraphAllocatedTokens(subgraphDeploymentId);
         uint256 beforeAllocatedTokens = subgraphService.allocationProvisionTracker(_indexer);
@@ -131,7 +131,7 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
         // after state
         uint256 afterSubgraphAllocatedTokens = subgraphService.getSubgraphAllocatedTokens(subgraphDeploymentId);
         uint256 afterAllocatedTokens = subgraphService.allocationProvisionTracker(_indexer);
-        Allocation.State memory afterAllocation = subgraphService.getAllocation(_allocationId);
+        Allocation.State memory afterAllocation = subgraphService.allocations(_allocationId);
         uint256 accRewardsPerAllocatedTokenDelta = afterAllocation.accRewardsPerAllocatedToken -
             beforeAllocation.accRewardsPerAllocatedToken;
         uint256 afterAccRewardsPending = rewardsManager.calcRewards(
@@ -154,7 +154,7 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
     function _closeStaleAllocation(address _allocationId) internal {
         assertTrue(subgraphService.isActiveAllocation(_allocationId));
 
-        Allocation.State memory allocation = subgraphService.getAllocation(_allocationId);
+        Allocation.State memory allocation = subgraphService.allocations(_allocationId);
         uint256 previousSubgraphAllocatedTokens = subgraphService.getSubgraphAllocatedTokens(
             allocation.subgraphDeploymentId
         );
@@ -171,7 +171,7 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
         subgraphService.closeStaleAllocation(_allocationId);
 
         // update allocation
-        allocation = subgraphService.getAllocation(_allocationId);
+        allocation = subgraphService.allocations(_allocationId);
 
         // check allocation
         assertEq(allocation.closedAt, block.timestamp);
@@ -231,7 +231,7 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
             // Recover RAV data
             ITAPCollector.SignedRAV memory signedRav = abi.decode(_data, (ITAPCollector.SignedRAV));
             allocationId = abi.decode(signedRav.rav.metadata, (address));
-            allocation = subgraphService.getAllocation(allocationId);
+            allocation = subgraphService.allocations(allocationId);
             address payer = _recoverRAVSigner(signedRav);
 
             // Total amount of tokens collected for indexer
@@ -249,7 +249,7 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
         } else if (_paymentType == IGraphPayments.PaymentTypes.IndexingRewards) {
             // Recover IndexingRewards data
             (allocationId, indexingRewardsData.poi) = abi.decode(_data, (address, bytes32));
-            allocation = subgraphService.getAllocation(allocationId);
+            allocation = subgraphService.allocations(allocationId);
 
             // Calculate accumulated tokens, this depends on the rewards manager which we have mocked
             uint256 accRewardsPerTokens = allocation.tokens.mulPPM(rewardsManager.rewardsPerSignal());
@@ -332,7 +332,7 @@ contract SubgraphServiceTest is SubgraphServiceSharedTest {
             assertEq(stakeClaim.nextClaim, bytes32(0));
         } else if (_paymentType == IGraphPayments.PaymentTypes.IndexingRewards) {
             // Update allocation after collecting rewards
-            allocation = subgraphService.getAllocation(allocationId);
+            allocation = subgraphService.allocations(allocationId);
 
             // Check allocation state
             assertEq(allocation.accRewardsPending, 0);