Final polish [COMP-1037] (#74)

This patch adds some improvements based on discoveries from the testnet phase of the release.

The `claimComp` function has been enhanced in several ways to make it far more gas-efficient and versatile. In particular, it no longer refreshes speeds and allows specifying multiple accounts to claim, the markets in which to claim, and whether to claim the supply side and/or the borrow side independently.

The `NewCompRate` event parameter names were changed to reflect that the arguments are not actually mantissas (even though COMP per block units have 18 decimals).

When we `transferComp` and check if the COMP accrued is above the threshold, we now also check if the accrued amount is exactly 0, in order to short-circuit unnecessary transfers.

Finally, this patch extends the COMP Balance Metadata Lens to include COMP Allocated (that is, what is owed to you but not yet received). This is useful for showing users on an interface how much COMP they have earned, since it can be 'called' to return the differential value. A future version may implement this as a pure-view function, though it is more complex and requires detailed understanding about the way COMP is accrued, so the simpler approach is favored initially.

Co-authored-by: Max Wolff <[email protected]>
Co-authored-by: Geoff Hayes <[email protected]>

Author: 3 people

contracts/Comptroller.sol

@@ -51,7 +51,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
     event MarketComped(CToken cToken, bool isComped);
 
     /// @notice Emitted when COMP rate is changed
-    event NewCompRate(uint oldCompRateMantissa, uint newCompRateMantissa);
+    event NewCompRate(uint oldCompRate, uint newCompRate);
 
     /// @notice Emitted when a new COMP speed is calculated for a market
     event CompSpeedUpdated(CToken indexed cToken, uint newSpeed);
@@ -247,7 +247,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
 
         // Keep the flywheel moving
         updateCompSupplyIndex(cToken);
-        distributeSupplierComp(cToken, minter);
+        distributeSupplierComp(cToken, minter, false);
 
         return uint(Error.NO_ERROR);
     }
@@ -287,7 +287,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
 
         // Keep the flywheel moving
         updateCompSupplyIndex(cToken);
-        distributeSupplierComp(cToken, redeemer);
+        distributeSupplierComp(cToken, redeemer, false);
 
         return uint(Error.NO_ERROR);
     }
@@ -376,7 +376,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
         // Keep the flywheel moving
         Exp memory borrowIndex = Exp({mantissa: CToken(cToken).borrowIndex()});
         updateCompBorrowIndex(cToken, borrowIndex);
-        distributeBorrowerComp(cToken, borrower, borrowIndex);
+        distributeBorrowerComp(cToken, borrower, borrowIndex, false);
 
         return uint(Error.NO_ERROR);
     }
@@ -424,7 +424,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
         // Keep the flywheel moving
         Exp memory borrowIndex = Exp({mantissa: CToken(cToken).borrowIndex()});
         updateCompBorrowIndex(cToken, borrowIndex);
-        distributeBorrowerComp(cToken, borrower, borrowIndex);
+        distributeBorrowerComp(cToken, borrower, borrowIndex, false);
 
         return uint(Error.NO_ERROR);
     }
@@ -557,8 +557,8 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
 
         // Keep the flywheel moving
         updateCompSupplyIndex(cTokenCollateral);
-        distributeSupplierComp(cTokenCollateral, borrower);
-        distributeSupplierComp(cTokenCollateral, liquidator);
+        distributeSupplierComp(cTokenCollateral, borrower, false);
+        distributeSupplierComp(cTokenCollateral, liquidator, false);
 
         return uint(Error.NO_ERROR);
     }
@@ -611,8 +611,8 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
 
         // Keep the flywheel moving
         updateCompSupplyIndex(cToken);
-        distributeSupplierComp(cToken, src);
-        distributeSupplierComp(cToken, dst);
+        distributeSupplierComp(cToken, src, false);
+        distributeSupplierComp(cToken, dst, false);
 
         return uint(Error.NO_ERROR);
     }
@@ -1110,7 +1110,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
         return msg.sender == admin || msg.sender == comptrollerImplementation;
     }
 
-    /*** Comp Flywheel Distribution ***/
+    /*** Comp Distribution ***/
 
     /**
      * @notice Recalculate and update COMP speeds for all COMP markets
@@ -1197,7 +1197,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
      * @param cToken The market in which the supplier is interacting
      * @param supplier The address of the supplier to distribute COMP to
      */
