Merge pull request #91 from AztecProtocol/lh/liquity-linter-warnings

benesjan · web-flow · commit 90fa97fb1056 · 2022-06-07T10:02:27.000+02:00
fix: linter warnings in liquity contracts
diff --git a/src/bridges/liquity/StabilityPoolBridge.sol b/src/bridges/liquity/StabilityPoolBridge.sol
@@ -91,25 +91,25 @@ contract StabilityPoolBridge is IDefiBridge, ERC20("StabilityPoolBridge", "SPB")
      * this scenario because I expect the liquidation bots to be so fast that the scenario will never occur. Checking
      * for it would only waste gas.
      *
-     * @param inputAssetA - LUSD (Deposit) or SPB (Withdrawal)
-     * @param outputAssetA - SPB (Deposit) or LUSD (Withdrawal)
-     * @param inputValue - the amount of LUSD to deposit or the amount of SPB to burn and exchange for LUSD
+     * @param _inputAssetA - LUSD (Deposit) or SPB (Withdrawal)
+     * @param _outputAssetA - SPB (Deposit) or LUSD (Withdrawal)
+     * @param _inputValue - the amount of LUSD to deposit or the amount of SPB to burn and exchange for LUSD
      * @return outputValueA - the amount of SPB (Deposit) or LUSD (Withdrawal) minted/transferred to
      * the RollupProcessor.sol
      */
     function convert(
-        AztecTypes.AztecAsset calldata inputAssetA,
+        AztecTypes.AztecAsset calldata _inputAssetA,
         AztecTypes.AztecAsset calldata,
-        AztecTypes.AztecAsset calldata outputAssetA,
+        AztecTypes.AztecAsset calldata _outputAssetA,
         AztecTypes.AztecAsset calldata,
-        uint256 inputValue,
+        uint256 _inputValue,
         uint256,
         uint64,
         address
     )
         external
         payable
