updated abi and restructured validatePayment to prevent possible stak too deep error

Author: parzival1821

service_contracts/src/FilecoinWarmStorageService.sol

@@ -1634,83 +1634,94 @@ contract FilecoinWarmStorageService is
         uint256 provenEpochCount = 0;
         uint256 lastProvenEpoch = fromEpoch;
 
+        (provenEpochCount, lastProvenEpoch) = findProvenEpochs(dataSetId, fromEpoch, toEpoch);
 
-        // Updated algorithm
+        // If no epochs are proven, we can't settle anything
+        if (provenEpochCount == 0) {
+            return ValidationResult({
+                modifiedAmount: 0,
+                settleUpto: fromEpoch,
+                note: "No proven epochs in the requested range"
+            });
+        }
+
+        // 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;
+
+        // Emit event for logging
+        emit PaymentArbitrated(railId, dataSetId, proposedAmount, modifiedAmount, faultedEpochs);
+
+        return ValidationResult({
+            modifiedAmount: modifiedAmount,
+            settleUpto: lastProvenEpoch, // Settle up to the last proven epoch
+            note: ""
+        });
+    }
+
+    function findProvenEpochs(uint256 dataSetId, uint256 fromEpoch, uint256 toEpoch)
+        public
+        view
+        returns (uint256, uint256)
+    {
+        uint256 provenEpochCount = 0;
+        uint256 lastProvenEpoch = fromEpoch;
         uint256 activationEpoch = provingActivationEpoch[dataSetId];
-        if(toEpoch >= activationEpoch && toEpoch < block.number){
-            // if `toEpoch` lies after activation, and `fromEpoch` lies before activation, then update the `fromEpoch`, as follows : 
-            if(fromEpoch < activationEpoch){
+        if (toEpoch >= activationEpoch && toEpoch < block.number) {
+            // if `toEpoch` lies after activation, and `fromEpoch` lies before activation, then update the `fromEpoch`, as follows :
+            if (fromEpoch < activationEpoch) {
                 fromEpoch = activationEpoch - 1; // we have done -1 because starting epoch is considered as `fromEpoch + 1`
             }
 
             uint256 startingPeriod = getProvingPeriodForEpoch(dataSetId, fromEpoch + 1);
             uint256 endingPeriod = getProvingPeriodForEpoch(dataSetId, toEpoch);
 
-            // lets handle first period separately 
+            // lets handle first period separately
             uint256 startingPeriod_deadline = _calcPeriodDeadline(dataSetId, startingPeriod);
 
-            if(toEpoch < startingPeriod_deadline){ // alternative way to check the same : `startingPeriod == endingPeriod`
-                if(_isPeriodProven(dataSetId, startingPeriod)){
+            if (toEpoch < startingPeriod_deadline) {
+                // alternative way to check the same : `startingPeriod == endingPeriod`
+                if (_isPeriodProven(dataSetId, startingPeriod)) {
                     provenEpochCount = (toEpoch - fromEpoch);
                     lastProvenEpoch = toEpoch;
                 }
             } else {
-                if(_isPeriodProven(dataSetId, startingPeriod)){
+                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(_isPeriodProven(dataSetId, period)){ 
+                // now loop through the proving periods between endingPeriod and startingPeriod.
+                for (uint256 period = startingPeriod + 1; period <= endingPeriod - 1; period++) {
+                    if (_isPeriodProven(dataSetId, period)) {
                         provenEpochCount += maxProvingPeriod;
                         lastProvenEpoch = _calcPeriodDeadline(dataSetId, period);
                     }
                 }
 
                 // now handle the last period separately
-                if(_isPeriodProven(dataSetId, endingPeriod)){
+                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;
                 }
             }
         }
 
-        // If no epochs are proven, we can't settle anything
-        if (provenEpochCount == 0) {
-            return ValidationResult({
-                modifiedAmount: 0,
-                settleUpto: fromEpoch,
-                note: "No proven epochs in the requested range"
-            });
-        }
-
-        // 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;
-
-        // Emit event for logging
-        emit PaymentArbitrated(railId, dataSetId, proposedAmount, modifiedAmount, faultedEpochs);
-
-        return ValidationResult({
-            modifiedAmount: modifiedAmount,
-            settleUpto: lastProvenEpoch, // Settle up to the last proven epoch
-            note: ""
-        });
+        return (provenEpochCount, lastProvenEpoch);
     }
 
-    function _isPeriodProven(uint256 dataSetId, uint256 periodId) private view returns(bool){
+    function _isPeriodProven(uint256 dataSetId, uint256 periodId) private view returns (bool) {
         uint256 currentPeriod = getProvingPeriodForEpoch(dataSetId, block.number);
-        if(periodId == currentPeriod){
+        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 _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 {