Use ERC20 for internal variables, add public getters. Strangely reduc…

…es contract size.

src/policies/cooler/CoolerTreasuryBorrower.sol

@@ -31,22 +31,22 @@ contract CoolerTreasuryBorrower is ICoolerTreasuryBorrower, Policy, RolesConsume
     TRSRYv1 public TRSRY;
 
     /// @notice sUSDS is used within TRSRY to generate yield on idle USDS
-    ERC4626 public immutable susds;
+    ERC4626 public immutable SUSDS;
 
     /// @dev The SKY USDS token
-    ERC20 private immutable _usds;
+    ERC20 private immutable _USDS;
 
     bytes32 public constant COOLER_ROLE = bytes32("treasuryborrower_cooler");
     bytes32 public constant ADMIN_ROLE = bytes32("treasuryborrower_admin");
 
     constructor(address kernel_, address susds_) Policy(Kernel(kernel_)) {
-        susds = ERC4626(susds_);
-        _usds = ERC20(susds.asset());
+        SUSDS = ERC4626(susds_);
+        _USDS = ERC20(SUSDS.asset());
 
         // This particular implemenation can only handle an 18dp debtToken
         // If (for example) USDC were to be used then logic should be added
         // within borrow() and repay() to do the conversions.
-        if (_usds.decimals() != DECIMALS) revert InvalidParam();
+        if (_USDS.decimals() != DECIMALS) revert InvalidParam();
     }
 
     /// @inheritdoc Policy
@@ -84,54 +84,54 @@ contract CoolerTreasuryBorrower is ICoolerTreasuryBorrower, Policy, RolesConsume
         if (amountInWad == 0) revert ExpectedNonZero();
         if (recipient == address(0)) revert InvalidAddress();
 
-        uint256 outstandingDebt = TRSRY.reserveDebt(_usds, address(this));
+        uint256 outstandingDebt = TRSRY.reserveDebt(_USDS, address(this));
         TRSRY.setDebt({
             debtor_: address(this),
-            token_: _usds,
+            token_: _USDS,
             amount_: outstandingDebt + amountInWad
         });
 
         // Since TRSRY holds sUSDS, a conversion must be done before funding.
         // Withdraw that sUSDS amount locally and then redeem to USDS sending to the recipient
-        uint256 susdsAmount = susds.previewWithdraw(amountInWad);
-        TRSRY.increaseWithdrawApproval(address(this), susds, susdsAmount);
-        TRSRY.withdrawReserves(address(this), susds, susdsAmount);
-        susds.redeem(susdsAmount, recipient, address(this));
+        uint256 susdsAmount = SUSDS.previewWithdraw(amountInWad);
+        TRSRY.increaseWithdrawApproval(address(this), SUSDS, susdsAmount);
+        TRSRY.withdrawReserves(address(this), SUSDS, susdsAmount);
+        SUSDS.redeem(susdsAmount, recipient, address(this));
     }
 
     /// @inheritdoc ICoolerTreasuryBorrower
     function repay() external override onlyRole(COOLER_ROLE) {
-        uint256 debtTokenAmount = _usds.balanceOf(address(this));
+        uint256 debtTokenAmount = _USDS.balanceOf(address(this));
         if (debtTokenAmount == 0) revert ExpectedNonZero();
 
         // This policy is allowed to overpay TRSRY, in which case it's debt is set to zero
         // and any future repayments are just deposited. There are no 'credits' for overpaying
-        uint256 outstandingDebt = TRSRY.reserveDebt(_usds, address(this));
+        uint256 outstandingDebt = TRSRY.reserveDebt(_USDS, address(this));
         TRSRY.setDebt({
             debtor_: address(this),
-            token_: _usds,
+            token_: _USDS,
             amount_: (outstandingDebt > debtTokenAmount) ? outstandingDebt - debtTokenAmount : 0
         });
 
-        _usds.safeApprove(address(susds), debtTokenAmount);
-        susds.deposit(debtTokenAmount, address(TRSRY));
+        _USDS.safeApprove(address(SUSDS), debtTokenAmount);
+        SUSDS.deposit(debtTokenAmount, address(TRSRY));
     }
 
     /// @inheritdoc ICoolerTreasuryBorrower
     function setDebt(uint256 debtTokenAmount) external override onlyRole(ADMIN_ROLE) {
-        TRSRY.setDebt({debtor_: address(this), token_: _usds, amount_: debtTokenAmount});
+        TRSRY.setDebt({debtor_: address(this), token_: _USDS, amount_: debtTokenAmount});
     }
 
     /// @inheritdoc ICoolerTreasuryBorrower
     function debtToken() external view override returns (IERC20) {
-        return IERC20(address(_usds));
+        return IERC20(address(_USDS));
     }
 
     /// @inheritdoc ICoolerTreasuryBorrower
     function convertToDebtTokenAmount(
         uint256 amountInWad
     ) external view override returns (IERC20 dToken, uint256 dTokenAmount) {
-        dToken = IERC20(address(_usds));
+        dToken = IERC20(address(_USDS));
         dTokenAmount = amountInWad;
     }
 }

