Diphda release 2.64

.env.example

@@ -1,4 +1,5 @@
 ETHERSCAN_KEY=SomeEtherscanKey
+OVM_ETHERSCAN_KEY=SomeEtherscanKey
 PROVIDER_URL=https://network.infura.io/v3/SomeInfuraKey (runtime replaces "network")
 PROVIDER_URL_MAINNET=https://mainnet.infura.io/v3/SomeInfuraKey
 DEPLOY_PRIVATE_KEY=SomeEthereumPrivateKey (including 0x prefix)

.github/workflows/codeql-analysis.yml

@@ -29,6 +29,6 @@ jobs:
       - name: Run slither
         run: slither . --sarif slither.sarif || true
       - name: Upload SARIF file
-        uses: github/codeql-action/upload-sarif@v1
+        uses: github/codeql-action/upload-sarif@117a67b0743599d091109168df5eb673f1641f6b # pin@codeql-bundle-20220224
         with:
           sarif_file: "slither.sarif"

.github/workflows/codeql.yml

@@ -21,13 +21,13 @@ jobs:
         uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f # pin@v2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@7112cdaa06f3b661965fe3e2e93c9acaadbe85f3 # pin@codeql-bundle-20210921
+        uses: github/codeql-action/init@117a67b0743599d091109168df5eb673f1641f6b # pin@codeql-bundle-20220224
         with:
           queries: security-and-quality
           languages: javascript
 
       - name: Autobuild
-        uses: github/codeql-action/autobuild@7112cdaa06f3b661965fe3e2e93c9acaadbe85f3 # pin@codeql-bundle-20210921
+        uses: github/codeql-action/autobuild@117a67b0743599d091109168df5eb673f1641f6b # pin@codeql-bundle-20220224
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@7112cdaa06f3b661965fe3e2e93c9acaadbe85f3 # pin@codeql-bundle-20210921
+        uses: github/codeql-action/analyze@117a67b0743599d091109168df5eb673f1641f6b # pin@codeql-bundle-20220224

.github/workflows/slither-analysis.yml

@@ -45,7 +45,7 @@ jobs:
 
       - name: Upload lint results
         if: always()
-        uses: github/codeql-action/upload-sarif@7112cdaa06f3b661965fe3e2e93c9acaadbe85f3 # pin@codeql-bundle-20210921
+        uses: github/codeql-action/upload-sarif@117a67b0743599d091109168df5eb673f1641f6b # pin@codeql-bundle-20220224
         with:
           sarif_file: slither.sarif
         continue-on-error: true

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;
@@ -42,6 +31,9 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
     uint internal _cacheTimestamp;
     bool internal _cacheInvalid = true;
 
+    // flag to ensure importing excluded debt is invoked only once
+    bool public isInitialized = false; // public to avoid needing an event
+
     /* ========== ENCODED NAMES ========== */
 
     bytes32 internal constant sUSD = "sUSD";
@@ -55,6 +47,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 +56,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 +92,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 +155,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
         )
@@ -206,6 +207,40 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
         return _excludedIssuedDebts(currencyKeys);
     }
 
