Reduce redeem gas costs by 719K/$319 by removing unnecessary totalValues() (#588)

Massively reduce redeem gas costs by removing duplicated total value calculations

Author: DanielVF

contracts/contracts/mocks/MockVault.sol

@@ -2,6 +2,7 @@ pragma solidity 0.5.11;
 
 import { VaultCore } from "../vault/VaultCore.sol";
 import { VaultInitializer } from "../vault/VaultInitializer.sol";
+import "../utils/Helpers.sol";
 
 contract MockVault is VaultCore, VaultInitializer {
     uint256 storedTotalValue;
@@ -18,6 +19,21 @@ contract MockVault is VaultCore, VaultInitializer {
         return storedTotalValue;
     }
 
+    function _checkBalance(address _asset)
+        internal
+        view
+        returns (uint256 balance)
+    {
+        // Avoids rounding errors by returning the total value
+        // in a single currency
+        if (allAssets[0] == _asset) {
+            uint256 decimals = Helpers.getDecimals(_asset);
+            return storedTotalValue.scaleBy(int8(decimals - 18));
+        } else {
+            return 0;
+        }
+    }
+
     function setMaxSupplyDiff(uint256 _maxSupplyDiff) external onlyGovernor {
         maxSupplyDiff = _maxSupplyDiff;
     }

contracts/contracts/vault/VaultCore.sol

@@ -159,9 +159,6 @@ contract VaultCore is VaultStorage {
         whenNotCapitalPaused
         nonReentrant
     {
-        if (_amount > rebaseThreshold && !rebasePaused) {
-            _rebase();
-        }
         _redeem(_amount, _minimumUnitAmount);
     }
 
@@ -173,14 +170,18 @@ contract VaultCore is VaultStorage {
     function _redeem(uint256 _amount, uint256 _minimumUnitAmount) internal {
         require(_amount > 0, "Amount must be greater than 0");
 
-        uint256 _totalSupply = oUSD.totalSupply();
-        uint256 _backingValue = _totalValue();
+        // Calculate redemption outputs
+        (
+            uint256[] memory outputs,
+            uint256 _backingValue
+        ) = _calculateRedeemOutputs(_amount);
 
+        // Check that OUSD is backed by enough assets
+        uint256 _totalSupply = oUSD.totalSupply();
         if (maxSupplyDiff > 0) {
             // Allow a max difference of maxSupplyDiff% between
             // backing assets value and OUSD total supply
             uint256 diff = _totalSupply.divPrecisely(_backingValue);
-
             require(
                 (diff > 1e18 ? diff.sub(1e18) : uint256(1e18).sub(diff)) <=
                     maxSupplyDiff,
@@ -190,8 +191,6 @@ contract VaultCore is VaultStorage {
 
         emit Redeem(msg.sender, _amount);
 
-        // Calculate redemption outputs
-        uint256[] memory outputs = _calculateRedeemOutputs(_amount);
         // Send outputs
         for (uint256 i = 0; i < allAssets.length; i++) {
             if (outputs[i] == 0) continue;
@@ -248,11 +247,6 @@ contract VaultCore is VaultStorage {
         whenNotCapitalPaused
         nonReentrant
     {
-        // Unfortunately we have to do balanceOf twice, the rebase may change
-        // the account balance
-        if (oUSD.balanceOf(msg.sender) > rebaseThreshold && !rebasePaused) {
-            _rebase();
-        }
         _redeem(oUSD.balanceOf(msg.sender), _minimumUnitAmount);
     }
 
@@ -513,7 +507,11 @@ contract VaultCore is VaultStorage {
         view
         returns (uint256[] memory)
     {
-        return _calculateRedeemOutputs(_amount);
+        (
+            uint256[] memory outputs,
+            uint256 totalValue
+        ) = _calculateRedeemOutputs(_amount);
+        return outputs;
     }
 
     /**
@@ -524,7 +522,7 @@ contract VaultCore is VaultStorage {
     function _calculateRedeemOutputs(uint256 _amount)
         internal
         view
-        returns (uint256[] memory outputs)
+        returns (uint256[] memory outputs, uint256 totalBalance)
     {
         // We always give out coins in proportion to how many we have,
         // Now if all coins were the same value, this math would easy,
@@ -559,7 +557,6 @@ contract VaultCore is VaultStorage {
         uint256[] memory assetPrices = _getAssetPrices(true);
         uint256[] memory assetBalances = new uint256[](assetCount);
         uint256[] memory assetDecimals = new uint256[](assetCount);
-        uint256 totalBalance = 0;
         uint256 totalOutputRatio = 0;
         outputs = new uint256[](assetCount);