Euler diff: contracts/modules/RiskManager.sol

Before: contract 0xad8a5c16FDF36E568F602d088dD0C0ADe52dd652

After: git 1d8c9f1d548570a0235cda39b13a76e658ae37d3

@@ -261,42 +261,57 @@
         AssetCache memory assetCache;
         for (uint i = 0; i < underlyings.length; ++i) {
             address underlying = underlyings[i];
-            bool assetCacheAndPriceInited = false;
-            uint price;
             config = resolveAssetConfig(underlying);
             assetStorage = eTokenLookup[config.eTokenAddress];
             uint balance = assetStorage.users[account].balance;
             uint owed = assetStorage.users[account].owed;
-            if (balance != 0 && config.collateralFactor != 0) {
+            if (owed != 0) {
                 initAssetCache(underlying, assetStorage, assetCache);
-                (price,) = getPriceInternal(assetCache, config);
-                assetCacheAndPriceInited = true;
+                (uint price,) = getPriceInternal(assetCache, config);
-                uint assetCollateral = balanceToUnderlyingAmount(assetCache, balance);
-                assetCollateral = assetCollateral * price / 1e18;
-                assetCollateral = assetCollateral * config.collateralFactor / CONFIG_FACTOR_SCALE;
-                status.collateralValue += assetCollateral;
-            }
-            if (owed != 0) {
-                if (!assetCacheAndPriceInited) {
-                    initAssetCache(underlying, assetStorage, assetCache);
-                    (price,) = getPriceInternal(assetCache, config);
-                    assetCacheAndPriceInited = true;
-                }
                 status.numBorrows++;
                 if (config.borrowIsolated) status.borrowIsolated = true;
                 uint assetLiability = getCurrentOwed(assetStorage, assetCache, account);
+                if (balance != 0) { // self-collateralisation
+                    uint balanceInUnderlying = balanceToUnderlyingAmount(assetCache, balance);
+                    uint selfAmount = assetLiability;
+                    uint selfAmountAdjusted = assetLiability * CONFIG_FACTOR_SCALE / SELF_COLLATERAL_FACTOR;
+                    if (selfAmountAdjusted > balanceInUnderlying) {
+                        selfAmount = balanceInUnderlying * SELF_COLLATERAL_FACTOR / CONFIG_FACTOR_SCALE;
+                        selfAmountAdjusted = balanceInUnderlying;
+                    }
+                    {
+                        uint assetCollateral = (balanceInUnderlying - selfAmountAdjusted) * config.collateralFactor / CONFIG_FACTOR_SCALE;
+                        assetCollateral += selfAmount;
+                        status.collateralValue += assetCollateral * price / 1e18;
+                    }
+                    assetLiability -= selfAmount;
+                    status.liabilityValue += selfAmount * price / 1e18;
+                    status.borrowIsolated = true; // self-collateralised loans are always isolated
+                }
                 assetLiability = assetLiability * price / 1e18;
                 assetLiability = config.borrowFactor != 0 ? assetLiability * CONFIG_FACTOR_SCALE / config.borrowFactor : MAX_SANE_DEBT_AMOUNT;
                 status.liabilityValue += assetLiability;
+            } else if (balance != 0 && config.collateralFactor != 0) {
+                initAssetCache(underlying, assetStorage, assetCache);
+                (uint price,) = getPriceInternal(assetCache, config);
+                uint balanceInUnderlying = balanceToUnderlyingAmount(assetCache, balance);
+                uint assetCollateral = balanceInUnderlying * price / 1e18;
+                assetCollateral = assetCollateral * config.collateralFactor / CONFIG_FACTOR_SCALE;
+                status.collateralValue += assetCollateral;
             }
         }
     }

contracts/Interfaces.sol CHANGED Viewed

@@ -20,10 +20,10 @@
 }
 interface IERC20Permit {
     function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
-    function nonces(address owner) external view returns (uint);
-    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external;
+    function permit(address owner, address spender, uint value, uint deadline, bytes calldata signature) external;
 }
 interface IERC3156FlashBorrower {
     function onFlashLoan(address initiator, address token, uint256 amount, uint256 fee, bytes calldata data) external returns (bytes32);

contracts/Base.sol CHANGED Viewed

@@ -52,8 +52,15 @@
     modifier reentrantOK() { // documentation only
         _;
     }
+    // Used to flag functions which do not modify storage, but do perform a delegate call
+    // to a view function, which prohibits a standard view modifier. The flag is used to
+    // patch state mutability in compiled ABIs and interfaces.
+    modifier staticDelegate() {
+        _;
+    }
     // WARNING: Must be very careful with this modifier. It resets the free memory pointer
     // to the value it was when the function started. This saves gas if more memory will
     // be allocated in the future. However, if the memory will be later referenced
     // (for example because the function has returned a pointer to it) then you cannot

contracts/Constants.sol CHANGED Viewed

@@ -23,8 +23,9 @@
     uint internal constant AVERAGE_LIQUIDITY_PERIOD = 24 * 60 * 60;
     uint16 internal constant MIN_UNISWAP3_OBSERVATION_CARDINALITY = 144;
     uint24 internal constant DEFAULT_TWAP_WINDOW_SECONDS = 30 * 60;
     uint32 internal constant DEFAULT_BORROW_FACTOR = uint32(0.28 * 4_000_000_000);
+    uint32 internal constant SELF_COLLATERAL_FACTOR = uint32(0.95 * 4_000_000_000);
     // Implementation internals
@@ -74,8 +75,9 @@
     //   Classes
     uint internal constant MODULEID__IRM_CLASS__STABLE = 2_000_500;
     uint internal constant MODULEID__IRM_CLASS__MAJOR = 2_000_501;
     uint internal constant MODULEID__IRM_CLASS__MIDCAP = 2_000_502;
+    uint internal constant MODULEID__IRM_CLASS__MEGA = 2_000_503;
     // Swap types
     uint internal constant SWAP_TYPE__UNI_EXACT_INPUT_SINGLE = 1;
     uint internal constant SWAP_TYPE__UNI_EXACT_INPUT = 2;