+    /// used when migrating to new DebtCache instance in order to import the excluded debt records
+    /// If this method is not run after upgrading the contract, the debt will be
+    /// incorrect w.r.t to wrapper factory assets until the values are imported from
+    /// previous instance of the contract
+    /// Also, in addition to this method it's possible to use recordExcludedDebtChange since
+    /// it's accessible to owner in case additional adjustments are required
+    function importExcludedIssuedDebts(IDebtCache prevDebtCache, IIssuer prevIssuer) external onlyOwner {
+        // this can only be run once so that recorded debt deltas aren't accidentally
+        // lost or double counted
+        require(!isInitialized, "already initialized");
+        isInitialized = true;
+
+        // get the currency keys from **previous** issuer, in case current issuer
+        // doesn't have all the synths at this point
+        // warning: if a synth won't be added to the current issuer before the next upgrade of this contract,
+        // its entry will be lost (because it won't be in the prevIssuer for next time).
+        // if for some reason this is a problem, it should be possible to use recordExcludedDebtChange() to amend
+        bytes32[] memory keys = prevIssuer.availableCurrencyKeys();
+
+        require(keys.length > 0, "previous Issuer has no synths");
+
+        // query for previous debt records
+        uint[] memory debts = prevDebtCache.excludedIssuedDebts(keys);
+
+        // store the values
+        for (uint i = 0; i < keys.length; i++) {
+            if (debts[i] > 0) {
+                // adding the values instead of overwriting in case some deltas were recorded in this
+                // contract already (e.g. if the upgrade was not atomic)
+                _excludedIssuedDebt[keys[i]] = _excludedIssuedDebt[keys[i]].add(debts[i]);
+            }
+        }
+    }
+
     // Returns the total sUSD debt backed by non-SNX collateral.
     function totalNonSnxBackedDebt() external view returns (uint excludedDebt, bool isInvalid) {
         bytes32[] memory currencyKeys = issuer().availableCurrencyKeys();
@@ -252,9 +287,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 +335,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/BaseSingleNetworkAggregator.sol

@@ -0,0 +1,73 @@
+pragma solidity ^0.5.16;
+
+//import "@chainlink/contracts-0.0.10/src/v0.5/interfaces/AggregatorV2V3Interface.sol";
+
+import "./AddressResolver.sol";
+import "./interfaces/IDebtCache.sol";
+import "./interfaces/ISynthetixDebtShare.sol";
+import "./interfaces/AggregatorV2V3Interface.sol";
+
+import "./SafeDecimalMath.sol";
+
+// aggregator which reports the data from the system itself
+// useful for testing
+contract BaseSingleNetworkAggregator is Owned, AggregatorV2V3Interface {
+    using SafeDecimalMath for uint;
+
+    AddressResolver public resolver;
+
+    uint public overrideTimestamp;
+
+    constructor(AddressResolver _resolver) public Owned(msg.sender) {
+        resolver = _resolver;
+    }
+
+    function setOverrideTimestamp(uint timestamp) public onlyOwner {
+        overrideTimestamp = timestamp;
+
+        emit SetOverrideTimestamp(timestamp);
+    }
+
+    function latestRoundData()
+        external
+        view
+        returns (
+            uint80,
+            int256,
+            uint256,
+            uint256,
+            uint80
+        )
+    {
+        return getRoundData(uint80(latestRound()));
+    }
+
+    function latestRound() public view returns (uint256) {
+        return 1;
+    }
+
+    function decimals() external view returns (uint8) {
+        return 0;
+    }
+
+    function getAnswer(uint256 _roundId) external view returns (int256 answer) {
+        (,answer,,,) = getRoundData(uint80(_roundId));
+    }
+
+    function getTimestamp(uint256 _roundId) external view returns (uint256 timestamp) {
+        (,,timestamp,,) = getRoundData(uint80(_roundId));
+    }
+
+    function getRoundData(uint80)
+        public
+        view
+        returns (
+            uint80,
+            int256,
+            uint256,
+            uint256,
+            uint80
+        );
+
+    event SetOverrideTimestamp(uint timestamp);
+}

contracts/BaseSynthetixBridge.sol

@@ -10,13 +10,15 @@ import "./interfaces/IBaseSynthetixBridge.sol";
 // Internal references
 import "./interfaces/ISynthetix.sol";
 import "./interfaces/IRewardEscrowV2.sol";
+import "./interfaces/IFeePool.sol";
 import "@eth-optimism/contracts/iOVM/bridge/messaging/iAbs_BaseCrossDomainMessenger.sol";
 
 contract BaseSynthetixBridge is Owned, MixinSystemSettings, IBaseSynthetixBridge {
     /* ========== ADDRESS RESOLVER CONFIGURATION ========== */
     bytes32 private constant CONTRACT_EXT_MESSENGER = "ext:Messenger";
     bytes32 internal constant CONTRACT_SYNTHETIX = "Synthetix";
     bytes32 private constant CONTRACT_REWARDESCROW = "RewardEscrowV2";
+    bytes32 private constant CONTRACT_FEEPOOL = "FeePool";
 
     bool public initiationActive;
 
@@ -40,6 +42,10 @@ contract BaseSynthetixBridge is Owned, MixinSystemSettings, IBaseSynthetixBridge
         return IRewardEscrowV2(requireAndGetAddress(CONTRACT_REWARDESCROW));
     }
 
+    function feePool() internal view returns (IFeePool) {
+        return IFeePool(requireAndGetAddress(CONTRACT_FEEPOOL));
+    }
+
     function initiatingActive() internal view {
         require(initiationActive, "Initiation deactivated");
     }
@@ -48,10 +54,11 @@ contract BaseSynthetixBridge is Owned, MixinSystemSettings, IBaseSynthetixBridge
 
     function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {
         bytes32[] memory existingAddresses = MixinSystemSettings.resolverAddressesRequired();
-        bytes32[] memory newAddresses = new bytes32[](3);
+        bytes32[] memory newAddresses = new bytes32[](4);
         newAddresses[0] = CONTRACT_EXT_MESSENGER;
         newAddresses[1] = CONTRACT_SYNTHETIX;
         newAddresses[2] = CONTRACT_REWARDESCROW;
+        newAddresses[3] = CONTRACT_FEEPOOL;
         addresses = combineArrays(existingAddresses, newAddresses);
     }
 

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);
+    }
+}