perf(validatePayment): loop over proving periods (#267)

## Related Issue
Closes 252 ( Once completed)


## Current Progress
I've implemented the updated looping algorithm in validatePayment as
described in the issue
- [x] Replaced the existing loop with new algorithm 
- [ ] Convert provenPeriods to a bitmap
- [ ] Remove provenThisPeriod

## What I Need Feedback On
**Before I continue with the rest of the issue, I'd like to get feedback
on my implementation of the looping algorithm.**

Since there were no existing tests for this specific part of the code, I
want to make sure my approach is correct before implementing the
remaining parts of the issue. Also I would love to help you guys write
some tests for the same if required

## Questions for Maintainers
- Does the new looping logic match what you had in mind?
- Are there any edge cases I should consider?
- Any suggestions for improvement before I move forward?

## Changes Made
- Modified `FilecoinWarmStorageService.sol` to implement the new loop
structure

## Next Steps (after approval)
Once you confirm this approach is correct, I'll:
- Complete the remaining tasks in #252
- Request a full review

**Note:** This is a WIP/Draft PR specifically for early feedback on the
algorithm implementation.
(Also, just a heads-up, I changed my username from `dev-n-dough` to
`parzival1821`

---------

Co-authored-by: William Morriss <[email protected]>

Author: parzival1821

service_contracts/.gitignore

@@ -10,6 +10,7 @@ node_modules/
 
 # Lock files
 package-lock.json
+foundry.lock
 
 # Ignore IDEs
-.idea
+.idea

service_contracts/abi/FilecoinWarmStorageService.abi.json

@@ -401,30 +401,6 @@
     "outputs": [],
     "stateMutability": "nonpayable"
   },
-  {
-    "type": "function",
-    "name": "isEpochProven",
-    "inputs": [
-      {
-        "name": "dataSetId",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "epoch",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "",
-        "type": "bool",
-        "internalType": "bool"
-      }
-    ],
-    "stateMutability": "view"
-  },
   {
     "type": "function",
     "name": "migrate",

service_contracts/src/Errors.sol

@@ -201,7 +201,11 @@ library Errors {
     /// @param railId The rail ID
     error RailNotAssociated(uint256 railId);
 
-    /// @notice The epoch range is invalid (toEpoch must be > fromEpoch)
+    /// @notice The epoch range is invalid
+    /// @notice Will be emitted if any of the following conditions is NOT met:
+    /// @notice 1. fromEpoch must be less than toEpoch
+    /// @notice 2. toEpoch must be less than block number
+    /// @notice 3. toEpoch must be greater than the activation epoch
     /// @param fromEpoch The starting epoch (exclusive)
     /// @param toEpoch The ending epoch (inclusive)
     error InvalidEpochRange(uint256 fromEpoch, uint256 toEpoch);

service_contracts/src/FilecoinWarmStorageService.sol

@@ -1141,43 +1141,6 @@ contract FilecoinWarmStorageService is
         return (epoch - activationEpoch) / maxProvingPeriod;
     }
 
-    /**
-     * @notice Checks if a specific epoch has been proven
-     * @dev Returns true only if the epoch belongs to a proven proving period
-     * @param dataSetId The ID of the data set to check
-     * @param epoch The epoch to check
-     * @return True if the epoch has been proven, false otherwise
-     */
-    function isEpochProven(uint256 dataSetId, uint256 epoch) public view returns (bool) {
-        // Check if data set is active
-        if (provingActivationEpoch[dataSetId] == 0) {
-            return false;
-        }
-
-        // Check if this epoch is before activation
-        if (epoch < provingActivationEpoch[dataSetId]) {
-            return false;
-        }
-
-        // Check if this epoch is in the future (beyond current block)
-        if (epoch > block.number) {
-            return false;
-        }
-
-        // Get the period this epoch belongs to
-        uint256 periodId = getProvingPeriodForEpoch(dataSetId, epoch);
-
-        // Special case: current ongoing proving period
-        uint256 currentPeriod = getProvingPeriodForEpoch(dataSetId, block.number);
-        if (periodId == currentPeriod) {
-            // For the current period, check if it has been proven already
-            return provenThisPeriod[dataSetId];
-        }
-
-        // For past periods, check the provenPeriods bitmapping
-        return 0 != provenPeriods[dataSetId][periodId >> 8] & (1 << (periodId & 255));
-    }
-
     function max(uint256 a, uint256 b) internal pure returns (uint256) {
         return a > b ? a : b;
     }
@@ -1470,7 +1433,8 @@ contract FilecoinWarmStorageService is
         require(totalEpochsRequested > 0, Errors.InvalidEpochRange(fromEpoch, toEpoch));
 
         // If proving wasn't ever activated for this data set, don't pay anything
-        if (provingActivationEpoch[dataSetId] == 0) {
+        uint256 activationEpoch = provingActivationEpoch[dataSetId];
+        if (activationEpoch == 0) {
             return ValidationResult({
                 modifiedAmount: 0,
                 settleUpto: fromEpoch,
@@ -1479,18 +1443,8 @@ contract FilecoinWarmStorageService is
         }
 
         // Count proven epochs and find the last proven epoch
-        uint256 provenEpochCount = 0;
-        uint256 lastProvenEpoch = fromEpoch;
-
-        // Check each epoch in the range
-        for (uint256 epoch = fromEpoch + 1; epoch <= toEpoch; epoch++) {
-            bool isProven = isEpochProven(dataSetId, epoch);
-
-            if (isProven) {
-                provenEpochCount++;
-                lastProvenEpoch = epoch;
-            }
-        }
+        (uint256 provenEpochCount, uint256 lastProvenEpoch) =
+            _findProvenEpochs(dataSetId, fromEpoch, toEpoch, activationEpoch);
 
         // If no epochs are proven, we can't settle anything
         if (provenEpochCount == 0) {
@@ -1504,16 +1458,70 @@ contract FilecoinWarmStorageService is
         // Calculate the modified amount based on proven epochs
         uint256 modifiedAmount = (proposedAmount * provenEpochCount) / totalEpochsRequested;
 
-        // Calculate how many epochs were not proven (faulted)
-        uint256 faultedEpochs = totalEpochsRequested - provenEpochCount;
-
         return ValidationResult({
             modifiedAmount: modifiedAmount,
             settleUpto: lastProvenEpoch, // Settle up to the last proven epoch
             note: ""
         });
     }
 
+    function _findProvenEpochs(uint256 dataSetId, uint256 fromEpoch, uint256 toEpoch, uint256 activationEpoch)
+        internal
+        view
+        returns (uint256 provenEpochCount, uint256 settledUpTo)
+    {
+        require(toEpoch >= activationEpoch && toEpoch <= block.number, Errors.InvalidEpochRange(fromEpoch, toEpoch));
+        uint256 currentPeriod = getProvingPeriodForEpoch(dataSetId, block.number);
+
+        if (fromEpoch < activationEpoch - 1) {
+            fromEpoch = activationEpoch - 1;
+        }
+
+        uint256 startingPeriod = getProvingPeriodForEpoch(dataSetId, fromEpoch + 1);
+
+        // handle first period separately
+        uint256 startingPeriodDeadline = _calcPeriodDeadline(activationEpoch, startingPeriod);
+
+        if (toEpoch < startingPeriodDeadline) {
+            if (_isPeriodProven(dataSetId, startingPeriod, currentPeriod)) {
+                provenEpochCount = toEpoch - fromEpoch;
+                settledUpTo = toEpoch;
+            }
+        } else {
+            if (_isPeriodProven(dataSetId, startingPeriod, currentPeriod)) {
+                provenEpochCount += (startingPeriodDeadline - fromEpoch);
+            }
+
+            uint256 endingPeriod = getProvingPeriodForEpoch(dataSetId, toEpoch);
+            // loop through the proving periods between startingPeriod and endingPeriod
+            for (uint256 period = startingPeriod + 1; period < endingPeriod; period++) {
+                if (_isPeriodProven(dataSetId, period, currentPeriod)) {
+                    provenEpochCount += maxProvingPeriod;
+                }
+            }
+            settledUpTo = _calcPeriodDeadline(activationEpoch, endingPeriod - 1);
+
+            // handle the last period separately
+            if (_isPeriodProven(dataSetId, endingPeriod, currentPeriod)) {
+                provenEpochCount += (toEpoch - settledUpTo);
+                settledUpTo = toEpoch;
+            }
+        }
+        return (provenEpochCount, settledUpTo);
+    }
+
+    function _isPeriodProven(uint256 dataSetId, uint256 periodId, uint256 currentPeriod) private view returns (bool) {
+        if (periodId == currentPeriod) {
+            return provenThisPeriod[dataSetId];
+        }
+        uint256 isProven = provenPeriods[dataSetId][periodId >> 8] & (1 << (periodId & 255));
+        return isProven != 0;
+    }
+
+    function _calcPeriodDeadline(uint256 activationEpoch, uint256 periodId) private view returns (uint256) {
+        return activationEpoch + (periodId + 1) * maxProvingPeriod;
+    }
+
     function railTerminated(uint256 railId, address terminator, uint256 endEpoch) external override {
         require(msg.sender == paymentsContractAddress, Errors.CallerNotPayments(paymentsContractAddress, msg.sender));