-    function distributeSupplierComp(address cToken, address supplier) internal {
+    function distributeSupplierComp(address cToken, address supplier, bool distributeAll) internal {
         CompMarketState storage supplyState = compSupplyState[cToken];
         Double memory supplyIndex = Double({mantissa: supplyState.index});
         Double memory supplierIndex = Double({mantissa: compSupplierIndex[cToken][supplier]});
@@ -1211,7 +1211,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
         uint supplierTokens = CToken(cToken).balanceOf(supplier);
         uint supplierDelta = mul_(supplierTokens, deltaIndex);
         uint supplierAccrued = add_(compAccrued[supplier], supplierDelta);
-        compAccrued[supplier] = transferComp(supplier, supplierAccrued, compClaimThreshold);
+        compAccrued[supplier] = transferComp(supplier, supplierAccrued, distributeAll ? 0 : compClaimThreshold);
         emit DistributedSupplierComp(CToken(cToken), supplier, supplierDelta, supplyIndex.mantissa);
     }
 
@@ -1221,7 +1221,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
      * @param cToken The market in which the borrower is interacting
      * @param borrower The address of the borrower to distribute COMP to
      */
-    function distributeBorrowerComp(address cToken, address borrower, Exp memory marketBorrowIndex) internal {
+    function distributeBorrowerComp(address cToken, address borrower, Exp memory marketBorrowIndex, bool distributeAll) internal {
         CompMarketState storage borrowState = compBorrowState[cToken];
         Double memory borrowIndex = Double({mantissa: borrowState.index});
         Double memory borrowerIndex = Double({mantissa: compBorrowerIndex[cToken][borrower]});
@@ -1232,7 +1232,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
             uint borrowerAmount = div_(CToken(cToken).borrowBalanceStored(borrower), marketBorrowIndex);
             uint borrowerDelta = mul_(borrowerAmount, deltaIndex);
             uint borrowerAccrued = add_(compAccrued[borrower], borrowerDelta);
-            compAccrued[borrower] = transferComp(borrower, borrowerAccrued, compClaimThreshold);
+            compAccrued[borrower] = transferComp(borrower, borrowerAccrued, distributeAll ? 0 : compClaimThreshold);
             emit DistributedBorrowerComp(CToken(cToken), borrower, borrowerDelta, borrowIndex.mantissa);
         }
     }
@@ -1245,7 +1245,7 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
      * @return The amount of COMP which was NOT transferred to the user
      */
     function transferComp(address user, uint userAccrued, uint threshold) internal returns (uint) {
-        if (userAccrued >= threshold) {
+        if (userAccrued >= threshold && userAccrued > 0) {
             Comp comp = Comp(getCompAddress());
             uint compRemaining = comp.balanceOf(address(this));
             if (userAccrued <= compRemaining) {
@@ -1257,24 +1257,52 @@ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerE
     }
 
     /**
-     * @notice Claim all the comp accrued by holder
-     * @param holder The address to claim comp for
+     * @notice Claim all the comp accrued by holder in all markets
+     * @param holder The address to claim COMP for
      */
     function claimComp(address holder) public {
-        refreshCompSpeeds();
+        return claimComp(holder, allMarkets);
+    }
 
-        CToken[] memory allMarkets_ = allMarkets;
-        for (uint i = 0; i < allMarkets_.length; i++) {
-            CToken cToken = allMarkets_[i];
-            Exp memory borrowIndex = Exp({mantissa: cToken.borrowIndex()});
-            distributeSupplierComp(address(cToken), holder);
-            distributeBorrowerComp(address(cToken), holder, borrowIndex);
-        }
+    /**
+     * @notice Claim all the comp accrued by holder in the specified markets
+     * @param holder The address to claim COMP for
+     * @param cTokens The list of markets to claim COMP in
+     */
+    function claimComp(address holder, CToken[] memory cTokens) public {
+        address[] memory holders = new address[](1);
+        holders[0] = holder;
+        claimComp(holders, cTokens, true, true);
+    }
 
-        compAccrued[holder] = transferComp(holder, compAccrued[holder], 0);
+    /**
+     * @notice Claim all comp accrued by the holders
+     * @param holders The addresses to claim COMP for
+     * @param cTokens The list of markets to claim COMP in
+     * @param borrowers Whether or not to claim COMP earned by borrowing
+     * @param suppliers Whether or not to claim COMP earned by supplying
+     */
+    function claimComp(address[] memory holders, CToken[] memory cTokens, bool borrowers, bool suppliers) public {
+        for (uint i = 0; i < cTokens.length; i++) {
+            CToken cToken = cTokens[i];
+            require(markets[address(cToken)].isListed, "market must be listed");
+            if (borrowers == true) {
+                Exp memory borrowIndex = Exp({mantissa: cToken.borrowIndex()});
+                updateCompBorrowIndex(address(cToken), borrowIndex);
+                for (uint j = 0; j < holders.length; j++) {
+                    distributeBorrowerComp(address(cToken), holders[j], borrowIndex, true);
+                }
+            }
+            if (suppliers == true) {
+                updateCompSupplyIndex(address(cToken));
+                for (uint j = 0; j < holders.length; j++) {
+                    distributeSupplierComp(address(cToken), holders[j], true);
+                }
+            }
+        }
     }
 
-    /*** Comp Flyhwheel Admin ***/
+    /*** Comp Distribution Admin ***/
 
     /**
      * @notice Set the amount of COMP distributed per block

contracts/Lens/CompoundLens.sol

@@ -259,6 +259,29 @@ contract CompoundLens {
         });
     }
 
+    struct CompBalanceMetadataExt {
+        uint balance;
+        uint votes;
+        address delegate;
+        uint allocated;
+    }
+
+    function getCompBalanceMetadataExt(Comp comp, Comptroller comptroller, address account) external returns (CompBalanceMetadataExt memory) {
+        uint balance = comp.balanceOf(account);
+        comptroller.claimComp(account);
+        uint newBalance = comp.balanceOf(account);
+        uint accrued = comptroller.compAccrued(account);
+        uint total = add(accrued, newBalance, "sum comp total");
+        uint allocated = sub(total, balance, "sub allocated");
+
+        return CompBalanceMetadataExt({
+            balance: balance,
+            votes: uint256(comp.getCurrentVotes(account)),
+            delegate: comp.delegates(account),
+            allocated: allocated
+        });
+    }
+
     struct CompVotes {
         uint blockNumber;
         uint votes;
@@ -278,4 +301,16 @@ contract CompoundLens {
     function compareStrings(string memory a, string memory b) internal pure returns (bool) {
         return (keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b))));
     }
+
+    function add(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
+        uint c = a + b;
+        require(c >= a, errorMessage);
+        return c;
+    }
+
+    function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
+        require(b <= a, errorMessage);
+        uint c = a - b;
+        return c;
+    }
 }

contracts/Flywheel/Reservoir.sol renamed to contracts/Reservoir.sol

@@ -97,4 +97,4 @@ contract Reservoir {
   }
 }
 
-import "../EIP20Interface.sol";
+import "./EIP20Interface.sol";