SIP-80 Futures

contracts/BaseDebtCache.sol

@@ -18,19 +18,8 @@ import "./interfaces/IERC20.sol";
 import "./interfaces/ICollateralManager.sol";
 import "./interfaces/IEtherWrapper.sol";
 import "./interfaces/IWrapperFactory.sol";
+import "./interfaces/IFuturesMarketManager.sol";
 
-//
-// The debt cache (SIP-91) caches the global debt and the debt of each synth in the system.
-// Debt is denominated by the synth supply multiplied by its current exchange rate.
-//
-// The cache can be invalidated when an exchange rate changes, and thereafter must be
-// updated by performing a debt snapshot, which recomputes the global debt sum using
-// current synth supplies and exchange rates. This is performed usually by a snapshot keeper.
-//
-// Some synths are backed by non-SNX collateral, such as sETH being backed by ETH
-// held in the EtherWrapper (SIP-112). This debt is called "excluded debt" and is
-// excluded from the global debt in `_cachedDebt`.
-//
 // https://docs.synthetix.io/contracts/source/contracts/debtcache
 contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
     using SafeMath for uint;
@@ -55,6 +44,7 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
     bytes32 private constant CONTRACT_SYSTEMSTATUS = "SystemStatus";
     bytes32 private constant CONTRACT_COLLATERALMANAGER = "CollateralManager";
     bytes32 private constant CONTRACT_ETHER_WRAPPER = "EtherWrapper";
+    bytes32 private constant CONTRACT_FUTURESMARKETMANAGER = "FuturesMarketManager";
     bytes32 private constant CONTRACT_WRAPPER_FACTORY = "WrapperFactory";
 
     constructor(address _owner, address _resolver) public Owned(_owner) MixinSystemSettings(_resolver) {}
@@ -63,14 +53,15 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
 
     function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {
         bytes32[] memory existingAddresses = MixinSystemSettings.resolverAddressesRequired();
-        bytes32[] memory newAddresses = new bytes32[](7);
+        bytes32[] memory newAddresses = new bytes32[](8);
         newAddresses[0] = CONTRACT_ISSUER;
         newAddresses[1] = CONTRACT_EXCHANGER;
         newAddresses[2] = CONTRACT_EXRATES;
         newAddresses[3] = CONTRACT_SYSTEMSTATUS;
         newAddresses[4] = CONTRACT_COLLATERALMANAGER;
         newAddresses[5] = CONTRACT_WRAPPER_FACTORY;
         newAddresses[6] = CONTRACT_ETHER_WRAPPER;
+        newAddresses[7] = CONTRACT_FUTURESMARKETMANAGER;
         addresses = combineArrays(existingAddresses, newAddresses);
     }
 
@@ -98,6 +89,10 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
         return IEtherWrapper(requireAndGetAddress(CONTRACT_ETHER_WRAPPER));
     }
 
+    function futuresMarketManager() internal view returns (IFuturesMarketManager) {
+        return IFuturesMarketManager(requireAndGetAddress(CONTRACT_FUTURESMARKETMANAGER));
+    }
+
     function wrapperFactory() internal view returns (IWrapperFactory) {
         return IWrapperFactory(requireAndGetAddress(CONTRACT_WRAPPER_FACTORY));
     }
@@ -157,22 +152,25 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
         view
         returns (
             uint[] memory snxIssuedDebts,
+            uint _futuresDebt,
             uint _excludedDebt,
             bool anyRateIsInvalid
         )
     {
         (uint[] memory rates, bool isInvalid) = exchangeRates().ratesAndInvalidForCurrencies(currencyKeys);
         uint[] memory values = _issuedSynthValues(currencyKeys, rates);
         (uint excludedDebt, bool isAnyNonSnxDebtRateInvalid) = _totalNonSnxBackedDebt(currencyKeys, rates, isInvalid);
+        (uint futuresDebt, bool futuresDebtIsInvalid) = futuresMarketManager().totalDebt();
 
-        return (values, excludedDebt, isAnyNonSnxDebtRateInvalid);
+        return (values, futuresDebt, excludedDebt, isInvalid || futuresDebtIsInvalid || isAnyNonSnxDebtRateInvalid);
     }
 
     function currentSynthDebts(bytes32[] calldata currencyKeys)
         external
         view
         returns (
             uint[] memory debtValues,
+            uint futuresDebt,
             uint excludedDebt,
             bool anyRateIsInvalid
         )
@@ -252,9 +250,15 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
         for (uint i; i < numValues; i++) {
             total = total.add(values[i]);
         }
