fix: Change access control for rebalance method to allow non-operator accounts to call it. (#123)

* Use onlyAllowedCaller instead of onlyOperator to control access to rebalance method

* Undo accidental change in BaseExtension

* Remove onlyEOA from docstring comment

* Extended `minPositions` configuration to potentially allow opening up access to `rebalance` method (#125)

* Extend minPosition configuration to allow opening up rebalance method

* Refactoring to make precommit linter happy

* Refactoring of FixedRebalanceExtension.sol

* Return current positions from rebalance method

* Add tests for returned position values

* Increase tolerance in integration tests

* Fix wrong indentation

Co-authored-by: Richard Guan <[email protected]>

* Remove extra space from test name

Co-authored-by: Richard Guan <[email protected]>

Co-authored-by: Christian Koopmann <[email protected]>
Co-authored-by: Richard Guan <[email protected]>

Author: 3 people

contracts/adapters/FixedRebalanceExtension.sol

@@ -49,12 +49,13 @@ contract FixedRebalanceExtension is BaseExtension {
 
     // /* ============ Events ============ */
 
-    event AllocationsUpdated(uint256[] _maturities, uint256[] _allocations);
+    event AllocationsUpdated(uint256[] _maturities, uint256[] _allocations, uint256[] _minPositions);
 
     // /* ============ State Variables ============ */
 
     uint256[] internal maturities;                               // Array of relative maturities in seconds (i.e. 3 months / 6 months)
     uint256[] internal allocations;                              // Relative allocations 
+    uint256[] internal minPositions;                             // Minimum positions to achieve after every full rebalancing (assuming share = 100 %)
 
     ISetToken public immutable setToken;                       
     INotionalTradeModule internal immutable notionalTradeModule; 
@@ -77,7 +78,8 @@ contract FixedRebalanceExtension is BaseExtension {
         address _underlyingToken,
         address _assetToken,
         uint256[] memory _maturities,
-        uint256[] memory _allocations
+        uint256[] memory _allocations,
+        uint256[] memory _minPositions
     )
         public
         BaseExtension(_manager)
@@ -90,7 +92,7 @@ contract FixedRebalanceExtension is BaseExtension {
         assetToken = _assetToken;
         currencyId = _notionalProxy.getCurrencyId(_assetToken);
 
-        _setAllocations(_maturities, _allocations);
+        _setAllocations(_maturities, _allocations, _minPositions);
     }
 
     // /* ============ External Functions ============ */
@@ -110,24 +112,24 @@ contract FixedRebalanceExtension is BaseExtension {
      * @param _maturities                Relative maturities (i.e. "3 months") in seconds
      * @param _allocations               Relative allocations (i.e. 0.9 = 90%) with 18 decimals corresponding to the respective maturity
      */
-    function setAllocations(uint256[] memory _maturities, uint256[] memory _allocations) external onlyOperator {
-        _setAllocations(_maturities, _allocations);
+    function setAllocations(uint256[] memory _maturities, uint256[] memory _allocations, uint256[] memory _minPositions) external onlyOperator {
+        _setAllocations(_maturities, _allocations, _minPositions);
     }
 
     /**
-     * ONLY OPERATOR: Rebalances the positions towards the configured allocation percentages.
+     * ONLY ALLOWED CALLER: Rebalances the positions towards the configured allocation percentages.
      *
-     * @param _share                Relative share of the necessary trade volume to execute (allows for splitting the rebalance over multiple transactions
-     * @param _minPositions         Minimum positions (in set token units) for each maturity after rebalance. (slippage protection)
+     * @param _share                 Relative share of the necessary trade volume to execute (allows for splitting the rebalance over multiple transactions
+     * @param _rebalanceMinPositions Minimum positions (in set token units) for each maturity after this rebalance operation. 
+     * @dev Will revert if _rebalanceMinPositions is lower than the minPositions configured by the operator (weighted by share)
      */
-    function rebalance(uint256 _share, uint256[] memory _minPositions) external onlyOperator {
+    function rebalance(uint256 _share, uint256[] memory _rebalanceMinPositions) external onlyAllowedCaller(msg.sender) returns(uint256[] memory) {
         require(_share > 0, "Share must be greater than 0");
         require(_share <= 1 ether, "Share cannot exceed 100%");
 
-        // TODO: Review if we want to open up this method for anyone to call.
-        _sellOverweightPositions(_share);
+        uint256[] memory currentPositionsBefore = _sellOverweightPositions(_share);
         _buyUnderweightPositions(_share);
-        _checkCurrentPositions(_minPositions);
+        return _checkCurrentPositions(currentPositionsBefore, _rebalanceMinPositions, _share);
     }
 
     // Aggregates all fCash positions + asset token position into a single value
@@ -150,24 +152,41 @@ contract FixedRebalanceExtension is BaseExtension {
         }
     }
 
-    // Get maturities and allocations
-    function getAllocations() external view returns (uint256[] memory, uint256[] memory) {
-        return (maturities, allocations);
+    // Get maturities, allocations and minPositions
+    function getAllocations() external view returns (uint256[] memory, uint256[] memory, uint256[] memory) {
+        return (maturities, allocations, minPositions);
     }
 
     // Convert relative to aboslute maturity
     function relativeToAbsoluteMaturity(uint256 _relativeMaturity) external view returns (uint256) {
         return _relativeToAbsoluteMaturity(_relativeMaturity);
     }
 
+    // Return current token position for each maturity;
+    function getCurrentPositions()
+        external
+        view
+        returns(uint256[] memory currentPositions)
+    {
+        currentPositions = new uint256[](maturities.length);
+        for(uint i = 0; i < maturities.length; i++) {
+            uint256 maturity = _relativeToAbsoluteMaturity(maturities[i]);
+            address wrappedfCash = wrappedfCashFactory.computeAddress(currencyId, uint40(maturity));
+            int256 currentPositionSigned = setToken.getDefaultPositionRealUnit(wrappedfCash);
+            require(currentPositionSigned >= 0, "Negative position");
+            currentPositions[i] = uint256(currentPositionSigned);
+        }
+    }
+
+
 
 
     // /* ============ Internal Functions ============ */
 
     // @dev Sells fCash positions that are currently above their targeted allocation
     // @dev _maturity         absolute maturity of fCash to redeem
     // @param _share          Relative share of the necessary trade volume to execute (allows for splitting the rebalance over multiple transactions
-    function _sellOverweightPositions(uint256 _share) internal {
+    function _sellOverweightPositions(uint256 _share) internal returns(uint256[] memory){
         (
             uint256[] memory overweightPositions,
             uint256[] memory currentPositions,
@@ -179,6 +198,7 @@ contract FixedRebalanceExtension is BaseExtension {
                 _redeemFCash(absoluteMaturities[i], receiveAmount, currentPositions[i]);
             }
         }
+        return currentPositions;
     }
 
     // @dev Buys fCash positions that are currently below their targeted allocation
@@ -197,20 +217,40 @@ contract FixedRebalanceExtension is BaseExtension {
         }
     }
 
-    function _checkCurrentPositions(uint256[] memory _minPositions)
+    // @dev Checks that the positions after rebalance are above the _rebalanceMinPositions specified in rebalanceCall
+    // @dev Also verifies that _rebalanceMinPositions are above the minPositions configured by the operator (weighted by _share)
+    function _checkCurrentPositions(uint256[] memory _positionsBefore, uint256[] memory _rebalanceMinPositions, uint256 _share)
         internal
         view
+        returns(uint256[] memory currentPositions)
     {
-        require(_minPositions.length == maturities.length, "Min positions must be same length as maturities");
+        require(_rebalanceMinPositions.length == maturities.length , "Min positions must be same length as maturities");
+        currentPositions = new uint256[](maturities.length);
         for(uint i = 0; i < maturities.length; i++) {
+
+            uint256 weightedMinPosition = _getWeightedMinPosition(minPositions[i], _positionsBefore[i], _share);
+            require(_rebalanceMinPositions[i] >= weightedMinPosition, "Caller provided min position must not be less than operator specified value weighted by share");
             uint256 maturity = _relativeToAbsoluteMaturity(maturities[i]);
             address wrappedfCash = wrappedfCashFactory.computeAddress(currencyId, uint40(maturity));
             int256 currentPositionSigned = setToken.getDefaultPositionRealUnit(wrappedfCash);
             require(currentPositionSigned >= 0, "Negative position");
-            require(uint256(currentPositionSigned) >= _minPositions[i], "Position below min");
+            require(uint256(currentPositionSigned) >= _rebalanceMinPositions[i], "Position below min");
+            currentPositions[i] = uint256(currentPositionSigned);
         }
     }
 
+    // @dev Calculates the minimumPosition for a given maturity by taking the weighted average between the _minPosition configured by the operator and the position before the rebalance call.
+    function _getWeightedMinPosition(uint256 _minPosition, uint256 _positionBefore, uint256 _share) internal pure returns(uint256) {
+        if(_minPosition > _positionBefore) {
+            // If the position was below the min position before you have to increase it by at least _share % of the difference
+            return _positionBefore.add(_minPosition.sub(_positionBefore).preciseMul(_share));
+        } else {
+            // If the position was above the min position before you can only decrease it by maximum _share % of the difference
+            return _positionBefore.sub(_positionBefore.sub(_minPosition).preciseMul(_share));
+        } 
+    }
+
+
     // @dev Get positions that are currently above their targeted weight
     function _getOverweightPositions()
         internal
@@ -380,21 +420,21 @@ contract FixedRebalanceExtension is BaseExtension {
 
 
     // @dev Sets configured allocations for the setToken
-    function _setAllocations(uint256[] memory _maturities, uint256[] memory _allocations) internal {
-        require(_maturities.length == _allocations.length, "Maturities and allocations must be same length");
+    function _setAllocations(uint256[] memory _maturities, uint256[] memory _allocations, uint256[] memory _minPositions) internal {
+        require((_maturities.length == _allocations.length) && (_maturities.length == _minPositions.length), "Maturities, minPositions and allocations must be same length");
         uint256 totalAllocation = 0;
         for (uint256 i = 0; i < _maturities.length; i++) {
             totalAllocation = totalAllocation.add(_allocations[i]);
         }
         require(totalAllocation == PreciseUnitMath.preciseUnit(), "Allocations must sum to 1");
         maturities = _maturities;
-        emit AllocationsUpdated(_maturities, _allocations);
         allocations = _allocations;
+        minPositions = _minPositions;
+        emit AllocationsUpdated(_maturities, _allocations, _minPositions);
     }
 
     // @dev Returns the token via which to trade
     function _getTradeToken() internal view returns(address) {
         return tradeViaUnderlying ? underlyingToken : assetToken;
     }
-
 }