SIP-182 Wrapper Factory

contracts/BaseDebtCache.sol

@@ -17,6 +17,7 @@ import "./interfaces/ISystemStatus.sol";
 import "./interfaces/IERC20.sol";
 import "./interfaces/ICollateralManager.sol";
 import "./interfaces/IEtherWrapper.sol";
+import "./interfaces/IWrapperFactory.sol";
 
 //
 // The debt cache (SIP-91) caches the global debt and the debt of each synth in the system.
@@ -37,6 +38,7 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
 
     uint internal _cachedDebt;
     mapping(bytes32 => uint) internal _cachedSynthDebt;
+    mapping(bytes32 => uint) internal _excludedIssuedDebt;
     uint internal _cacheTimestamp;
     bool internal _cacheInvalid = true;
 
@@ -53,20 +55,22 @@ 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_WRAPPER_FACTORY = "WrapperFactory";
 
     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[](6);
+        bytes32[] memory newAddresses = new bytes32[](7);
         newAddresses[0] = CONTRACT_ISSUER;
         newAddresses[1] = CONTRACT_EXCHANGER;
         newAddresses[2] = CONTRACT_EXRATES;
         newAddresses[3] = CONTRACT_SYSTEMSTATUS;
         newAddresses[4] = CONTRACT_COLLATERALMANAGER;
-        newAddresses[5] = CONTRACT_ETHER_WRAPPER;
+        newAddresses[5] = CONTRACT_WRAPPER_FACTORY;
+        newAddresses[6] = CONTRACT_ETHER_WRAPPER;
         addresses = combineArrays(existingAddresses, newAddresses);
     }
 
@@ -94,6 +98,10 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
         return IEtherWrapper(requireAndGetAddress(CONTRACT_ETHER_WRAPPER));
     }
 
+    function wrapperFactory() internal view returns (IWrapperFactory) {
+        return IWrapperFactory(requireAndGetAddress(CONTRACT_WRAPPER_FACTORY));
+    }
+
     function debtSnapshotStaleTime() external view returns (uint) {
         return getDebtSnapshotStaleTime();
     }
@@ -125,7 +133,6 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
         return _cacheStale(_cacheTimestamp);
     }
 
-    // Returns the USD-denominated supply of each synth in `currencyKeys`, according to `rates`.
     function _issuedSynthValues(bytes32[] memory currencyKeys, uint[] memory rates)
         internal
         view
@@ -156,11 +163,11 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
     {
         (uint[] memory rates, bool isInvalid) = exchangeRates().ratesAndInvalidForCurrencies(currencyKeys);
         uint[] memory values = _issuedSynthValues(currencyKeys, rates);
-        (uint excludedDebt, bool isAnyNonSnxDebtRateInvalid) = _totalNonSnxBackedDebt();
-        return (values, excludedDebt, isInvalid || isAnyNonSnxDebtRateInvalid);
+        (uint excludedDebt, bool isAnyNonSnxDebtRateInvalid) = _totalNonSnxBackedDebt(currencyKeys, rates, isInvalid);
+
+        return (values, excludedDebt, isAnyNonSnxDebtRateInvalid);
     }
 
-    // Returns the USD-denominated supply of each synth in `currencyKeys`, using current exchange rates.
     function currentSynthDebts(bytes32[] calldata currencyKeys)
         external
         view
@@ -186,24 +193,44 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
         return _cachedSynthDebts(currencyKeys);
     }
 