src/policies/cooler/MonoCooler.sol

@@ -43,17 +43,17 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
     //                                         IMMUTABLES                                         //
     //============================================================================================//
 
-    /// @inheritdoc IMonoCooler
-    IERC20 public immutable override collateralToken;
+    /// @dev The collateral token, eg gOHM
+    ERC20 private immutable _COLLATERAL_TOKEN;
 
-    /// @inheritdoc IMonoCooler
-    IERC20 public immutable override ohm;
+    /// @dev The OHM token
+    ERC20 private immutable _OHM;
 
-    /// @inheritdoc IMonoCooler
-    IStaking public immutable override staking;
+    /// @dev The OHM staking contract
+    IStaking private immutable _STAKING;
 
-    /// @inheritdoc IMonoCooler
-    uint256 public immutable override minDebtRequired;
+    /// @dev The minimum debt a user needs to maintain
+    uint256 private immutable _MIN_DEBT_REQUIRED;
 
     /// @inheritdoc IMonoCooler
     bytes32 public immutable override DOMAIN_SEPARATOR;
@@ -126,7 +126,7 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
             "Authorization(address account,address authorized,uint96 authorizationDeadline,uint256 nonce,uint256 signatureDeadline)"
         );
 
-    /// @dev expected decimals for the `collateralToken` and `treasuryBorrower`
+    /// @dev expected decimals for the `_COLLATERAL_TOKEN` and `treasuryBorrower`
     uint8 private constant _EXPECTED_DECIMALS = 18;
 
     //============================================================================================//
@@ -142,14 +142,14 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
         uint96 interestRateWad_,
         uint256 minDebtRequired_
     ) Policy(Kernel(kernel_)) {
-        collateralToken = IERC20(gohm_);
+        _COLLATERAL_TOKEN = ERC20(gohm_);
 
         // Only handle 18dp collateral
-        if (collateralToken.decimals() != _EXPECTED_DECIMALS) revert InvalidParam();
+        if (_COLLATERAL_TOKEN.decimals() != _EXPECTED_DECIMALS) revert InvalidParam();
 
-        ohm = IERC20(ohm_);
-        staking = IStaking(staking_);
-        minDebtRequired = minDebtRequired_;
+        _OHM = ERC20(ohm_);
+        _STAKING = IStaking(staking_);
+        _MIN_DEBT_REQUIRED = minDebtRequired_;
 
         ltvOracle = ICoolerLtvOracle(ltvOracle_);
         (uint96 newOLTV, uint96 newLLTV) = ltvOracle.currentLtvs();
@@ -186,18 +186,18 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
         // If MINTR has changed, then update approval to burn OHM from the old
         address oldAddress = address(MINTR);
         if (address(newMINTR) != oldAddress) {
-            if (oldAddress != address(0)) ohm.approve(oldAddress, 0);
+            if (oldAddress != address(0)) _OHM.approve(oldAddress, 0);
 
-            ohm.approve(address(newMINTR), type(uint256).max);
+            _OHM.approve(address(newMINTR), type(uint256).max);
             MINTR = newMINTR;
         }
 
         // If DLGTE has changed, then update approval to pull gOHM for delegation
         oldAddress = address(DLGTE);
         if (address(newDLGTE) != oldAddress) {
-            if (oldAddress != address(0)) collateralToken.approve(address(oldAddress), 0);
+            if (oldAddress != address(0)) _COLLATERAL_TOKEN.approve(address(oldAddress), 0);
 
-            collateralToken.approve(address(newDLGTE), type(uint256).max);
+            _COLLATERAL_TOKEN.approve(address(newDLGTE), type(uint256).max);
             DLGTE = newDLGTE;
         }
     }
