fix: review

Author: Schlagonia

src/Bases/convertors/BaseConvertor.sol

@@ -40,13 +40,13 @@ contract BaseConvertor is BaseHealthCheck {
         IMerklDistributor(0x3Ef3D8bA38EBe18DB133cEc108f4D14CE00Dd9Ae);
 
     /// @notice Token converted to/from strategy `asset`.
-    ERC20 public immutable want;
+    ERC20 public immutable WANT;
 
     /// @notice Auction selling `asset` into `want`.
-    Auction public immutable sellAssetAuction;
+    Auction public immutable SELL_ASSET_AUCTION;
 
     /// @notice Auction selling `want` into `asset`.
-    Auction public immutable buyAssetAuction;
+    Auction public immutable BUY_ASSET_AUCTION;
 
     /// @notice Morpho-style oracle with answer = asset per want, scaled 1e36.
     address public oracle;
@@ -75,7 +75,7 @@ contract BaseConvertor is BaseHealthCheck {
         address _want,
         address _oracle
     ) BaseHealthCheck(_asset, _name) {
-        want = ERC20(_want);
+        WANT = ERC20(_want);
 
         AuctionFactory factory = AuctionFactory(
             0xbA7FCb508c7195eE5AE823F37eE2c11D7ED52F8e
@@ -87,16 +87,18 @@ contract BaseConvertor is BaseHealthCheck {
         _sellAssetAuction.enable(_asset);
         _sellAssetAuction.setStepDecayRate(1);
         _sellAssetAuction.setGovernanceOnlyKick(true);
-        sellAssetAuction = _sellAssetAuction;
+        SELL_ASSET_AUCTION = _sellAssetAuction;
 
         Auction _buyAssetAuction = Auction(
             factory.createNewAuction(_asset, address(this), address(this))
         );
         _buyAssetAuction.enable(_want);
         _buyAssetAuction.setStepDecayRate(1);
         _buyAssetAuction.setGovernanceOnlyKick(true);
-        buyAssetAuction = _buyAssetAuction;
+        BUY_ASSET_AUCTION = _buyAssetAuction;
 
+        // We store the default decay rate in case a custom one
+        // is ever used for a specific auction we can reset it to the default.
         decayRate = 1;
 
         _setStartingPriceBps(uint16(MAX_BPS + 10));
@@ -130,6 +132,8 @@ contract BaseConvertor is BaseHealthCheck {
         _setStartingPriceBps(_startingPriceBps);
     }
 
+    /// @notice Set the default decay rate used for want/asset auctions.
+    ///  Reward token auctions always use DEFAULT_AUCTION_DECAY_RATE.
     function setDecayRate(uint256 _decayRate) external onlyManagement {
         _setDecayRate(_decayRate);
     }
@@ -144,14 +148,6 @@ contract BaseConvertor is BaseHealthCheck {
         _setMaxGasPriceToTend(_maxGasPriceToTend);
     }
 
-    /// @notice Management passthrough to set auction step decay rate.
-    function setAuctionStepDecayRate(
-        address _from,
-        uint256 _stepDecayRate
-    ) external onlyManagement {
-        _auctionForToken(_from).setStepDecayRate(_stepDecayRate);
-    }
-
     /// @notice Management passthrough to set auction step duration.
     function setAuctionStepDuration(
         address _from,
@@ -182,23 +178,25 @@ contract BaseConvertor is BaseHealthCheck {
     }
 
     function _kickAuction(address _from) internal virtual returns (uint256) {
-        if (_from == address(asset)) {
-            return _kickConfiguredAuction(sellAssetAuction, _from);
+        if (_from == address(WANT)) {
+            return _kickConfiguredAuction(BUY_ASSET_AUCTION, _from);
         }
-        return _kickConfiguredAuction(buyAssetAuction, _from);
+        return _kickConfiguredAuction(SELL_ASSET_AUCTION, _from);
     }
 
     function kickable(address _from) public view virtual returns (uint256) {
-        if (_from == address(asset)) {
-            return _kickableFromAuction(sellAssetAuction, _from);
+        if (_from == address(WANT)) {
+            return _kickableFromAuction(BUY_ASSET_AUCTION, _from);
         }
-        return _kickableFromAuction(buyAssetAuction, _from);
+        return _kickableFromAuction(SELL_ASSET_AUCTION, _from);
     }
 
+    /// @notice We use trigger to go from asset -> want.
+    /// We cannot assume loose want should be converted, so it does not go back.
     function auctionTrigger(
         address _from
     ) external view returns (bool shouldKick, bytes memory data) {
-        if (_from == address(want)) return (false, bytes("want"));
+        if (_from == address(WANT)) return (false, bytes("want"));
 
         if (!(_isBaseFeeAcceptable())) return (false, bytes("base fee"));
 
@@ -247,15 +245,15 @@ contract BaseConvertor is BaseHealthCheck {
     }
 
     function balanceOfWant() public view virtual returns (uint256) {
-        return want.balanceOf(address(this));
+        return WANT.balanceOf(address(this));
     }
 
     function balanceOfAssetInAuction() public view virtual returns (uint256) {
-        return asset.balanceOf(address(sellAssetAuction));
+        return asset.balanceOf(address(SELL_ASSET_AUCTION));
     }
 
     function balanceOfWantInAuction() public view virtual returns (uint256) {
-        return want.balanceOf(address(buyAssetAuction));
+        return WANT.balanceOf(address(BUY_ASSET_AUCTION));
     }
 
     function availableWithdrawLimit(
@@ -272,6 +270,10 @@ contract BaseConvertor is BaseHealthCheck {
         require(_oracle != address(0), "ZERO ADDRESS");
 
         oracle = _oracle;
+
+        // Call _oraclePrice() to ensure the oracle is valid.
+        _oraclePrice();
+
         emit OracleSet(_oracle);
     }
 
@@ -337,7 +339,6 @@ contract BaseConvertor is BaseHealthCheck {
         }
 
         _available = _kickableFromAuction(_auction, _from);
-        if (_available < minAmountToSell) return 0;
 
         _setAuctionPricing(_auction, _from, _available);
 
@@ -385,8 +386,8 @@ contract BaseConvertor is BaseHealthCheck {
     function _auctionForToken(
         address _from
     ) internal view returns (Auction _auction) {
-        if (_from == address(asset)) return sellAssetAuction;
-        return buyAssetAuction;
+        if (_from == address(WANT)) return BUY_ASSET_AUCTION;
+        return SELL_ASSET_AUCTION;
     }
 
     function _oraclePrice() internal view virtual returns (uint256 _price) {
@@ -407,7 +408,8 @@ contract BaseConvertor is BaseHealthCheck {
             uint256 _stepDecayRate
         )
     {
-        if (_from != address(asset) && _from != address(want)) {
+        // If non want/asset tokens, use the default auction pricing.
+        if (_from != address(asset) && _from != address(WANT)) {
             return (
                 DEFAULT_AUCTION_STARTING_PRICE,
                 0,
@@ -424,6 +426,7 @@ contract BaseConvertor is BaseHealthCheck {
             Math.Rounding.Up
         );
 
+        // Auction starting price is a lot size, so we need to adjust for amount.
         _startingPrice = Math.mulDiv(
             _amount,
             startUnitPrice,
@@ -446,10 +449,10 @@ contract BaseConvertor is BaseHealthCheck {
         if (_from == address(asset)) {
             uint256 oneAsset = 10 ** asset.decimals();
             uint256 quoteWant = _quoteWantFromAsset(oneAsset);
-            return Math.mulDiv(quoteWant, 1e18, 10 ** want.decimals());
+            return Math.mulDiv(quoteWant, 1e18, 10 ** WANT.decimals());
         }
 
-        uint256 oneWant = 10 ** want.decimals();
+        uint256 oneWant = 10 ** WANT.decimals();
         uint256 quoteAsset = _quoteAssetFromWant(oneWant);
         return Math.mulDiv(quoteAsset, 1e18, 10 ** asset.decimals());
     }

src/Bases/convertors/BaseConvertor4626.sol

@@ -22,13 +22,13 @@ contract BaseConvertor4626 is BaseConvertor {
         address _asset,
         string memory _name,
         address _want,
-        address _vault,
-        address _oracle
+        address _oracle,
+        address _vault
     ) BaseConvertor(_asset, _name, _want, _oracle) {
         vault = IERC4626(_vault);
         require(vault.asset() == _want, "wrong vault");
 
-        want.forceApprove(_vault, type(uint256).max);
+        WANT.forceApprove(_vault, type(uint256).max);
     }
 
     /*//////////////////////////////////////////////////////////////
@@ -43,7 +43,7 @@ contract BaseConvertor4626 is BaseConvertor {
     function freeWant(uint256 _wantAmount) external onlyKeepers {
         uint256 freedWant = _freeWantFromVault(_wantAmount);
         if (freedWant > 0) {
-            _kickConfiguredAuction(buyAssetAuction, address(want));
+            _kickConfiguredAuction(BUY_ASSET_AUCTION, address(WANT));
         }
     }
 
@@ -122,7 +122,7 @@ contract BaseConvertor4626 is BaseConvertor {
     function _emergencyWithdraw(uint256 _amount) internal virtual override {
         uint256 wantAmount = _quoteWantFromAsset(_amount);
         _freeWantFromVault(wantAmount);
-        _kickConfiguredAuction(buyAssetAuction, address(want));
+        _kickConfiguredAuction(BUY_ASSET_AUCTION, address(WANT));
     }
 
     /*//////////////////////////////////////////////////////////////

src/Bases/convertors/Convertor4626Factory.sol

@@ -39,15 +39,15 @@ contract Convertor4626Factory {
         address _asset,
         string calldata _name,
         address _want,
-        address _vault,
-        address _oracle
+        address _oracle,
+        address _vault
     ) external returns (address) {
         address deployed = deployments4626[_asset][_want][_vault];
         if (deployed != address(0)) revert AlreadyDeployed(deployed);
 
         IBaseConvertor4626 _newConvertor = IBaseConvertor4626(
             address(
-                new BaseConvertor4626(_asset, _name, _want, _vault, _oracle)
+                new BaseConvertor4626(_asset, _name, _want, _oracle, _vault)
             )
         );
 
@@ -75,7 +75,7 @@ contract Convertor4626Factory {
     ) external view returns (bool) {
         IBaseConvertor4626 convertor = IBaseConvertor4626(_strategy);
         return
-            deployments4626[convertor.asset()][convertor.want()][
+            deployments4626[convertor.asset()][convertor.WANT()][
                 convertor.vault()
             ] == _strategy;
     }

src/Bases/convertors/ConvertorFactory.sol

@@ -68,7 +68,7 @@ contract ConvertorFactory {
         address _strategy
     ) external view returns (bool) {
         IBaseConvertor convertor = IBaseConvertor(_strategy);
-        return deployments[convertor.asset()][convertor.want()] == _strategy;
+        return deployments[convertor.asset()][convertor.WANT()] == _strategy;
     }
 
     function _configureStrategy(IBaseConvertor _strategy) internal {

src/Bases/convertors/IBaseConvertor.sol

@@ -4,11 +4,11 @@ pragma solidity >=0.8.18;
 import {IBaseHealthCheck} from "../HealthCheck/IBaseHealthCheck.sol";
 
 interface IBaseConvertor is IBaseHealthCheck {
-    function want() external view returns (address);
+    function WANT() external view returns (address);
 
-    function sellAssetAuction() external view returns (address);
+    function SELL_ASSET_AUCTION() external view returns (address);
 
-    function buyAssetAuction() external view returns (address);
+    function BUY_ASSET_AUCTION() external view returns (address);
 
     function oracle() external view returns (address);
 
@@ -38,11 +38,6 @@ interface IBaseConvertor is IBaseHealthCheck {
 
     function setMaxGasPriceToTend(uint256 _maxGasPriceToTend) external;
 
-    function setAuctionStepDecayRate(
-        address _from,
-        uint256 _stepDecayRate
-    ) external;
-
     function setAuctionStepDuration(
         address _from,
         uint256 _stepDuration