-    function _totalNonSnxBackedDebt() internal view returns (uint excludedDebt, bool isInvalid) {
+    function _excludedIssuedDebts(bytes32[] memory currencyKeys) internal view returns (uint[] memory) {
+        uint numKeys = currencyKeys.length;
+        uint[] memory debts = new uint[](numKeys);
+        for (uint i = 0; i < numKeys; i++) {
+            debts[i] = _excludedIssuedDebt[currencyKeys[i]];
+        }
+        return debts;
+    }
+
+    function excludedIssuedDebts(bytes32[] calldata currencyKeys) external view returns (uint[] memory excludedDebts) {
+        return _excludedIssuedDebts(currencyKeys);
+    }
+
+    // Returns the total sUSD debt backed by non-SNX collateral, excluding debts recorded with _excludedIssuedDebt
+    function totalNonSnxBackedDebt() external view returns (uint excludedDebt, bool isInvalid) {
+        bytes32[] memory currencyKeys = issuer().availableCurrencyKeys();
+        (uint[] memory rates, bool ratesAreInvalid) = exchangeRates().ratesAndInvalidForCurrencies(currencyKeys);
+
+        return _totalNonSnxBackedDebt(currencyKeys, rates, ratesAreInvalid);
+    }
+
+    function _totalNonSnxBackedDebt(bytes32[] memory currencyKeys, uint[] memory rates, bool ratesAreInvalid) internal view returns (uint excludedDebt, bool isInvalid) {
         // Calculate excluded debt.
         // 1. MultiCollateral long debt + short debt.
         (uint longValue, bool anyTotalLongRateIsInvalid) = collateralManager().totalLong();
         (uint shortValue, bool anyTotalShortRateIsInvalid) = collateralManager().totalShort();
-        isInvalid = anyTotalLongRateIsInvalid || anyTotalShortRateIsInvalid;
+        isInvalid = ratesAreInvalid || anyTotalLongRateIsInvalid || anyTotalShortRateIsInvalid;
         excludedDebt = longValue.add(shortValue);
 
         // 2. EtherWrapper.
         // Subtract sETH and sUSD issued by EtherWrapper.
         excludedDebt = excludedDebt.add(etherWrapper().totalIssuedSynths());
 
-        return (excludedDebt, isInvalid);
-    }
+        for (uint i = 0; i < currencyKeys.length; i++) {
+            excludedDebt = excludedDebt.add(_excludedIssuedDebt[currencyKeys[i]].multiplyDecimalRound(rates[i]));
+        }
 
-    // Returns the total sUSD debt backed by non-SNX collateral.
-    function totalNonSnxBackedDebt() external view returns (uint excludedDebt, bool isInvalid) {
-        return _totalNonSnxBackedDebt();
+        return (excludedDebt, isInvalid);
     }
 
     function _currentDebt() internal view returns (uint debt, bool anyRateIsInvalid) {
@@ -212,7 +239,7 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
 
         // Sum all issued synth values based on their supply.
         uint[] memory values = _issuedSynthValues(currencyKeys, rates);
-        (uint excludedDebt, bool isAnyNonSnxDebtRateInvalid) = _totalNonSnxBackedDebt();
+        (uint excludedDebt, bool isAnyNonSnxDebtRateInvalid) = _totalNonSnxBackedDebt(currencyKeys, rates, isInvalid);
 
         uint numValues = values.length;
         uint total;
@@ -221,10 +248,9 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
         }
         total = total < excludedDebt ? 0 : total.sub(excludedDebt);
 
-        return (total, isInvalid || isAnyNonSnxDebtRateInvalid);
+        return (total, isAnyNonSnxDebtRateInvalid);
     }
 
-    // Returns the current debt of the system, excluding non-SNX backed debt (eg. EtherWrapper).
     function currentDebt() external view returns (uint debt, bool anyRateIsInvalid) {
         return _currentDebt();
     }
@@ -260,6 +286,8 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
 
     function takeDebtSnapshot() external {}
 
+    function recordExcludedDebtChange(bytes32 currencyKey, int256 delta) external {}
+
     /* ========== MODIFIERS ========== */
 
     function _requireSystemActiveIfNotOwner() internal view {
@@ -290,4 +318,18 @@ contract BaseDebtCache is Owned, MixinSystemSettings, IDebtCache {
         _onlyIssuerOrExchanger();
         _;
     }
+
+    function _onlyDebtIssuer() internal view {
+        bool isWrapper = wrapperFactory().isWrapper(msg.sender);
+
+        // owner included for debugging and fixing in emergency situation
+        bool isOwner = msg.sender == owner;
+
+        require(isOwner || isWrapper, "Only debt issuers may call this");
+    }
+
+    modifier onlyDebtIssuer() {
+        _onlyDebtIssuer();
+        _;
+    }
 }

contracts/DebtCache.sol

@@ -70,6 +70,14 @@ contract DebtCache is BaseDebtCache {
         _updateDebtCacheValidity(currentlyInvalid);
     }
 