+
+        // Add in the debt accounted for by futures
+        (uint futuresDebt, bool futuresDebtIsInvalid) = futuresMarketManager().totalDebt();
+        total = total.add(futuresDebt);
+
+        // Ensure that if the excluded non-SNX debt exceeds SNX-backed debt, no overflow occurs
         total = total < excludedDebt ? 0 : total.sub(excludedDebt);
 
-        return (total, isAnyNonSnxDebtRateInvalid);
+        return (total, isInvalid || futuresDebtIsInvalid || isAnyNonSnxDebtRateInvalid);
     }
 
     function currentDebt() external view returns (uint debt, bool anyRateIsInvalid) {
@@ -294,6 +298,8 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
 
     function recordExcludedDebtChange(bytes32 currencyKey, int256 delta) external {}
 
+    function updateCachedsUSDDebt(int amount) external {}
+
     /* ========== MODIFIERS ========== */
 
     function _requireSystemActiveIfNotOwner() internal view {

contracts/DebtCache.sol

@@ -15,6 +15,7 @@ contract DebtCache is BaseDebtCache {
     constructor(address _owner, address _resolver) public BaseDebtCache(_owner, _resolver) {}
 
     bytes32 internal constant EXCLUDED_DEBT_KEY = "EXCLUDED_DEBT";
+    bytes32 internal constant FUTURES_DEBT_KEY = "FUTURES_DEBT";
 
     /* ========== MUTATIVE FUNCTIONS ========== */
 
@@ -26,15 +27,19 @@ contract DebtCache is BaseDebtCache {
 
     function takeDebtSnapshot() external requireSystemActiveIfNotOwner {
         bytes32[] memory currencyKeys = issuer().availableCurrencyKeys();
-        (uint[] memory values, uint excludedDebt, bool isInvalid) = _currentSynthDebts(currencyKeys);
+        (uint[] memory values, uint futuresDebt, uint excludedDebt, bool isInvalid) = _currentSynthDebts(currencyKeys);
 
+        // The total SNX-backed debt is the debt of futures markets plus the debt of circulating synths.
+        uint snxCollateralDebt = futuresDebt;
+        _cachedSynthDebt[FUTURES_DEBT_KEY] = futuresDebt;
         uint numValues = values.length;
-        uint snxCollateralDebt;
         for (uint i; i < numValues; i++) {
             uint value = values[i];
             snxCollateralDebt = snxCollateralDebt.add(value);
             _cachedSynthDebt[currencyKeys[i]] = value;
         }
+
+        // Subtract out the excluded non-SNX backed debt from our total
         _cachedSynthDebt[EXCLUDED_DEBT_KEY] = excludedDebt;
         uint newDebt = snxCollateralDebt.floorsub(excludedDebt);
         _cachedDebt = newDebt;

contracts/EmptyFuturesMarketManager.sol

@@ -0,0 +1,39 @@
+pragma solidity ^0.5.16;
+
+// Empty contract for ether collateral placeholder for OVM
+// https://docs.synthetix.io/contracts/source/contracts/emptyethercollateral
+
+import "./interfaces/IFuturesMarketManager.sol";
+
+contract EmptyFuturesMarketManager is IFuturesMarketManager {
+    function markets(uint index, uint pageSize) external view returns (address[] memory) {
+        index;
+        pageSize;
+        address[] memory _markets;
+        return _markets;
+    }
+
+    function numMarkets() external view returns (uint) {
+        return 0;
+    }
+
+    function allMarkets() external view returns (address[] memory) {
+        address[] memory _markets;
+        return _markets;
+    }
+
+    function marketForKey(bytes32 marketKey) external view returns (address) {
+        marketKey;
+        return address(0);
+    }
+
+    function marketsForKeys(bytes32[] calldata marketKeys) external view returns (address[] memory) {
+        marketKeys;
+        address[] memory _markets;
+        return _markets;
+    }
+
+    function totalDebt() external view returns (uint debt, bool isInvalid) {
+        return (0, false);
+    }
+}

contracts/ExchangeCircuitBreaker.sol

@@ -0,0 +1,209 @@
+pragma solidity ^0.5.16;
+
+// Inheritance
+import "./Owned.sol";
+import "./MixinResolver.sol";
+import "./MixinSystemSettings.sol";
+import "./interfaces/IExchangeCircuitBreaker.sol";
+
+// Libraries
+import "./SafeDecimalMath.sol";
+
+// Internal references
+import "./interfaces/ISynth.sol";
+import "./interfaces/IIssuer.sol";
+import "./interfaces/ISystemStatus.sol";
+import "./interfaces/IExchangeRates.sol";
+import "./Proxyable.sol";
+
+/**
+ * Compares current exchange rate to previous, and suspends a synth if the
+ * difference is outside of deviation bounds.
+ * Stores last "good" rate for each synth on each invocation.
+ * Inteded use is to use in combination with ExchangeRates on mutative exchange-like
+ * methods.
+ * Suspend functionality is public, resume functionality is controlled by owner.
+ *
+ * https://docs.synthetix.io/contracts/source/contracts/ExchangeCircuitBreaker
+ */
+contract ExchangeCircuitBreaker is Owned, MixinSystemSettings, IExchangeCircuitBreaker {
+    using SafeMath for uint;
+    using SafeDecimalMath for uint;
+
+    bytes32 public constant CONTRACT_NAME = "ExchangeCircuitBreaker";
+
+    // SIP-65: Decentralized circuit breaker
+    uint public constant CIRCUIT_BREAKER_SUSPENSION_REASON = 65;
+
+    // is internal to have lastExchangeRate getter in interface in solidity v0.5
+    // TODO: after upgrading solidity, switch to just public lastExchangeRate instead
+    //  of maintaining this internal one
+    mapping(bytes32 => uint) internal _lastExchangeRate;
+
+    /* ========== ADDRESS RESOLVER CONFIGURATION ========== */
+
+    bytes32 private constant CONTRACT_SYSTEMSTATUS = "SystemStatus";
+    bytes32 private constant CONTRACT_EXRATES = "ExchangeRates";
+    bytes32 private constant CONTRACT_ISSUER = "Issuer";
+
+    constructor(address _owner, address _resolver) public Owned(_owner) MixinSystemSettings(_resolver) {}
+
+    /* ========== VIEWS ========== */
+
+    function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {
+        bytes32[] memory existingAddresses = MixinSystemSettings.resolverAddressesRequired();
+        bytes32[] memory newAddresses = new bytes32[](3);
+        newAddresses[0] = CONTRACT_SYSTEMSTATUS;
+        newAddresses[1] = CONTRACT_EXRATES;
+        newAddresses[2] = CONTRACT_ISSUER;
+        addresses = combineArrays(existingAddresses, newAddresses);
+    }
+
+    // Returns rate and its "invalid" state.
+    // Rate can be invalid either due to:
+    //  1. Returned as invalid from ExchangeRates - due to being stale, or flagged by oracle.
+    //  2, Out of deviation dounds w.r.t. to previously stored rate or if there is no
+    //  valid stored rate, w.r.t. to previous 3 oracle rates.
+    function rateWithInvalid(bytes32 currencyKey) external view returns (uint, bool) {
+        (uint rate, bool invalid) = _exchangeRates().rateAndInvalid(currencyKey);
+        return (rate, invalid || _isRateOutOfBounds(currencyKey, rate));
+    }
+
+    function isDeviationAboveThreshold(uint base, uint comparison) external view returns (bool) {
+        return _isDeviationAboveThreshold(base, comparison);
+    }
+
+    function priceDeviationThresholdFactor() external view returns (uint) {
+        return getPriceDeviationThresholdFactor();
+    }
+
+    function lastExchangeRate(bytes32 currencyKey) external view returns (uint) {
+        return _lastExchangeRate[currencyKey];
+    }
+
+    function exchangeRates() public view returns (address) {
+        return requireAndGetAddress(CONTRACT_EXRATES);
+    }
+
+    /* ========== Internal views ========== */
+    function _exchangeRates() internal view returns (IExchangeRates) {
+        return IExchangeRates(requireAndGetAddress(CONTRACT_EXRATES));
+    }
+
+    function systemStatus() internal view returns (ISystemStatus) {
+        return ISystemStatus(requireAndGetAddress(CONTRACT_SYSTEMSTATUS));
+    }
+
+    function issuer() internal view returns (IIssuer) {
+        return IIssuer(requireAndGetAddress(CONTRACT_ISSUER));
+    }
+
+    /* ========== Mutating ========== */
+
+    /**
+     * Checks rate deviation from previous and its "invalid" oracle state (stale rate, of flagged by oracle).
+     * if it's valid and within deviation bounds, stores it and returns it and "false" (circuit not broken).
+     * If rate is invalid or outside of deviation bounds - doesn't store it, suspends the the synth, and returns
+     * last rate and "true" (circuit broken).
+     * Also, checks that system is not suspended currently, if it is - doesn't perform any checks, and
+     * returns last rate and "false" (not broken), to prevent synths suspensions during maintenance.
+     */
+    function rateWithBreakCircuit(bytes32 currencyKey) external returns (uint lastValidRate, bool circuitBroken) {
+        // check system status
+        if (systemStatus().systemSuspended()) {
+            // if system is inactive this call has no effect, but will neither revert,
+            // nor persist new rate, nor suspend the synth - because the system is inactive.
+            // not reverting is needed for performing admin operations during system suspension
+            // e.g. purging synths that use some exchanging functionality
+        } else {
+            // get new rate and check oracle "invalid" state
+            (uint rate, bool invalid) = _exchangeRates().rateAndInvalid(currencyKey);
+            // check and suspend
+            if (invalid || _isRateOutOfBounds(currencyKey, rate)) {
+                // check synth exists, to prevent spamming settings for non existant synths
+                // gas savings: check here instead of every call, because synth existance is only
+                //  important if we want to suspend it, and most regular calls don't need to incur
+                //  the extra gas costs of another external call
+                require(issuer().synths(currencyKey) != ISynth(0), "No such synth");
+                systemStatus().suspendSynth(currencyKey, CIRCUIT_BREAKER_SUSPENSION_REASON);
+                circuitBroken = true;
+            } else {
+                // store the last passing rate
+                _lastExchangeRate[currencyKey] = rate;
+            }
+        }
+        return (_lastExchangeRate[currencyKey], circuitBroken);
+    }
+
+    /**
+     * SIP-139
+     * resets the stored value for _lastExchangeRate for multiple currencies to the latest rate
+     * can be used to un-suspend synths after a suspension happenned
+     * doesn't check deviations here, so believes that owner knows better
+     * emits LastRateOverriden
+     */
+    function resetLastExchangeRate(bytes32[] calldata currencyKeys) external onlyOwner {
+        (uint[] memory rates, bool anyRateInvalid) = _exchangeRates().ratesAndInvalidForCurrencies(currencyKeys);
+
+        require(!anyRateInvalid, "Rates for given synths not valid");
+
+        for (uint i = 0; i < currencyKeys.length; i++) {
+            emit LastRateOverriden(currencyKeys[i], _lastExchangeRate[currencyKeys[i]], rates[i]);
+            _lastExchangeRate[currencyKeys[i]] = rates[i];
+        }
+    }
+
+    /* ========== INTERNAL FUNCTIONS ========== */
+
+    function _isDeviationAboveThreshold(uint base, uint comparison) internal view returns (bool) {
+        if (base == 0 || comparison == 0) {
+            return true;
+        }
+
+        uint factor;
+        if (comparison > base) {
+            factor = comparison.divideDecimal(base);
+        } else {
+            factor = base.divideDecimal(comparison);
+        }
+
+        return factor >= getPriceDeviationThresholdFactor();
+    }
+
+    /**
+     * Rate is invalid if:
+     * - is outside of deviation bounds relative to previous non-zero rate
+     * - (warm up case) if previous rate was 0 (init), gets last 4 rates from oracle, and checks
+     * if rate is outside of deviation w.r.t any of the 3 previous ones (excluding the last one).
+     */
+    function _isRateOutOfBounds(bytes32 currencyKey, uint currentRate) internal view returns (bool) {
+        if (currentRate == 0) {
+            return true;
+        }
+
+        uint lastRateFromExchange = _lastExchangeRate[currencyKey];
+
+        if (lastRateFromExchange > 0) {
+            return _isDeviationAboveThreshold(lastRateFromExchange, currentRate);
+        }
+
+        // if no last exchange for this synth, then we need to look up last 3 rates (+1 for current rate)
+        (uint[] memory rates, ) = _exchangeRates().ratesAndUpdatedTimeForCurrencyLastNRounds(currencyKey, 4, 0);
+
+        // start at index 1 to ignore current rate
+        for (uint i = 1; i < rates.length; i++) {
+            // ignore any empty rates in the past (otherwise we will never be able to get validity)
+            if (rates[i] > 0 && _isDeviationAboveThreshold(rates[i], currentRate)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    // ========== EVENTS ==========
+
+    // @notice signals that a the "last rate" was overriden by one of the admin methods
+    //   with a value that didn't come direclty from the ExchangeRates.getRates methods
+    event LastRateOverriden(bytes32 currencyKey, uint256 previousRate, uint256 newRate);
+}

contracts/ExchangeRates.sol

@@ -14,7 +14,7 @@ import "./SafeDecimalMath.sol";
 import "@chainlink/contracts-0.0.10/src/v0.5/interfaces/AggregatorV2V3Interface.sol";
 // FlagsInterface from Chainlink addresses SIP-76
 import "@chainlink/contracts-0.0.10/src/v0.5/interfaces/FlagsInterface.sol";
-import "./interfaces/IExchanger.sol";
+import "./interfaces/IExchangeCircuitBreaker.sol";
 
 // https://docs.synthetix.io/contracts/source/contracts/exchangerates
 contract ExchangeRates is Owned, MixinSystemSettings, IExchangeRates {