🆙 Update Carbon contracts in controllers (#669)

Author: truefibot

contracts/carbon/ProtocolConfig.sol

@@ -32,8 +32,8 @@ contract ProtocolConfig is Upgradeable, IProtocolConfig {
         address _protocolAdmin,
         address _protocolTreasury,
         address _pauserAddress
-    ) external initializer {
-        __Upgradeable_init(msg.sender, msg.sender);
+    ) public initializer {
+        __Upgradeable_init(msg.sender, _pauserAddress);
         defaultProtocolFeeRate = _defaultProtocolFeeRate;
         protocolAdmin = _protocolAdmin;
         protocolTreasury = _protocolTreasury;

contracts/carbon/StructuredPortfolio.sol

@@ -11,6 +11,7 @@
 
 pragma solidity ^0.8.16;
 
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
 import {Upgradeable} from "./proxy/Upgradeable.sol";
@@ -52,8 +53,8 @@ contract StructuredPortfolio is IStructuredPortfolio, LoansManager, Upgradeable
         IProtocolConfig _protocolConfig,
         PortfolioParams memory portfolioParams,
         TrancheInitData[] memory tranchesInitData,
-        ExpectedEquityRate calldata _expectedEquityRate
-    ) external initializer {
+        ExpectedEquityRate memory _expectedEquityRate
+    ) public initializer {
         _initialize(_fixedInterestOnlyLoans, underlyingToken);
         __Upgradeable_init(_protocolConfig.protocolAdmin(), _protocolConfig.pauserAddress());
         _grantRole(MANAGER_ROLE, manager);
@@ -101,48 +102,37 @@ contract StructuredPortfolio is IStructuredPortfolio, LoansManager, Upgradeable
     }
 
     function updateCheckpoints() public whenNotPaused {
-        require(status == Status.Live, "SP: Portfolio is not live");
-
+        require(status != Status.CapitalFormation, "SP: No checkpoints before start");
+        (uint256[] memory _totalAssetsAfter, uint256[] memory pendingFees) = _calculateWaterfall(virtualTokenBalance + loansValue());
+        LoansDeficitCheckpoint[] memory deficits = _calculateLoansDeficit(_totalAssetsAfter, pendingFees);
+        for (uint256 i = 0; i < _totalAssetsAfter.length; i++) {
+            tranches[i].updateCheckpointFromPortfolio(_totalAssetsAfter[i], deficits[i].deficit);
+        }
         if (someLoansDefaulted) {
-            _updateCheckpointsAndLoansDeficit();
-        } else {
-            _updateCheckpoints();
+            for (uint256 i = 1; i < deficits.length; i++) {
+                tranchesData[i].loansDeficitCheckpoint = deficits[i];
+            }
         }
     }
 
-    function _updateCheckpointsAndLoansDeficit() internal {
-        uint256[] memory _totalAssetsBefore = new uint256[](tranches.length);
-        for (uint256 i = 0; i < tranches.length; i++) {
-            _totalAssetsBefore[i] = tranches[i].getCheckpoint().totalAssets;
+    function _calculateLoansDeficit(uint256[] memory realTotalAssets, uint256[] memory pendingFees)
+        internal
+        view
+        returns (LoansDeficitCheckpoint[] memory)
+    {
+        LoansDeficitCheckpoint[] memory deficits = new LoansDeficitCheckpoint[](realTotalAssets.length);
+        if (!someLoansDefaulted) {
+            return deficits;
         }
-
-        uint256[] memory _totalAssetsAfter = _updateCheckpoints();
-
         uint256 timestamp = _limitedBlockTimestamp();
-        for (uint256 i = 1; i < _totalAssetsAfter.length; i++) {
-            uint256 currentDeficit = _defaultedLoansDeficit(tranchesData[i], timestamp);
-
-            int256 deficitDelta = SafeCast.toInt256(_totalAssetsBefore[i]) - SafeCast.toInt256(_totalAssetsAfter[i]);
-            uint256 newDeficit = _getNewLoansDeficit(currentDeficit, deficitDelta);
-
-            tranchesData[i].loansDeficitCheckpoint = LoansDeficitCheckpoint({deficit: newDeficit, timestamp: timestamp});
-        }
-    }
-
-    function _updateCheckpoints() internal returns (uint256[] memory) {
-        uint256[] memory _totalAssetsAfter = calculateWaterfall();
-        for (uint256 i = 0; i < _totalAssetsAfter.length; i++) {
-            tranches[i].updateCheckpointFromPortfolio(_totalAssetsAfter[i]);
-        }
-        return _totalAssetsAfter;
-    }
-
-    function _getNewLoansDeficit(uint256 currentDeficit, int256 delta) internal pure returns (uint256) {
-        require(delta > type(int256).min, "SP: Delta out of range");
-        if (delta < 0 && currentDeficit < uint256(-delta)) {
-            return 0;
+        for (uint256 i = 1; i < realTotalAssets.length; i++) {
+            Checkpoint memory checkpoint = tranches[i].getCheckpoint();
+            uint256 assumedTotalAssets = _assumedTrancheValue(i, timestamp);
+            uint256 assumedTotalAssetsAfterFees = _saturatingSub(assumedTotalAssets, Math.max(pendingFees[i], checkpoint.unpaidFees));
+            uint256 newDeficit = _saturatingSub(assumedTotalAssetsAfterFees, realTotalAssets[i]);
+            deficits[i] = LoansDeficitCheckpoint({deficit: newDeficit, timestamp: timestamp});
         }
-        return _addSigned(currentDeficit, delta);
+        return deficits;
     }
 
     function increaseVirtualTokenBalance(uint256 increment) external {
@@ -157,16 +147,18 @@ contract StructuredPortfolio is IStructuredPortfolio, LoansManager, Upgradeable
         uint256 tranchesCount = tranches.length;
         for (uint256 i = 0; i < tranchesCount; i++) {
             if (msg.sender == address(tranches[i])) {
-                virtualTokenBalance = _addSigned(virtualTokenBalance, delta);
+                virtualTokenBalance = delta < 0 ? virtualTokenBalance - uint256(-delta) : virtualTokenBalance + uint256(delta);
                 return;
             }
         }
         revert("SP: Not a tranche");
     }
 
-    function totalAssets() public view returns (uint256) {
+    function totalAssets() external view returns (uint256) {
         if (status == Status.Live) {
-            return liquidAssets() + loansValue();
+            uint256 _totalPendingFees = totalPendingFees();
+            uint256 totalAssetsBeforeFees = virtualTokenBalance + loansValue();
+            return _saturatingSub(totalAssetsBeforeFees, _totalPendingFees);
         }
         return _sum(_tranchesTotalAssets());
     }
@@ -244,6 +236,53 @@ contract StructuredPortfolio is IStructuredPortfolio, LoansManager, Upgradeable
         _checkTranchesRatios(_tranchesTotalAssets());
     }
 
+    function maxTrancheValueComplyingWithRatio(uint256 trancheIdx) external view returns (uint256) {
+        if (status != Status.Live || trancheIdx == 0) {
+            return type(uint256).max;
+        }
+
+        uint256[] memory waterfallValues = calculateWaterfall();
+
+        uint256 subordinateValue = 0;
+        for (uint256 i = 0; i < trancheIdx; i++) {
+            subordinateValue += waterfallValues[i];
+        }
+
+        uint256 minSubordinateRatio = tranchesData[trancheIdx].minSubordinateRatio;
+        if (minSubordinateRatio == 0) {
+            return type(uint256).max;
+        }
+
+        return (subordinateValue * BASIS_PRECISION) / minSubordinateRatio;
+    }
+
+    function minTrancheValueComplyingWithRatio(uint256 trancheIdx) external view returns (uint256) {
+        if (status != Status.Live) {
+            return 0;
+        }
+
+        uint256[] memory trancheValues = calculateWaterfall();
+        uint256 tranchesCount = trancheValues.length;
+        if (trancheIdx == tranchesCount - 1) {
+            return 0;
+        }
+
+        uint256 subordinateValueWithoutTranche = 0;
+        uint256 maxThreshold = 0;
+        for (uint256 i = 0; i < tranchesCount - 1; i++) {
+            uint256 trancheValue = trancheValues[i];
+            if (i != trancheIdx) {
+                subordinateValueWithoutTranche += trancheValue;
+            }
+            if (i >= trancheIdx) {
+                uint256 lowerBound = (trancheValues[i + 1] * tranchesData[i + 1].minSubordinateRatio) / BASIS_PRECISION;
+                uint256 minTrancheValue = _saturatingSub(lowerBound, subordinateValueWithoutTranche);
+                maxThreshold = Math.max(minTrancheValue, maxThreshold);
+            }
+        }
+        return maxThreshold;
+    }
+
     function _tranchesTotalAssets() internal view returns (uint256[] memory) {
         if (status == Status.Live) {
             return calculateWaterfall();
@@ -290,36 +329,24 @@ contract StructuredPortfolio is IStructuredPortfolio, LoansManager, Upgradeable
         }
 
         _changePortfolioStatus(Status.Closed);
+        updateCheckpoints();
 
         if (!isAfterEndDate) {
             endDate = block.timestamp;
         }
     }
 
     function _closeTranches() internal {
+        updateCheckpoints();
         uint256 limitedBlockTimestamp = _limitedBlockTimestamp();
+        (uint256[] memory waterfall, ) = _calculateWaterfall(virtualTokenBalance);
 
-        uint256[] memory waterfallTranchesAssets = calculateWaterfall();
-        uint256[] memory distributedAssets = new uint256[](waterfallTranchesAssets.length);
-        uint256 assetsLeft = virtualTokenBalance;
-
-        for (uint256 i = waterfallTranchesAssets.length - 1; i > 0; i--) {
-            tranchesData[i].maxValueOnClose = _assumedTrancheValue(i, limitedBlockTimestamp);
-
-            uint256 trancheDistributedAssets = _min(waterfallTranchesAssets[i], assetsLeft);
-            distributedAssets[i] = trancheDistributedAssets;
-            tranches[i].updateCheckpointFromPortfolio(trancheDistributedAssets);
-
-            assetsLeft -= trancheDistributedAssets;
-        }
-
-        distributedAssets[0] = _min(waterfallTranchesAssets[0], assetsLeft);
-        tranches[0].updateCheckpointFromPortfolio(distributedAssets[0]);
-
-        for (uint256 i = 0; i < distributedAssets.length; i++) {
-            uint256 trancheDistributedAssets = distributedAssets[i];
-            tranchesData[i].distributedAssets = trancheDistributedAssets;
-            _transfer(tranches[i], trancheDistributedAssets);
+        for (uint256 i = 0; i < waterfall.length; i++) {
+            if (i != 0) {
+                tranchesData[i].maxValueOnClose = _assumedTrancheValue(i, limitedBlockTimestamp);
+            }
+            tranchesData[i].distributedAssets = waterfall[i];
+            _transfer(tranches[i], waterfall[i]);
         }
     }
 
@@ -340,21 +367,34 @@ contract StructuredPortfolio is IStructuredPortfolio, LoansManager, Upgradeable
     }
 
     function calculateWaterfall() public view returns (uint256[] memory) {
-        uint256[] memory waterfall = calculateWaterfallWithoutFees();
+        (uint256[] memory waterfall, ) = _calculateWaterfall(virtualTokenBalance + loansValue());
+        return waterfall;
+    }
+
+    function _calculateWaterfall(uint256 assetsLeft) internal view returns (uint256[] memory, uint256[] memory) {
+        uint256[] memory waterfall = _calculateWaterfallWithoutFees(assetsLeft);
+        uint256[] memory fees = new uint256[](tranches.length);
         for (uint256 i = 0; i < waterfall.length; i++) {
             uint256 pendingFees = tranches[i].totalPendingFeesForAssets(waterfall[i]);
             waterfall[i] = _saturatingSub(waterfall[i], pendingFees);
+            fees[i] = pendingFees;
         }
-        return waterfall;
+        return (waterfall, fees);
     }
 
     function calculateWaterfallWithoutFees() public view returns (uint256[] memory) {
+        return _calculateWaterfallWithoutFees(virtualTokenBalance + loansValue());
+    }
+
+    function _calculateWaterfallWithoutFees(uint256 assetsLeft) internal view returns (uint256[] memory) {
         uint256[] memory waterfall = new uint256[](tranches.length);
         if (status != Status.Live) {
+            for (uint256 i = 0; i < waterfall.length; i++) {
+                waterfall[i] = tranches[i].totalAssetsBeforeFees();
+            }
             return waterfall;
         }
 
-        uint256 assetsLeft = virtualTokenBalance + loansValue();
         uint256 limitedBlockTimestamp = _limitedBlockTimestamp();
 
         for (uint256 i = waterfall.length - 1; i > 0; i--) {
@@ -377,28 +417,20 @@ contract StructuredPortfolio is IStructuredPortfolio, LoansManager, Upgradeable
     function _assumedTrancheValue(uint256 trancheIdx, uint256 timestamp) internal view returns (uint256) {
         Checkpoint memory checkpoint = tranches[trancheIdx].getCheckpoint();
         TrancheData memory trancheData = tranchesData[trancheIdx];
+        uint256 targetApy = trancheData.targetApy;
 
-        uint256 assumedTotalAssets = _assumedTotalAssets(checkpoint, trancheData, timestamp);
-        uint256 defaultedLoansDeficit = _defaultedLoansDeficit(trancheData, timestamp);
+        uint256 timePassedSinceCheckpoint = _saturatingSub(timestamp, checkpoint.timestamp);
+        uint256 assumedTotalAssets = _withInterest(checkpoint.totalAssets, targetApy, timePassedSinceCheckpoint) +
+            checkpoint.unpaidFees;
 
-        return assumedTotalAssets + defaultedLoansDeficit;
-    }
-
-    function _assumedTotalAssets(
-        Checkpoint memory checkpoint,
-        TrancheData memory trancheData,
-        uint256 timestamp
-    ) internal pure returns (uint256) {
-        uint256 timePassed = _saturatingSub(timestamp, checkpoint.timestamp);
-        return _withInterest(checkpoint.totalAssets, trancheData.targetApy, timePassed);
-    }
-
-    function _defaultedLoansDeficit(TrancheData memory trancheData, uint256 timestamp) internal pure returns (uint256) {
-        if (trancheData.loansDeficitCheckpoint.deficit == 0) {
-            return 0;
+        uint256 defaultedLoansDeficit;
+        uint256 checkpointDeficit = trancheData.loansDeficitCheckpoint.deficit;
+        if (checkpointDeficit != 0) {
+            uint256 timePassed = _saturatingSub(timestamp, trancheData.loansDeficitCheckpoint.timestamp);
+            defaultedLoansDeficit = _withInterest(checkpointDeficit, targetApy, timePassed);
         }
-        uint256 timePassed = _saturatingSub(timestamp, trancheData.loansDeficitCheckpoint.timestamp);
-        return _withInterest(trancheData.loansDeficitCheckpoint.deficit, trancheData.targetApy, timePassed);
+
+        return assumedTotalAssets + defaultedLoansDeficit;
     }
 
     function _withInterest(
@@ -456,7 +488,7 @@ contract StructuredPortfolio is IStructuredPortfolio, LoansManager, Upgradeable
                 continue;
             }
 
-            uint256 trancheShare = _min(trancheFreeCapacity, undistributedAssets);
+            uint256 trancheShare = Math.min(trancheFreeCapacity, undistributedAssets);
             undistributedAssets -= trancheShare;
             _repayInClosed(i, trancheShare);
         }
@@ -504,18 +536,10 @@ contract StructuredPortfolio is IStructuredPortfolio, LoansManager, Upgradeable
         emit PortfolioStatusChanged(newStatus);
     }
 
-    function _min(uint256 x, uint256 y) internal pure returns (uint256) {
-        return x > y ? y : x;
-    }
-
     function _saturatingSub(uint256 x, uint256 y) internal pure returns (uint256) {
         return x > y ? x - y : 0;
     }
 
-    function _addSigned(uint256 x, int256 y) internal pure returns (uint256) {
-        return y < 0 ? x - uint256(-y) : x + uint256(y);
-    }
-
     function _sum(uint256[] memory components) internal pure returns (uint256) {
         uint256 sum;
         for (uint256 i = 0; i < components.length; i++) {
@@ -525,7 +549,7 @@ contract StructuredPortfolio is IStructuredPortfolio, LoansManager, Upgradeable
     }
 
     function _limitedBlockTimestamp() internal view returns (uint256) {
-        return _min(block.timestamp, endDate);
+        return Math.min(block.timestamp, endDate);
     }
 
     function _requireManagerRole() internal view {