+    function recordExcludedDebtChange(bytes32 currencyKey, int256 delta) external onlyDebtIssuer {
+        int256 newExcludedDebt = int256(_excludedIssuedDebt[currencyKey]) + delta;
+
+        require(newExcludedDebt >= 0, "Excluded debt cannot become negative");
+
+        _excludedIssuedDebt[currencyKey] = uint(newExcludedDebt);
+    }
+
     function updateCachedsUSDDebt(int amount) external onlyIssuer {
         uint delta = SafeDecimalMath.abs(amount);
         if (amount > 0) {

contracts/FeePool.sol

@@ -26,6 +26,7 @@ import "./interfaces/IDelegateApprovals.sol";
 import "./interfaces/IRewardsDistribution.sol";
 import "./interfaces/ICollateralManager.sol";
 import "./interfaces/IEtherWrapper.sol";
+import "./interfaces/IWrapperFactory.sol";
 
 // https://docs.synthetix.io/contracts/source/contracts/feepool
 contract FeePool is Owned, Proxyable, LimitedSetup, MixinSystemSettings, IFeePool {
@@ -75,6 +76,7 @@ contract FeePool is Owned, Proxyable, LimitedSetup, MixinSystemSettings, IFeePoo
     bytes32 private constant CONTRACT_COLLATERALMANAGER = "CollateralManager";
     bytes32 private constant CONTRACT_REWARDSDISTRIBUTION = "RewardsDistribution";
     bytes32 private constant CONTRACT_ETHER_WRAPPER = "EtherWrapper";
+    bytes32 private constant CONTRACT_WRAPPER_FACTORY = "WrapperFactory";
 
     /* ========== ETERNAL STORAGE CONSTANTS ========== */
 
@@ -93,7 +95,7 @@ contract FeePool is Owned, Proxyable, LimitedSetup, MixinSystemSettings, IFeePoo
     /* ========== VIEWS ========== */
     function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {
         bytes32[] memory existingAddresses = MixinSystemSettings.resolverAddressesRequired();
-        bytes32[] memory newAddresses = new bytes32[](12);
+        bytes32[] memory newAddresses = new bytes32[](13);
         newAddresses[0] = CONTRACT_SYSTEMSTATUS;
         newAddresses[1] = CONTRACT_SYNTHETIX;
         newAddresses[2] = CONTRACT_FEEPOOLSTATE;
@@ -105,7 +107,8 @@ contract FeePool is Owned, Proxyable, LimitedSetup, MixinSystemSettings, IFeePoo
         newAddresses[8] = CONTRACT_DELEGATEAPPROVALS;
         newAddresses[9] = CONTRACT_REWARDSDISTRIBUTION;
         newAddresses[10] = CONTRACT_COLLATERALMANAGER;
-        newAddresses[11] = CONTRACT_ETHER_WRAPPER;
+        newAddresses[11] = CONTRACT_WRAPPER_FACTORY;
+        newAddresses[12] = CONTRACT_ETHER_WRAPPER;
         addresses = combineArrays(existingAddresses, newAddresses);
     }
 
@@ -157,6 +160,10 @@ contract FeePool is Owned, Proxyable, LimitedSetup, MixinSystemSettings, IFeePoo
         return IEtherWrapper(requireAndGetAddress(CONTRACT_ETHER_WRAPPER));
     }
 
+    function wrapperFactory() internal view returns (IWrapperFactory) {
+        return IWrapperFactory(requireAndGetAddress(CONTRACT_WRAPPER_FACTORY));
+    }
+
     function issuanceRatio() external view returns (uint) {
         return getIssuanceRatio();
     }
@@ -250,6 +257,7 @@ contract FeePool is Owned, Proxyable, LimitedSetup, MixinSystemSettings, IFeePoo
         require(_recentFeePeriodsStorage(0).startTime <= (now - getFeePeriodDuration()), "Too early to close fee period");
 
         etherWrapper().distributeFees();
+        wrapperFactory().distributeFees();
 
         // Note:  when FEE_PERIOD_LENGTH = 2, periodClosing is the current period & periodToRollover is the last open claimable period
         FeePeriod storage periodClosing = _recentFeePeriodsStorage(FEE_PERIOD_LENGTH - 2);
@@ -725,8 +733,9 @@ contract FeePool is Owned, Proxyable, LimitedSetup, MixinSystemSettings, IFeePoo
         bool isSynth = issuer().synthsByAddress(msg.sender) != bytes32(0);
         bool isCollateral = collateralManager().hasCollateral(msg.sender);
         bool isEtherWrapper = msg.sender == address(etherWrapper());
+        bool isWrapper = msg.sender == address(wrapperFactory());
 
-        require(isExchanger || isSynth || isCollateral || isEtherWrapper, "Only Internal Contracts");
+        require(isExchanger || isSynth || isCollateral || isEtherWrapper || isWrapper, "Only Internal Contracts");
         _;
     }
 

contracts/MixinSystemSettings.sol

@@ -30,6 +30,9 @@ contract MixinSystemSettings is MixinResolver {
     bytes32 internal constant SETTING_ETHER_WRAPPER_MAX_ETH = "etherWrapperMaxETH";
     bytes32 internal constant SETTING_ETHER_WRAPPER_MINT_FEE_RATE = "etherWrapperMintFeeRate";
     bytes32 internal constant SETTING_ETHER_WRAPPER_BURN_FEE_RATE = "etherWrapperBurnFeeRate";
+    bytes32 internal constant SETTING_WRAPPER_MAX_TOKEN_AMOUNT = "wrapperMaxTokens";
+    bytes32 internal constant SETTING_WRAPPER_MINT_FEE_RATE = "wrapperMintFeeRate";
+    bytes32 internal constant SETTING_WRAPPER_BURN_FEE_RATE = "wrapperBurnFeeRate";
     bytes32 internal constant SETTING_MIN_CRATIO = "minCratio";
     bytes32 internal constant SETTING_NEW_COLLATERAL_MANAGER = "newCollateralManager";
     bytes32 internal constant SETTING_INTERACTION_DELAY = "interactionDelay";
@@ -143,6 +146,30 @@ contract MixinSystemSettings is MixinResolver {
         return flexibleStorage().getUIntValue(SETTING_CONTRACT_NAME, SETTING_ETHER_WRAPPER_BURN_FEE_RATE);
     }
 
+    function getWrapperMaxTokenAmount(address wrapper) internal view returns (uint) {
+        return
+            flexibleStorage().getUIntValue(
+                SETTING_CONTRACT_NAME,
+                keccak256(abi.encodePacked(SETTING_WRAPPER_MAX_TOKEN_AMOUNT, wrapper))
+            );
+    }
+
+    function getWrapperMintFeeRate(address wrapper) internal view returns (int) {
+        return
+            flexibleStorage().getIntValue(
+                SETTING_CONTRACT_NAME,
+                keccak256(abi.encodePacked(SETTING_WRAPPER_MINT_FEE_RATE, wrapper))
+            );
+    }
+
+    function getWrapperBurnFeeRate(address wrapper) internal view returns (int) {
+        return
+            flexibleStorage().getIntValue(
+                SETTING_CONTRACT_NAME,
+                keccak256(abi.encodePacked(SETTING_WRAPPER_BURN_FEE_RATE, wrapper))
+            );
+    }
+
     function getMinCratio(address collateral) internal view returns (uint) {
         return
             flexibleStorage().getUIntValue(

contracts/MultiCollateralSynth.sol

@@ -6,6 +6,7 @@ import "./Synth.sol";
 // Internal references
 import "./interfaces/ICollateralManager.sol";
 import "./interfaces/IEtherWrapper.sol";
+import "./interfaces/IWrapperFactory.sol";
 
 // https://docs.synthetix.io/contracts/source/contracts/multicollateralsynth
 contract MultiCollateralSynth is Synth {
@@ -15,6 +16,7 @@ contract MultiCollateralSynth is Synth {
 
     bytes32 private constant CONTRACT_COLLATERALMANAGER = "CollateralManager";
     bytes32 private constant CONTRACT_ETHER_WRAPPER = "EtherWrapper";
+    bytes32 private constant CONTRACT_WRAPPER_FACTORY = "WrapperFactory";
 
     /* ========== CONSTRUCTOR ========== */
 
@@ -39,11 +41,16 @@ contract MultiCollateralSynth is Synth {
         return IEtherWrapper(requireAndGetAddress(CONTRACT_ETHER_WRAPPER));
     }
 
+    function wrapperFactory() internal view returns (IWrapperFactory) {
+        return IWrapperFactory(requireAndGetAddress(CONTRACT_WRAPPER_FACTORY));
+    }
+
     function resolverAddressesRequired() public view returns (bytes32[] memory addresses) {
         bytes32[] memory existingAddresses = Synth.resolverAddressesRequired();
-        bytes32[] memory newAddresses = new bytes32[](2);
+        bytes32[] memory newAddresses = new bytes32[](3);
         newAddresses[0] = CONTRACT_COLLATERALMANAGER;
         newAddresses[1] = CONTRACT_ETHER_WRAPPER;
+        newAddresses[2] = CONTRACT_WRAPPER_FACTORY;
         addresses = combineArrays(existingAddresses, newAddresses);
     }
 
@@ -69,17 +76,18 @@ contract MultiCollateralSynth is Synth {
 
     /* ========== MODIFIERS ========== */
 
-    // Contracts directly interacting with multiCollateralSynth to issue and burn
+    // Contracts directly interacting with multiCollateralSynth or wrapper to issue and burn
     modifier onlyInternalContracts() {
         bool isFeePool = msg.sender == address(feePool());
         bool isExchanger = msg.sender == address(exchanger());
         bool isIssuer = msg.sender == address(issuer());
         bool isEtherWrapper = msg.sender == address(etherWrapper());
+        bool isWrapper = wrapperFactory().isWrapper(msg.sender);
         bool isMultiCollateral = collateralManager().hasCollateral(msg.sender);
 
         require(
-            isFeePool || isExchanger || isIssuer || isEtherWrapper || isMultiCollateral,
-            "Only FeePool, Exchanger, Issuer, MultiCollateral contracts allowed"
+            isFeePool || isExchanger || isIssuer || isEtherWrapper || isWrapper || isMultiCollateral,
+            "Only FeePool, Exchanger, Issuer, Wrapper, or MultiCollateral contracts allowed"
         );
         _;
     }