feat: getters without out of gas ---> pagination

contracts/DistributionCreator.sol

@@ -49,9 +49,9 @@
 import { RewardTokenAmounts } from "./struct/RewardTokenAmounts.sol";
 
 interface IDistributionCreator {
     function tryGetExtensiveDistributionParameters(
         DistributionParameters memory distribution
     ) external view returns (bool success, ExtensiveDistributionParameters memory extensiveParams);
 }
 
 /// @title DistributionCreator
@@ -291,9 +291,37 @@
     }
 
     /// @notice Returns the list of all currently active distributions on pools of supported AMMs (like Uniswap V3)
-    function getActiveDistributions() external view returns (ExtensiveDistributionParameters[] memory) {
+    function getActiveDistributions()
+        external
+        view
+        returns (ExtensiveDistributionParameters[] memory searchDistributions)
+    {
         uint32 roundedEpoch = _getRoundedEpoch(uint32(block.timestamp));
-        return _getPoolDistributionsBetweenEpochs(address(0), roundedEpoch, roundedEpoch + EPOCH_DURATION);
+        (searchDistributions, ) = _getPoolDistributionsBetweenEpochs(
+            address(0),
+            roundedEpoch,
+            roundedEpoch + EPOCH_DURATION,
+            0,
+            type(uint32).max
+        );
+    }
+
+    /// @notice Similar to `getActiveDistributions()` with additional parameters to prevent out of gas error
+    /// @param skip Disregard distibutions with a global index lower than `skip`
+    /// @param first Limit the length of the returned array to `first`
+    /// @return searchDistributions Eligible distributions
+    /// @return lastIndexDistribution Index of the last distribution assessed in the list of all distributions
+    /// For pagniation purpose, in case of out of gas, you can call back the same function but with `skip` set to `lastIndexDistribution`
+    function getActiveDistributions(
+        uint32 skip,
+        uint32 first
+    )
+        external
+        view
+        returns (ExtensiveDistributionParameters[] memory searchDistributions, uint256 lastIndexDistribution)
+    {
+        uint32 roundedEpoch = _getRoundedEpoch(uint32(block.timestamp));
+        return _getPoolDistributionsBetweenEpochs(address(0), roundedEpoch, roundedEpoch + EPOCH_DURATION, skip, first);
     }
 
     /// @notice Returns the list of all the reward tokens supported as well as their minimum amounts
@@ -320,9 +348,32 @@
 
     /// @notice Returns the list of all the distributions that were or that are going to be live at
     /// a specific epoch
-    function getDistributionsForEpoch(uint32 epoch) external view returns (ExtensiveDistributionParameters[] memory) {
+    function getDistributionsForEpoch(
+        uint32 epoch
+    ) external view returns (ExtensiveDistributionParameters[] memory searchDistributions) {
+        uint32 roundedEpoch = _getRoundedEpoch(epoch);
+        (searchDistributions, ) = _getPoolDistributionsBetweenEpochs(
+            address(0),
+            roundedEpoch,
+            roundedEpoch + EPOCH_DURATION,
+            0,
+            type(uint32).max
+        );
+    }
+
+    /// @notice Similar to `getDistributionsForEpoch(uint256 epoch)` with additional parameters to prevent out of gas error
+    /// @param skip Disregard distibutions with a global index lower than `skip`
+    /// @param first Limit the length of the returned array to `first`
+    /// @return searchDistributions Eligible distributions
+    /// @return lastIndexDistribution Index of the last distribution assessed in the list of all distributions
+    /// For pagniation purpose, in case of out of gas, you can call back the same function but with `skip` set to `lastIndexDistribution`
+    function getDistributionsForEpoch(
+        uint32 epoch,
+        uint32 skip,
+        uint32 first
+    ) external view returns (ExtensiveDistributionParameters[] memory, uint256 lastIndexDistribution) {
         uint32 roundedEpoch = _getRoundedEpoch(epoch);
-        return _getPoolDistributionsBetweenEpochs(address(0), roundedEpoch, roundedEpoch + EPOCH_DURATION);
+        return _getPoolDistributionsBetweenEpochs(address(0), roundedEpoch, roundedEpoch + EPOCH_DURATION, skip, first);
     }
 
     /// @notice Gets the distributions that were or will be live at some point between `epochStart` (included) and `epochEnd` (excluded)
@@ -331,33 +382,125 @@
     function getDistributionsBetweenEpochs(
         uint32 epochStart,
         uint32 epochEnd
-    ) external view returns (ExtensiveDistributionParameters[] memory) {
-        return _getPoolDistributionsBetweenEpochs(address(0), _getRoundedEpoch(epochStart), _getRoundedEpoch(epochEnd));
+    ) external view returns (ExtensiveDistributionParameters[] memory searchDistributions) {
+        (searchDistributions, ) = _getPoolDistributionsBetweenEpochs(
+            address(0),
+            _getRoundedEpoch(epochStart),
+            _getRoundedEpoch(epochEnd),
+            0,
+            type(uint32).max
+        );
+    }
+
+    /// @notice Similar to `getDistributionsBetweenEpochs(uint256 epochStart, uint256 epochEnd)` with additional parameters to prevent out of gas error
+    /// @param skip Disregard distibutions with a global index lower than `skip`
+    /// @param first Limit the length of the returned array to `first`
+    /// @return searchDistributions Eligible distributions
+    /// @return lastIndexDistribution Index of the last distribution assessed in the list of all distributions
+    /// For pagniation purpose, in case of out of gas, you can call back the same function but with `skip` set to `lastIndexDistribution`
+    function getDistributionsBetweenEpochs(
+        uint32 epochStart,
+        uint32 epochEnd,
+        uint32 skip,
+        uint32 first
+    ) external view returns (ExtensiveDistributionParameters[] memory, uint256 lastIndexDistribution) {
+        return
+            _getPoolDistributionsBetweenEpochs(
+                address(0),
+                _getRoundedEpoch(epochStart),
+                _getRoundedEpoch(epochEnd),
+                skip,
+                first
+            );
     }
 
     /// @notice Returns the list of all distributions that were or will be live after `epochStart` (included)
     function getDistributionsAfterEpoch(
         uint32 epochStart
-    ) external view returns (ExtensiveDistributionParameters[] memory) {
-        return _getPoolDistributionsBetweenEpochs(address(0), _getRoundedEpoch(epochStart), type(uint32).max);
+    ) external view returns (ExtensiveDistributionParameters[] memory searchDistributions) {
+        (searchDistributions, ) = _getPoolDistributionsBetweenEpochs(
+            address(0),
+            _getRoundedEpoch(epochStart),
+            type(uint32).max,
+            0,
+            type(uint32).max
+        );
+    }
+
+    /// @notice Similar to `getDistributionsAfterEpoch(uint256 epochStart)` with additional parameters to prevent out of gas error
+    /// @param skip Disregard distibutions with a global index lower than `skip`
+    /// @param first Limit the length of the returned array to `first`
+    /// @return searchDistributions Eligible distributions
+    /// @return lastIndexDistribution Index of the last distribution assessed in the list of all distributions
+    /// For pagniation purpose, in case of out of gas, you can call back the same function but with `skip` set to `lastIndexDistribution`
+    function getDistributionsAfterEpoch(
+        uint32 epochStart,
+        uint32 skip,
+        uint32 first
+    ) external view returns (ExtensiveDistributionParameters[] memory, uint256 lastIndexDistribution) {
+        return
+            _getPoolDistributionsBetweenEpochs(address(0), _getRoundedEpoch(epochStart), type(uint32).max, skip, first);
     }
 
     /// @notice Returns the list of all currently active distributions for a specific UniswapV3 pool
     function getActivePoolDistributions(
         address uniV3Pool
-    ) external view returns (ExtensiveDistributionParameters[] memory) {
+    ) external view returns (ExtensiveDistributionParameters[] memory searchDistributions) {
         uint32 roundedEpoch = _getRoundedEpoch(uint32(block.timestamp));
-        return _getPoolDistributionsBetweenEpochs(uniV3Pool, roundedEpoch, roundedEpoch + EPOCH_DURATION);
+        (searchDistributions, ) = _getPoolDistributionsBetweenEpochs(
+            uniV3Pool,
+            roundedEpoch,
+            roundedEpoch + EPOCH_DURATION,
+            0,
+            type(uint32).max
+        );
+    }
+
+    /// @notice Similar to `getActivePoolDistributions(address uniV3Pool)` with additional parameters to prevent out of gas error
+    /// @param skip Disregard distibutions with a global index lower than `skip`
+    /// @param first Limit the length of the returned array to `first`
+    /// @return searchDistributions Eligible distributions
+    /// @return lastIndexDistribution Index of the last distribution assessed in the list of all distributions
+    /// For pagniation purpose, in case of out of gas, you can call back the same function but with `skip` set to `lastIndexDistribution`
+    function getActivePoolDistributions(
+        address uniV3Pool,
+        uint32 skip,
+        uint32 first
+    ) external view returns (ExtensiveDistributionParameters[] memory, uint256 lastIndexDistribution) {
+        uint32 roundedEpoch = _getRoundedEpoch(uint32(block.timestamp));
+        return _getPoolDistributionsBetweenEpochs(uniV3Pool, roundedEpoch, roundedEpoch + EPOCH_DURATION, skip, first);
     }
 
     /// @notice Returns the list of all the distributions that were or that are going to be live at a
     /// specific epoch and for a specific pool
     function getPoolDistributionsForEpoch(
         address uniV3Pool,
         uint32 epoch
-    ) external view returns (ExtensiveDistributionParameters[] memory) {
+    ) external view returns (ExtensiveDistributionParameters[] memory searchDistributions) {
+        uint32 roundedEpoch = _getRoundedEpoch(epoch);
+        (searchDistributions, ) = _getPoolDistributionsBetweenEpochs(
+            uniV3Pool,
+            roundedEpoch,
+            roundedEpoch + EPOCH_DURATION,
+            0,
+            type(uint32).max
+        );
+    }
+
+    /// @notice Similar to `getPoolDistributionsForEpoch(address uniV3Pool,uint32 epoch)` with additional parameters to prevent out of gas error
+    /// @param skip Disregard distibutions with a global index lower than `skip`
+    /// @param first Limit the length of the returned array to `first`
+    /// @return searchDistributions Eligible distributions
+    /// @return lastIndexDistribution Index of the last distribution assessed in the list of all distributions
+    /// For pagniation purpose, in case of out of gas, you can call back the same function but with `skip` set to `lastIndexDistribution`
+    function getPoolDistributionsForEpoch(
+        address uniV3Pool,
+        uint32 epoch,
+        uint32 skip,
+        uint32 first
+    ) external view returns (ExtensiveDistributionParameters[] memory, uint256 lastIndexDistribution) {
         uint32 roundedEpoch = _getRoundedEpoch(epoch);
-        return _getPoolDistributionsBetweenEpochs(uniV3Pool, roundedEpoch, roundedEpoch + EPOCH_DURATION);
+        return _getPoolDistributionsBetweenEpochs(uniV3Pool, roundedEpoch, roundedEpoch + EPOCH_DURATION, skip, first);
     }
 
     /// @notice Returns the list of all distributions that were or will be live at some point between
@@ -366,17 +509,68 @@
         address uniV3Pool,
         uint32 epochStart,
         uint32 epochEnd
-    ) external view returns (ExtensiveDistributionParameters[] memory) {
-        return _getPoolDistributionsBetweenEpochs(uniV3Pool, _getRoundedEpoch(epochStart), _getRoundedEpoch(epochEnd));
+    ) external view returns (ExtensiveDistributionParameters[] memory searchDistributions) {
+        (searchDistributions, ) = _getPoolDistributionsBetweenEpochs(
+            uniV3Pool,
+            _getRoundedEpoch(epochStart),
+            _getRoundedEpoch(epochEnd),
+            0,
+            type(uint32).max
+        );
+    }
+
+    /// @notice Similar to `getPoolDistributionsBetweenEpochs(address uniV3Pool,uint32 epochStart, uint32 epochEnd)` with additional parameters to prevent out of gas error
+    /// @param skip Disregard distibutions with a global index lower than `skip`
+    /// @param first Limit the length of the returned array to `first`
+    /// @return searchDistributions Eligible distributions
+    /// @return lastIndexDistribution Index of the last distribution assessed in the list of all distributions
+    /// For pagniation purpose, in case of out of gas, you can call back the same function but with `skip` set to `lastIndexDistribution`
+    function getPoolDistributionsBetweenEpochs(
+        address uniV3Pool,
+        uint32 epochStart,
+        uint32 epochEnd,
+        uint32 skip,
+        uint32 first
+    ) external view returns (ExtensiveDistributionParameters[] memory, uint256 lastIndexDistribution) {
+        return
+            _getPoolDistributionsBetweenEpochs(
+                uniV3Pool,
+                _getRoundedEpoch(epochStart),
+                _getRoundedEpoch(epochEnd),
+                skip,
+                first
+            );
     }
 
     /// @notice Returns the list of all distributions that were or will be live after `epochStart` (included)
     /// for a specific pool
     function getPoolDistributionsAfterEpoch(
         address uniV3Pool,
         uint32 epochStart
-    ) external view returns (ExtensiveDistributionParameters[] memory) {
-        return _getPoolDistributionsBetweenEpochs(uniV3Pool, _getRoundedEpoch(epochStart), type(uint32).max);
+    ) external view returns (ExtensiveDistributionParameters[] memory searchDistributions) {
+        (searchDistributions, ) = _getPoolDistributionsBetweenEpochs(
+            uniV3Pool,
+            _getRoundedEpoch(epochStart),
+            type(uint32).max,
+            0,
+            type(uint32).max
+        );
+    }
+
+    /// @notice Similar to `getPoolDistributionsAfterEpoch(address uniV3Pool,uint32 epochStart)` with additional parameters to prevent out of gas error
+    /// @param skip Disregard distibutions with a global index lower than `skip`
+    /// @param first Limit the length of the returned array to `first`
+    /// @return searchDistributions Eligible distributions
+    /// @return lastIndexDistribution Index of the last distribution assessed in the list of all distributions
+    /// For pagniation purpose, in case of out of gas, you can call back the same function but with `skip` set to `lastIndexDistribution`
+    function getPoolDistributionsAfterEpoch(
+        address uniV3Pool,
+        uint32 epochStart,
+        uint32 skip,
+        uint32 first
+    ) external view returns (ExtensiveDistributionParameters[] memory, uint256 lastIndexDistribution) {
+        return
+            _getPoolDistributionsBetweenEpochs(uniV3Pool, _getRoundedEpoch(epochStart), type(uint32).max, skip, first);
     }
 
     // ============================ GOVERNANCE FUNCTIONS ===========================
@@ -527,14 +721,16 @@
     function _getPoolDistributionsBetweenEpochs(
         address uniV3Pool,
         uint32 epochStart,
-        uint32 epochEnd
-    ) internal view returns (ExtensiveDistributionParameters[] memory) {
+        uint32 epochEnd,
+        uint32 skip,
+        uint32 first
+    ) internal view returns (ExtensiveDistributionParameters[] memory, uint256) {
         uint256 length;
         uint256 distributionListLength = distributionList.length;
-        ExtensiveDistributionParameters[] memory activeRewards = new ExtensiveDistributionParameters[](
-            distributionListLength
-        );
-        for (uint32 i; i < distributionListLength; ) {
+        uint256 returnSize = first > distributionListLength ? distributionListLength : first;
+        ExtensiveDistributionParameters[] memory activeRewards = new ExtensiveDistributionParameters[](returnSize);
+        uint32 i = skip;
+        while (i < distributionListLength) {
             DistributionParameters memory distribution = distributionList[i];
             if (
                 _isDistributionLiveBetweenEpochs(distribution, epochStart, epochEnd) &&
@@ -551,10 +747,11 @@
             unchecked {
                 ++i;
             }
+            if (length == returnSize) break;
         }
         assembly {
             mstore(activeRewards, length)
         }
-        return activeRewards;
+        return (activeRewards, i);
     }
 }

package.json

@@ -11,6 +11,7 @@
     "foundry:gas": "forge test --gas-report",
     "foundry:run": "docker run -it --rm -v $(pwd):/app -w /app ghcr.io/foundry-rs/foundry sh",
     "foundry:setup": "curl -L https://foundry.paradigm.xyz | bash && foundryup && git submodule update --init --recursive",
+    "foundry:size": "forge build --skip test --sizes",
     "foundry:test": "forge test -vvv",
     "hardhat:compile": "hardhat compile",
     "hardhat:coverage": "hardhat coverage",
@@ -96,4 +97,4 @@
     "solc": "0.8.12",
     "yargs": "^17.5.1"
   }
-}
+}