Optimised the loop in validatePayment to loop over Proving Periods instead of epochs

Author: parzival1821

service_contracts/foundry.lock

@@ -0,0 +1,20 @@
+{
+  "lib/forge-std": {
+    "rev": "f46d8301cf732f4f83846565aa475628265e51e0"
+  },
+  "lib/fws-payments": {
+    "rev": "477228d2d1e93bf7b2aa7e24018e88994806ddba"
+  },
+  "lib/openzeppelin-contracts": {
+    "rev": "a6ae04acf8e38ed49a70fdce5389df2752e3ecc4"
+  },
+  "lib/openzeppelin-contracts-upgradeable": {
+    "rev": "3bfc52f2fbf5be95de632f346169dac6a669bd57"
+  },
+  "lib/pdp": {
+    "rev": "61681392933926fbccb142ab7767e037680850b4"
+  },
+  "lib/session-key-registry": {
+    "rev": "e472ca2b525fb2396832216182b64a0c165cb49c"
+  }
+}

service_contracts/src/FilecoinWarmStorageService.sol

@@ -1632,15 +1632,48 @@ contract FilecoinWarmStorageService is
 
         // Count proven epochs and find the last proven epoch
         uint256 provenEpochCount = 0;
-        uint256 lastProvenEpoch = fromEpoch;
+        uint256 lastProvenEpoch = 0;
 
-        // Check each epoch in the range
-        for (uint256 epoch = fromEpoch + 1; epoch <= toEpoch; epoch++) {
-            bool isProven = isEpochProven(dataSetId, epoch);
 
-            if (isProven) {
-                provenEpochCount++;
-                lastProvenEpoch = epoch;
+        // Updated algorithm
+        uint256 activationEpoch = provingActivationEpoch[dataSetId];
+        if(activationEpoch != 0 && toEpoch >= activationEpoch && toEpoch < block.number){
+            // now, starting epoch - fromEpoch + 1. find period corres to it. find out how long that period lasts and add that many epochs. then keep adding 2880 epochs till period end passes the endEpoch 
+
+            if(fromEpoch < activationEpoch){
+                fromEpoch = activationEpoch;
+            }
+
+            uint256 startingPeriod = getProvingPeriodForEpoch(dataSetId, fromEpoch + 1);
+            uint256 endingPeriod = getProvingPeriodForEpoch(dataSetId, toEpoch);
+
+            // lets handle first period separately
+            uint256 startingPeriod_deadline = _calcPeriodDeadline(dataSetId, startingPeriod);
+
+            if(toEpoch < startingPeriod_deadline){
+                if(_isPeriodProven(dataSetId, startingPeriod)){
+                    provenEpochCount = (toEpoch - fromEpoch);
+                    lastProvenEpoch = toEpoch;
+                }
+            } else {
+                if(_isPeriodProven(dataSetId, startingPeriod)){
+                    provenEpochCount += (startingPeriod_deadline - fromEpoch);
+                }
+
+                // now loop through the proving periods between endingPeriod and startingPeriod. 
+                for(uint256 period = startingPeriod + 1; period <= endingPeriod - 1; period++){
+                    if(provenPeriods[dataSetId][period]){ // here to check if period is proven, we can simply access the mapping since a period in between cannot be the current period 
+                        provenEpochCount += maxProvingPeriod;
+                        lastProvenEpoch = _calcPeriodDeadline(dataSetId, period);
+                    }
+                }
+
+                // now handle the last period separately
+                if(_isPeriodProven(dataSetId, endingPeriod)){
+                    // then the epochs to add = `endingPeriod_starting` to `toEpoch`. But since `endingPeriod_starting` is simply the ending of its previous period, so
+                    provenEpochCount += (toEpoch - _calcPeriodDeadline(dataSetId, endingPeriod - 1));
+                    lastProvenEpoch = toEpoch;
+                }
             }
         }
 
@@ -1669,6 +1702,18 @@ contract FilecoinWarmStorageService is
         });
     }
 
+    function _isPeriodProven(uint256 dataSetId, uint256 periodId) private view returns(bool){
+        uint256 currentPeriod = getProvingPeriodForEpoch(dataSetId, block.number);
+        if(periodId == currentPeriod){
+            return provenThisPeriod[dataSetId];
+        } 
+        return provenPeriods[dataSetId][periodId];
+    }
+
+    function _calcPeriodDeadline(uint256 dataSetId, uint256 periodId) private view returns(uint256){
+        return provingActivationEpoch[dataSetId] + ((periodId+1) * maxProvingPeriod); // we need to do `periodId + 1` since it starts from 0
+    }
+
     function railTerminated(uint256 railId, address terminator, uint256 endEpoch) external override {
         require(msg.sender == paymentsContractAddress, Errors.CallerNotPayments(paymentsContractAddress, msg.sender));