Add index-coop contracts needed for Perp Strategy Extension deployment (#7)

* Remove BaseManagerV2

* Remove StreamingFeeSplitExtension

* Add FeeSplitExtension contract

* Add SupplyCapIssuanceHook

Author: cgewecke

contracts/extensions/StreamingFeeSplitExtension.sol renamed to contracts/extensions/FeeSplitExtension.sol

@@ -23,22 +23,21 @@ import { Address } from "@openzeppelin/contracts/utils/Address.sol";
 import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
 
 import { BaseExtension } from "../lib/BaseExtension.sol";
+import { IIssuanceModule } from "../interfaces/IIssuanceModule.sol";
 import { IBaseManager } from "../interfaces/IBaseManager.sol";
 import { ISetToken } from "../interfaces/ISetToken.sol";
 import { IStreamingFeeModule } from "../interfaces/IStreamingFeeModule.sol";
 import { PreciseUnitMath } from "../lib/PreciseUnitMath.sol";
 import { TimeLockUpgrade } from "../lib/TimeLockUpgrade.sol";
-import { MutualUpgrade } from "../lib/MutualUpgrade.sol";
 
 
 /**
- * @title StreamingFeeSplitExtension
+ * @title FeeSplitExtension
  * @author Set Protocol
  *
- * Smart contract manager extension that allows for splitting and setting streaming fees. Fee splits are updated by operator.
- * Any fee updates are timelocked.
+ * Smart contract extension that allows for splitting and setting streaming and mint/redeem fees.
  */
-contract StreamingFeeSplitExtension is BaseExtension, TimeLockUpgrade, MutualUpgrade {
+contract FeeSplitExtension is BaseExtension, TimeLockUpgrade {
     using Address for address;
     using PreciseUnitMath for uint256;
     using SafeMath for uint256;
@@ -56,6 +55,7 @@ contract StreamingFeeSplitExtension is BaseExtension, TimeLockUpgrade, MutualUpg
 
     ISetToken public setToken;
     IStreamingFeeModule public streamingFeeModule;
+    IIssuanceModule public issuanceModule;
 
     // Percent of fees in precise units (10^16 = 1%) sent to operator, rest to methodologist
     uint256 public operatorFeeSplit;
@@ -68,13 +68,15 @@ contract StreamingFeeSplitExtension is BaseExtension, TimeLockUpgrade, MutualUpg
     constructor(
         IBaseManager _manager,
         IStreamingFeeModule _streamingFeeModule,
+        IIssuanceModule _issuanceModule,
         uint256 _operatorFeeSplit,
         address _operatorFeeRecipient
     )
         public
         BaseExtension(_manager)
     {
         streamingFeeModule = _streamingFeeModule;
+        issuanceModule = _issuanceModule;
         operatorFeeSplit = _operatorFeeSplit;
         operatorFeeRecipient = _operatorFeeRecipient;
         setToken = manager.setToken();
@@ -83,9 +85,10 @@ contract StreamingFeeSplitExtension is BaseExtension, TimeLockUpgrade, MutualUpg
     /* ============ External Functions ============ */
 
     /**
-     * ANYONE CALLABLE: Accrues fees from streaming fee module. Gets resulting balance after fee accrual,
-     * calculates fees for operator and methodologist, and sends to operatorFeeRecipient and methodologist
-     * respectively.
+     * ANYONE CALLABLE: Accrues fees from streaming fee module. Gets resulting balance after fee accrual, calculates fees for
+     * operator and methodologist, and sends to operator fee recipient and methodologist respectively. NOTE: mint/redeem fees
+     * will automatically be sent to this address so reading the balance of the SetToken in the contract after accrual is
+     * sufficient for accounting for all collected fees.
      */
     function accrueFeesAndDistribute() public {
         // Emits a FeeActualized event
@@ -110,97 +113,91 @@ contract StreamingFeeSplitExtension is BaseExtension, TimeLockUpgrade, MutualUpg
     }
 
     /**
-     * MUTUAL UPGRADE: Initializes the streaming fee module. Operator and Methodologist must each call
-     * this function to execute the update.
+     * ONLY OPERATOR: Updates streaming fee on StreamingFeeModule.
+     * Because the method is timelocked, each party must call it twice: once to set the lock and once to execute.
      *
-     * This method is called after invoking `replaceProtectedModule` or `emergencyReplaceProtectedModule`
-     * to configure the replacement streaming fee module's fee settings.
+     * Method is timelocked to protect token owners from sudden changes in fee structure which
+     * they would rather not bear. The delay gives them a chance to exit their positions without penalty.
+     *
+     * NOTE: This will accrue streaming fees though not send to operator fee recipient and methodologist.
      *
-     * @dev FeeState settings encode the following struct
-     * ```
-     * struct FeeState {
-     *   address feeRecipient;                // Address to accrue fees to
-     *   uint256 maxStreamingFeePercentage;   // Max streaming fee maanager commits to using (1% = 1e16, 100% = 1e18)
-     *   uint256 streamingFeePercentage;      // Percent of Set accruing to manager annually (1% = 1e16, 100% = 1e18)
-     *   uint256 lastStreamingFeeTimestamp;   // Timestamp last streaming fee was accrued
-     *}
-     *```
-     * @param _settings     FeeModule.FeeState settings
+     * @param _newFee       Percent of Set accruing to fee extension annually (1% = 1e16, 100% = 1e18)
      */
-    function initializeModule(IStreamingFeeModule.FeeState memory _settings)
+    function updateStreamingFee(uint256 _newFee)
         external
-        mutualUpgrade(manager.operator(), manager.methodologist())
+        onlyOperator
+        timeLockUpgrade
     {
-        bytes memory callData = abi.encodeWithSelector(
-            IStreamingFeeModule.initialize.selector,
-            manager.setToken(),
-            _settings
-        );
-
+        bytes memory callData = abi.encodeWithSignature("updateStreamingFee(address,uint256)", manager.setToken(), _newFee);
         invokeManager(address(streamingFeeModule), callData);
     }
 
     /**
-     * MUTUAL UPGRADE: Updates streaming fee on StreamingFeeModule. Operator and Methodologist must
-     * each call this function to execute the update. Because the method is timelocked, each party
-     * must call it twice: once to set the lock and once to execute.
+     * ONLY OPERATOR: Updates issue fee on IssuanceModule. Only is executed once time lock has passed.
+     * Because the method is timelocked, each party must call it twice: once to set the lock and once to execute.
      *
      * Method is timelocked to protect token owners from sudden changes in fee structure which
      * they would rather not bear. The delay gives them a chance to exit their positions without penalty.
      *
-     * NOTE: This will accrue streaming fees though not send to operator fee recipient and methodologist.
-     *
-     * @param _newFee       Percent of Set accruing to fee extension annually (1% = 1e16, 100% = 1e18)
+     * @param _newFee           New issue fee percentage in precise units (1% = 1e16, 100% = 1e18)
      */
-    function updateStreamingFee(uint256 _newFee)
+    function updateIssueFee(uint256 _newFee)
         external
-        mutualUpgrade(manager.operator(), manager.methodologist())
+        onlyOperator
         timeLockUpgrade
     {
-        bytes memory callData = abi.encodeWithSelector(
-            IStreamingFeeModule.updateStreamingFee.selector,
-            manager.setToken(),
-            _newFee
-        );
+        bytes memory callData = abi.encodeWithSignature("updateIssueFee(address,uint256)", manager.setToken(), _newFee);
+        invokeManager(address(issuanceModule), callData);
+    }
 
-        invokeManager(address(streamingFeeModule), callData);
+    /**
+     * ONLY OPERATOR: Updates redeem fee on IssuanceModule. Only is executed once time lock has passed.
+     * Because the method is timelocked, each party must call it twice: once to set the lock and once to execute.
+     *
+     * Method is timelocked to protect token owners from sudden changes in fee structure which
+     * they would rather not bear. The delay gives them a chance to exit their positions without penalty.
+     *
+     * @param _newFee           New redeem fee percentage in precise units (1% = 1e16, 100% = 1e18)
+     */
+    function updateRedeemFee(uint256 _newFee)
+        external
+        onlyOperator
+        timeLockUpgrade
+    {
+        bytes memory callData = abi.encodeWithSignature("updateRedeemFee(address,uint256)", manager.setToken(), _newFee);
+        invokeManager(address(issuanceModule), callData);
     }
 
     /**
-     * MUTUAL UPGRADE: Updates fee recipient on streaming fee module.
+     * ONLY OPERATOR: Updates fee recipient on both streaming fee and issuance modules.
      *
      * @param _newFeeRecipient  Address of new fee recipient. This should be the address of the fee extension itself.
      */
     function updateFeeRecipient(address _newFeeRecipient)
         external
-        mutualUpgrade(manager.operator(), manager.methodologist())
+        onlyOperator
     {
-        bytes memory callData = abi.encodeWithSelector(
-            IStreamingFeeModule.updateFeeRecipient.selector,
-            manager.setToken(),
-            _newFeeRecipient
-        );
-
+        bytes memory callData = abi.encodeWithSignature("updateFeeRecipient(address,address)", manager.setToken(), _newFeeRecipient);
         invokeManager(address(streamingFeeModule), callData);
+        invokeManager(address(issuanceModule), callData);
     }
 
     /**
-     * MUTUAL UPGRADE: Updates fee split between operator and methodologist. Split defined in precise units (1% = 10^16).
-     * Fees will be accrued and distributed before the new split goes into effect.
+     * ONLY OPERATOR: Updates fee split between operator and methodologist. Split defined in precise units (1% = 10^16).
      *
      * @param _newFeeSplit      Percent of fees in precise units (10^16 = 1%) sent to operator, (rest go to the methodologist).
      */
     function updateFeeSplit(uint256 _newFeeSplit)
         external
-        mutualUpgrade(manager.operator(), manager.methodologist())
+        onlyOperator
     {
         require(_newFeeSplit <= PreciseUnitMath.preciseUnit(), "Fee must be less than 100%");
         accrueFeesAndDistribute();
         operatorFeeSplit = _newFeeSplit;
     }
 
     /**
-     * OPERATOR ONLY: Updates the address that receives the operator's share of the fees (see IIP-72)
+     * ONLY OPERATOR: Updates the address that receives the operator's fees (see IIP-72)
      *
      * @param _newOperatorFeeRecipient  Address to send operator's fees to.
      */
@@ -211,4 +208,4 @@ contract StreamingFeeSplitExtension is BaseExtension, TimeLockUpgrade, MutualUpg
         require(_newOperatorFeeRecipient != address(0), "Zero address not valid");
         operatorFeeRecipient = _newOperatorFeeRecipient;
     }
-}
+}

contracts/hooks/SupplyCapIssuanceHook.sol

@@ -0,0 +1,104 @@
+/*
+    Copyright 2021 Set Labs Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+    SPDX-License-Identifier: Apache License, Version 2.0
+*/
+
+pragma solidity 0.6.10;
+pragma experimental ABIEncoderV2;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { SafeMath } from "@openzeppelin/contracts/math/SafeMath.sol";
+
+import { IManagerIssuanceHook } from "../interfaces/IManagerIssuanceHook.sol";
+import { ISetToken } from "../interfaces/ISetToken.sol";
+
+
+/**
+ * @title SupplyCapIssuanceHook
+ * @author Set Protocol
+ *
+ * Issuance hook that checks new issuances won't push SetToken totalSupply over supply cap.
+ */
+contract SupplyCapIssuanceHook is Ownable, IManagerIssuanceHook {
+    using SafeMath for uint256;
+
+    /* ============ Events ============ */
+
+    event SupplyCapUpdated(uint256 _newCap);
+
+    /* ============ State Variables ============ */
+
+    // Cap on totalSupply of Sets
+    uint256 public supplyCap;
+
+    /* ============ Constructor ============ */
+
+    /**
+     * Constructor, overwrites owner and original supply cap.
+     *
+     * @param _initialOwner     Owner address, overwrites Ownable logic which sets to deployer as default
+     * @param _supplyCap        Supply cap for Set (in wei of Set)
+     */
+    constructor(
+        address _initialOwner,
+        uint256 _supplyCap
+    )
+        public
+    {
+        supplyCap = _supplyCap;
+
+        // Overwrite _owner param of Ownable contract
+        transferOwnership(_initialOwner);
+    }
+
+    /**
+     * Adheres to IManagerIssuanceHook interface, and checks to make sure the current issue call won't push total supply over cap.
+     */
+    function invokePreIssueHook(
+        ISetToken _setToken,
+        uint256 _issueQuantity,
+        address /*_sender*/,
+        address /*_to*/
+    )
+        external
+        override
+    {
+        uint256 totalSupply = _setToken.totalSupply();
+
+        require(totalSupply.add(_issueQuantity) <= supplyCap, "Supply cap exceeded");
+    }
+
+    /**
+     * Adheres to IManagerIssuanceHook interface
+     */
+    function invokePreRedeemHook(
+        ISetToken _setToken,
+        uint256 _redeemQuantity,
+        address _sender,
+        address _to
+    )
+        external
+        override
+    {}
+
+    /**
+     * ONLY OWNER: Updates supply cap
+     */
+    function updateSupplyCap(uint256 _newCap) external onlyOwner {
+        supplyCap = _newCap;
+        SupplyCapUpdated(_newCap);
+    }
+}

contracts/lib/BaseExtension.sol

@@ -117,16 +117,6 @@ abstract contract BaseExtension {
 
     /* ============ Internal Functions ============ */
 
-    /**
-     * Invoke manager to transfer tokens from manager to other contract.
-     *
-     * @param _token           Token being transferred from manager contract
-     * @param _amount          Amount of token being transferred
-     */
-    function invokeManagerTransfer(address _token, address _destination, uint256 _amount) internal {
-        manager.transferTokens(_token, _destination, _amount);
-    }
-
     /**
      * Invoke call from manager
      *