@@ -275,11 +275,7 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
 
         // Add collateral on behalf of another account
         AccountState storage aState = allAccountState[onBehalfOf];
-        ERC20(address(collateralToken)).safeTransferFrom(
-            msg.sender,
-            address(this),
-            collateralAmount
-        );
+        _COLLATERAL_TOKEN.safeTransferFrom(msg.sender, address(this), collateralAmount);
 
         aState.collateral += collateralAmount;
         totalCollateral += collateralAmount;
@@ -363,7 +359,7 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
 
         // Finally transfer the collateral to the recipient
         emit CollateralWithdrawn(msg.sender, onBehalfOf, recipient, collateralWithdrawn);
-        ERC20(address(collateralToken)).safeTransfer(recipient, collateralWithdrawn);
+        _COLLATERAL_TOKEN.safeTransfer(recipient, collateralWithdrawn);
     }
 
     //============================================================================================//
@@ -414,8 +410,8 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
             _accountDebtCheckpoint = currentDebt + amountBorrowed;
         }
 
-        if (_accountDebtCheckpoint < minDebtRequired)
-            revert MinDebtNotMet(minDebtRequired, _accountDebtCheckpoint);
+        if (_accountDebtCheckpoint < _MIN_DEBT_REQUIRED)
+            revert MinDebtNotMet(_MIN_DEBT_REQUIRED, _accountDebtCheckpoint);
 
         // Update the state
         aState.debtCheckpoint = _accountDebtCheckpoint;
@@ -462,8 +458,8 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
 
             // Ensure the minimum debt amounts are still maintained
             aState.debtCheckpoint = _accountDebtCheckpoint = latestDebt - amountRepaid;
-            if (_accountDebtCheckpoint < minDebtRequired) {
-                revert MinDebtNotMet(minDebtRequired, _accountDebtCheckpoint);
+            if (_accountDebtCheckpoint < _MIN_DEBT_REQUIRED) {
+                revert MinDebtNotMet(_MIN_DEBT_REQUIRED, _accountDebtCheckpoint);
             }
         } else {
             amountRepaid = latestDebt;
@@ -583,9 +579,9 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
         if (totalCollateralClaimed > 0) {
             // Unstake and burn gOHM holdings.
             uint128 gOhmToBurn = totalCollateralClaimed - totalLiquidationIncentive;
-            ERC20(address(collateralToken)).safeApprove(address(staking), gOhmToBurn);
+            _COLLATERAL_TOKEN.safeApprove(address(_STAKING), gOhmToBurn);
 
-            MINTR.burnOhm(address(this), staking.unstake(address(this), gOhmToBurn, false, false));
+            MINTR.burnOhm(address(this), _STAKING.unstake(address(this), gOhmToBurn, false, false));
 
             totalCollateral -= totalCollateralClaimed;
         }
@@ -597,7 +593,7 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
 
         // The liquidator receives the total incentives across all accounts
         if (totalLiquidationIncentive > 0) {
-            ERC20(address(collateralToken)).safeTransfer(msg.sender, totalLiquidationIncentive);
+            _COLLATERAL_TOKEN.safeTransfer(msg.sender, totalLiquidationIncentive);
         }
     }
 
@@ -675,11 +671,31 @@ contract MonoCooler is IMonoCooler, Policy, RolesConsumer {
     //                                      VIEW FUNCTIONS                                        //
     //============================================================================================//
 
+    /// @inheritdoc IMonoCooler
+    function collateralToken() external view override returns (IERC20) {
+        return IERC20(address(_COLLATERAL_TOKEN));
+    }
+
+    /// @inheritdoc IMonoCooler
+    function ohm() external view override returns (IERC20) {
+        return IERC20(address(_OHM));
+    }
+
     /// @inheritdoc IMonoCooler
     function debtToken() external view override returns (IERC20) {
         return treasuryBorrower.debtToken();
     }
 
+    /// @inheritdoc IMonoCooler
+    function staking() external view override returns (IStaking) {
+        return _STAKING;
+    }
+
+    /// @inheritdoc IMonoCooler
+    function minDebtRequired() external view override returns (uint256) {
+        return _MIN_DEBT_REQUIRED;
+    }
+
     /// @inheritdoc IMonoCooler
     function loanToValues()
         external