-        override
+        override(IDefiBridge)
         returns (
             uint256 outputValueA,
             uint256,
@@ -118,34 +118,34 @@ contract StabilityPoolBridge is IDefiBridge, ERC20("StabilityPoolBridge", "SPB")
     {
         if (msg.sender != ROLLUP_PROCESSOR) revert InvalidCaller();
 
-        if (inputAssetA.erc20Address == LUSD && outputAssetA.erc20Address == address(this)) {
+        if (_inputAssetA.erc20Address == LUSD && _outputAssetA.erc20Address == address(this)) {
             // Deposit
             // Provides LUSD to the pool and claim rewards.
-            STABILITY_POOL.provideToSP(inputValue, FRONTEND_TAG);
-            swapRewardsToLUSDAndDeposit();
-            uint256 totalLUSDOwnedBeforeDeposit = STABILITY_POOL.getCompoundedLUSDDeposit(address(this)) - inputValue;
+            STABILITY_POOL.provideToSP(_inputValue, FRONTEND_TAG);
+            _swapRewardsToLUSDAndDeposit();
+            uint256 totalLUSDOwnedBeforeDeposit = STABILITY_POOL.getCompoundedLUSDDeposit(address(this)) - _inputValue;
             uint256 totalSupply = this.totalSupply();
             // outputValueA = how much SPB should be minted
             if (totalSupply == 0) {
                 // When the totalSupply is 0, I set the SPB/LUSD ratio to be 1.
-                outputValueA = inputValue;
+                outputValueA = _inputValue;
             } else {
                 // totalSupply / totalLUSDOwnedBeforeDeposit = how much SPB one LUSD is worth
                 // When I multiply this ^ with the amount of LUSD deposited I get the amount of SPB to be minted.
-                outputValueA = (totalSupply * inputValue) / totalLUSDOwnedBeforeDeposit;
+                outputValueA = (totalSupply * _inputValue) / totalLUSDOwnedBeforeDeposit;
             }
             _mint(address(this), outputValueA);
-        } else if (inputAssetA.erc20Address == address(this) && outputAssetA.erc20Address == LUSD) {
+        } else if (_inputAssetA.erc20Address == address(this) && _outputAssetA.erc20Address == LUSD) {
             // Withdrawal
             // Claim rewards and swap them to LUSD.
             STABILITY_POOL.withdrawFromSP(0);
-            swapRewardsToLUSDAndDeposit();
+            _swapRewardsToLUSDAndDeposit();
 
             // stabilityPool.getCompoundedLUSDDeposit(address(this)) / this.totalSupply() = how much LUSD is one SPB
             // outputValueA = amount of LUSD to be withdrawn and sent to RollupProcessor.sol
-            outputValueA = (STABILITY_POOL.getCompoundedLUSDDeposit(address(this)) * inputValue) / this.totalSupply();
+            outputValueA = (STABILITY_POOL.getCompoundedLUSDDeposit(address(this)) * _inputValue) / this.totalSupply();
             STABILITY_POOL.withdrawFromSP(outputValueA);
-            _burn(address(this), inputValue);
+            _burn(address(this), _inputValue);
         } else {
             revert IncorrectInput();
         }
@@ -162,7 +162,7 @@ contract StabilityPoolBridge is IDefiBridge, ERC20("StabilityPoolBridge", "SPB")
     )
         external
         payable
-        override
+        override(IDefiBridge)
         returns (
             uint256,
             uint256,
@@ -175,7 +175,7 @@ contract StabilityPoolBridge is IDefiBridge, ERC20("StabilityPoolBridge", "SPB")
     /**
      * @dev See {IERC20-totalSupply}.
      */
-    function totalSupply() public view override returns (uint256) {
+    function totalSupply() public view override(ERC20) returns (uint256) {
         return super.totalSupply() - DUST;
     }
 
@@ -186,7 +186,7 @@ contract StabilityPoolBridge is IDefiBridge, ERC20("StabilityPoolBridge", "SPB")
      * liquidations rewards (ETH) to LUSD as well, I will first swap LQTY to WETH and then swap it all through USDC to
      * LUSD.
      */
-    function swapRewardsToLUSDAndDeposit() internal {
+    function _swapRewardsToLUSDAndDeposit() internal {
         uint256 lqtyBalance = IERC20(LQTY).balanceOf(address(this));
         if (lqtyBalance > DUST) {
             UNI_ROUTER.exactInputSingle(
diff --git a/src/bridges/liquity/StakingBridge.sol b/src/bridges/liquity/StakingBridge.sol
@@ -83,24 +83,25 @@ contract StakingBridge is IDefiBridge, ERC20("StakingBridge", "SB") {
      * the method. If this is not the case, the function will revert (either in STAKING_CONTRACT.stake(...) or during
      * SB burn).
      *
-     * @param inputAssetA - LQTY (Staking) or SB (Unstaking)
-     * @param outputAssetA - SB (Staking) or LQTY (Unstaking)
-     * @param inputValue - the amount of LQTY to stake or the amount of SB to burn and exchange for LQTY
+     * @param _inputAssetA - LQTY (Staking) or SB (Unstaking)
+     * @param _outputAssetA - SB (Staking) or LQTY (Unstaking)
+     * @param _inputValue - the amount of LQTY to stake or the amount of SB to burn and exchange for LQTY
      * @return outputValueA - the amount of SB (Staking) or LQTY (Unstaking) minted/transferred to
      * the RollupProcessor.sol
      */
     function convert(
-        AztecTypes.AztecAsset calldata inputAssetA,
+        AztecTypes.AztecAsset calldata _inputAssetA,
         AztecTypes.AztecAsset calldata,
-        AztecTypes.AztecAsset calldata outputAssetA,
+        AztecTypes.AztecAsset calldata _outputAssetA,
         AztecTypes.AztecAsset calldata,
-        uint256 inputValue,
+        uint256 _inputValue,
         uint256,
         uint64,
         address
     )
         external
         payable
+        override(IDefiBridge)
         returns (
             uint256 outputValueA,
             uint256,
@@ -109,34 +110,34 @@ contract StakingBridge is IDefiBridge, ERC20("StakingBridge", "SB") {
     {
         if (msg.sender != ROLLUP_PROCESSOR) revert InvalidCaller();
 
-        if (inputAssetA.erc20Address == LQTY && outputAssetA.erc20Address == address(this)) {
+        if (_inputAssetA.erc20Address == LQTY && _outputAssetA.erc20Address == address(this)) {
             // Deposit
             // Stake and claim rewards
-            STAKING_CONTRACT.stake(inputValue);
-            swapRewardsToLQTYAndStake();
+            STAKING_CONTRACT.stake(_inputValue);
+            _swapRewardsToLQTYAndStake();
             uint256 totalSupply = this.totalSupply();
             // outputValueA = how much SB should be minted
             if (totalSupply == 0) {
                 // When the totalSupply is 0, I set the SB/LQTY ratio to be 1.
-                outputValueA = inputValue;
+                outputValueA = _inputValue;
             } else {
-                uint256 totalLQTYOwnedBeforeDeposit = STAKING_CONTRACT.stakes(address(this)) - inputValue;
+                uint256 totalLQTYOwnedBeforeDeposit = STAKING_CONTRACT.stakes(address(this)) - _inputValue;
                 // totalSupply / totalLQTYOwnedBeforeDeposit = how much SB one LQTY is worth
                 // When I multiply this ^ with the amount of LQTY deposited I get the amount of SB to be minted.
-                outputValueA = (totalSupply * inputValue) / totalLQTYOwnedBeforeDeposit;
+                outputValueA = (totalSupply * _inputValue) / totalLQTYOwnedBeforeDeposit;
             }
             _mint(address(this), outputValueA);
-        } else if (inputAssetA.erc20Address == address(this) && outputAssetA.erc20Address == LQTY) {
+        } else if (_inputAssetA.erc20Address == address(this) && _outputAssetA.erc20Address == LQTY) {
             // Withdrawal
             // Claim rewards
             STAKING_CONTRACT.unstake(0);
-            swapRewardsToLQTYAndStake();
+            _swapRewardsToLQTYAndStake();
 
             // STAKING_CONTRACT.stakes(address(this)) / this.totalSupply() = how much LQTY is one SB
             // outputValueA = amount of LQTY to be withdrawn and sent to rollupProcessor
-            outputValueA = (STAKING_CONTRACT.stakes(address(this)) * inputValue) / this.totalSupply();
+            outputValueA = (STAKING_CONTRACT.stakes(address(this)) * _inputValue) / this.totalSupply();
             STAKING_CONTRACT.unstake(outputValueA);
-            _burn(address(this), inputValue);
+            _burn(address(this), _inputValue);
         } else {
             revert IncorrectInput();
         }
@@ -153,6 +154,7 @@ contract StakingBridge is IDefiBridge, ERC20("StakingBridge", "SB") {
     )
         external
         payable
+        override(IDefiBridge)
         returns (
             uint256,
             uint256,
@@ -165,7 +167,7 @@ contract StakingBridge is IDefiBridge, ERC20("StakingBridge", "SB") {
     /**
      * @dev See {IERC20-totalSupply}.
      */
-    function totalSupply() public view override returns (uint256) {
+    function totalSupply() public view override(ERC20) returns (uint256) {
         return super.totalSupply() - DUST;
     }
 
@@ -176,7 +178,7 @@ contract StakingBridge is IDefiBridge, ERC20("StakingBridge", "SB") {
      * liquidation rewards (ETH) to LQTY as well, I will first swap LUSD to WETH through USDC and then swap it all
      * to LQTY
      */
-    function swapRewardsToLQTYAndStake() internal {
+    function _swapRewardsToLQTYAndStake() internal {
         uint256 lusdBalance = IERC20(LUSD).balanceOf(address(this));
         if (lusdBalance > DUST) {
             UNI_ROUTER.exactInput(
diff --git a/src/bridges/liquity/TroveBridge.sol b/src/bridges/liquity/TroveBridge.sol
@@ -125,28 +125,29 @@ contract TroveBridge is ERC20, Ownable, IDefiBridge {
      * the method. If this is not the case, the function will revert.
      *
      *                              Borrowing               Repaying                Redeeming
-     * @param inputAssetA -         ETH                     TB                      TB
-     * @param inputAssetB -         None                    LUSD                    None
-     * @param outputAssetA -        TB                      ETH                     ETH
-     * @param outputAssetB -        LUSD                    None                    None
-     * @param inputValue -          amount of ETH           amount of TB and LUSD   amount of TB
-     * @param interactionNonce -    nonce                   nonce                   nonce
-     * @param auxData -             max borrower fee        0                       0
+     * @param _inputAssetA -         ETH                     TB                      TB
+     * @param _inputAssetB -         None                    LUSD                    None
+     * @param _outputAssetA -        TB                      ETH                     ETH
+     * @param _outputAssetB -        LUSD                    None                    None
+     * @param _inputValue -          amount of ETH           amount of TB and LUSD   amount of TB
+     * @param _interactionNonce -    nonce                   nonce                   nonce
+     * @param _auxData -             max borrower fee        0                       0
      * @return outputValueA -       amount of TB            amount of ETH           amount of ETH
      * @return outputValueB -       amount of LUSD          0                       0
      */
     function convert(
-        AztecTypes.AztecAsset calldata inputAssetA,
-        AztecTypes.AztecAsset calldata inputAssetB,
-        AztecTypes.AztecAsset calldata outputAssetA,
-        AztecTypes.AztecAsset calldata outputAssetB,
-        uint256 inputValue,
-        uint256 interactionNonce,
-        uint64 auxData,
+        AztecTypes.AztecAsset calldata _inputAssetA,
+        AztecTypes.AztecAsset calldata _inputAssetB,
+        AztecTypes.AztecAsset calldata _outputAssetA,
+        AztecTypes.AztecAsset calldata _outputAssetB,
+        uint256 _inputValue,
+        uint256 _interactionNonce,
+        uint64 _auxData,
         address
     )
         external
         payable
+        override(IDefiBridge)
         returns (
             uint256 outputValueA,
             uint256 outputValueB,
@@ -160,36 +161,36 @@ contract TroveBridge is ERC20, Ownable, IDefiBridge {
         address lowerHint = SORTED_TROVES.getNext(address(this));
 
         if (
-            inputAssetA.assetType == AztecTypes.AztecAssetType.ETH &&
-            outputAssetA.erc20Address == address(this) &&
-            outputAssetB.erc20Address == LUSD
+            _inputAssetA.assetType == AztecTypes.AztecAssetType.ETH &&
+            _outputAssetA.erc20Address == address(this) &&
+            _outputAssetB.erc20Address == LUSD
         ) {
             // Borrowing
             if (troveStatus != Status.active) revert IncorrectStatus(Status.active, troveStatus);
             // outputValueA = by how much debt will increase and how much TB to mint
-            outputValueB = computeAmtToBorrow(inputValue); // LUSD amount to borrow
+            outputValueB = computeAmtToBorrow(_inputValue); // LUSD amount to borrow
 
             (uint256 debtBefore, , , ) = TROVE_MANAGER.getEntireDebtAndColl(address(this));
-            BORROWER_OPERATIONS.adjustTrove{value: inputValue}(auxData, 0, outputValueB, true, upperHint, lowerHint);
+            BORROWER_OPERATIONS.adjustTrove{value: _inputValue}(_auxData, 0, outputValueB, true, upperHint, lowerHint);
             (uint256 debtAfter, , , ) = TROVE_MANAGER.getEntireDebtAndColl(address(this));
 
             // outputValueA = debt increase = amount of TB to mint
             outputValueA = debtAfter - debtBefore;
             _mint(address(this), outputValueA);
         } else if (
-            inputAssetA.erc20Address == address(this) &&
-            inputAssetB.erc20Address == LUSD &&
-            outputAssetA.assetType == AztecTypes.AztecAssetType.ETH
+            _inputAssetA.erc20Address == address(this) &&
+            _inputAssetB.erc20Address == LUSD &&
+            _outputAssetA.assetType == AztecTypes.AztecAssetType.ETH
         ) {
             // Repaying
             if (troveStatus != Status.active) revert IncorrectStatus(Status.active, troveStatus);
             (, uint256 coll, , ) = TROVE_MANAGER.getEntireDebtAndColl(address(this));
-            outputValueA = (coll * inputValue) / this.totalSupply(); // Amount of collateral to withdraw
-            BORROWER_OPERATIONS.adjustTrove(0, outputValueA, inputValue, false, upperHint, lowerHint);
-            _burn(address(this), inputValue);
-            IRollupProcessor(ROLLUP_PROCESSOR).receiveEthFromBridge{value: outputValueA}(interactionNonce);
+            outputValueA = (coll * _inputValue) / this.totalSupply(); // Amount of collateral to withdraw
+            BORROWER_OPERATIONS.adjustTrove(0, outputValueA, _inputValue, false, upperHint, lowerHint);
+            _burn(address(this), _inputValue);
+            IRollupProcessor(ROLLUP_PROCESSOR).receiveEthFromBridge{value: outputValueA}(_interactionNonce);
         } else if (
-            inputAssetA.erc20Address == address(this) && outputAssetA.assetType == AztecTypes.AztecAssetType.ETH
+            _inputAssetA.erc20Address == address(this) && _outputAssetA.assetType == AztecTypes.AztecAssetType.ETH
         ) {
             // Redeeming
             if (troveStatus != Status.closedByRedemption)
@@ -198,9 +199,9 @@ contract TroveBridge is ERC20, Ownable, IDefiBridge {
                 BORROWER_OPERATIONS.claimCollateral();
                 collateralClaimed = true;
             }
-            outputValueA = (address(this).balance * inputValue) / this.totalSupply();
-            _burn(address(this), inputValue);
-            IRollupProcessor(ROLLUP_PROCESSOR).receiveEthFromBridge{value: outputValueA}(interactionNonce);
+            outputValueA = (address(this).balance * _inputValue) / this.totalSupply();
+            _burn(address(this), _inputValue);
+            IRollupProcessor(ROLLUP_PROCESSOR).receiveEthFromBridge{value: outputValueA}(_interactionNonce);
         } else {
             revert IncorrectInput();
         }
@@ -245,6 +246,7 @@ contract TroveBridge is ERC20, Ownable, IDefiBridge {
     )
         external
         payable
+        override(IDefiBridge)
         returns (
             uint256,
             uint256,
@@ -257,7 +259,7 @@ contract TroveBridge is ERC20, Ownable, IDefiBridge {
     /**
      * @notice Compute how much LUSD to borrow against collateral in order to keep ICR constant and by how much total
      * trove debt will increase.
-     * @param collateral Amount of ETH denominated in Wei
+     * @param _collateral Amount of ETH denominated in Wei
      * @return amtToBorrow Amount of LUSD to borrow to keep ICR constant.
      * + borrowing fee)
      * @dev I don't use view modifier here because the function updates PriceFeed state.
@@ -273,13 +275,13 @@ contract TroveBridge is ERC20, Ownable, IDefiBridge {
      * Note2: Step 4 is necessary to avoid loss of precision. BORROWING_RATE / DECIMAL_PRECISION was rounded to 0.
      * Note3: The borrowing fee computation is on this line in Liquity code: https://github.com/liquity/dev/blob/cb583ddf5e7de6010e196cfe706bd0ca816ea40e/packages/contracts/contracts/TroveManager.sol#L1433
      */
-    function computeAmtToBorrow(uint256 collateral) public returns (uint256 amtToBorrow) {
+    function computeAmtToBorrow(uint256 _collateral) public returns (uint256 amtToBorrow) {
         uint256 price = TROVE_MANAGER.priceFeed().fetchPrice();
         bool isRecoveryMode = TROVE_MANAGER.checkRecoveryMode(price);
         if (TROVE_MANAGER.getTroveStatus(address(this)) == 1) {
             // Trove is active - use current ICR and not the initial one
             uint256 icr = TROVE_MANAGER.getCurrentICR(address(this), price);
-            amtToBorrow = (collateral * price) / icr;
+            amtToBorrow = (_collateral * price) / icr;
             if (!isRecoveryMode) {
                 // Liquity is not in recovery mode so borrowing fee applies
                 uint256 borrowingRate = TROVE_MANAGER.getBorrowingRateWithDecay();
@@ -288,7 +290,7 @@ contract TroveBridge is ERC20, Ownable, IDefiBridge {
         } else {
             // Trove is inactive - I will use initial ICR to compute debt
             // 200e18 - 200 LUSD gas compensation to liquidators
-            amtToBorrow = (collateral * price) / INITIAL_ICR - 200e18;
+            amtToBorrow = (_collateral * price) / INITIAL_ICR - 200e18;
             if (!isRecoveryMode) {
                 // Liquity is not in recovery mode so borrowing fee applies
                 uint256 borrowingRate = TROVE_MANAGER.getBorrowingRateWithDecay();
@@ -300,7 +302,7 @@ contract TroveBridge is ERC20, Ownable, IDefiBridge {
     /**
      * @dev See {IERC20-totalSupply}.
      */
-    function totalSupply() public view override returns (uint256) {
+    function totalSupply() public view override(ERC20) returns (uint256) {
         return super.totalSupply() - DUST;
     }
 }
diff --git a/src/test/liquity/StabilityPoolBridgeInternal.t.sol b/src/test/liquity/StabilityPoolBridgeInternal.t.sol
@@ -30,7 +30,7 @@ contract StabilityPoolBridgeTestInternal is TestUtil, StabilityPoolBridge(addres
         payable(address(0)).transfer(address(this).balance - 1 ether);
 
         uint256 depositedLUSDBeforeSwap = STABILITY_POOL.getCompoundedLUSDDeposit(address(this));
-        swapRewardsToLUSDAndDeposit();
+        _swapRewardsToLUSDAndDeposit();
         uint256 depositedLUSDAfterSwap = STABILITY_POOL.getCompoundedLUSDDeposit(address(this));
 
         // Verify that rewards were swapped for non-zero amount and correctly staked
diff --git a/src/test/liquity/StakingBridgeInternal.t.sol b/src/test/liquity/StakingBridgeInternal.t.sol
