dimah7 - Consequent transfers of stETH, will result in DoS

[sherlock-admin4]

dimah7

High

Consequent transfers of stETH, will result in DoS

Summary

In many cases Lido's stETH token balance is getting with 1 or 2 wei down on transfers due to rounding down math calculation. More specifically, this happens because the balance calculation of the token depends on two integer divisions, where each one has a loss of 1 wei at most. More info about this corner case from Lido's docs here. However in protocol's case deposit function calls will revert, because it's not accounting properly value transfers.

Vulnerability Detail

As can be seen below the DepositWrapper::deposit function is used to deposit tokens into the protocol's vault, with additional functionality to wrap up the tokens to the required standard:

function deposit(
        address to,
        address token,
        uint256 amount,
        uint256 minLpAmount,
        uint256 deadline
    ) external payable returns (uint256 lpAmount) {
        address wrapper = address(this);
        address sender = msg.sender;
        address[] memory tokens = vault.underlyingTokens();
        if (tokens.length != 1 || tokens[0] != wsteth)
            revert InvalidTokenList();
        if (amount == 0) revert InvalidAmount();
        if (token == steth) {
            IERC20(steth).safeTransferFrom(sender, wrapper, amount);
            amount = _stethToWsteth(amount);
            ...

function _stethToWsteth(uint256 amount) private returns (uint256) {
        IERC20(steth).safeIncreaseAllowance(wsteth, amount);
        IWSteth(wsteth).wrap(amount);
        return IERC20(wsteth).balanceOf(address(this));
    }            

Although the _stethToWsteth function returns wstETH balance of the contract, this implementation doesn't account properly for real amount as the call will revert on the wrap function, as we'll have transfered amount - 1 and the contract doesn't hold stETH tokens.

Link to Lido's discussions on this case here

Impact

Will result in DoS, the impact would be even greater if any external protocols implement this contract

Code Snippet

https://github.com/sherlock-audit/2024-06-mellow/blob/6defa2f3481ee3232ea256d0c1e4f9df9860ffa5/mellow-lrt/src/utils/DepositWrapper.sol#L56-L57

Tool used

Manual Review

Recommendation

Implement fee-on-transfer balance check methods, which checks the balances before and after transfer, then the real amount will be as amount input

function deposit(
        address to,
        address token,
        uint256 amount,
        uint256 minLpAmount,
        uint256 deadline
    ) external payable returns (uint256 lpAmount) {
        address wrapper = address(this);
        address sender = msg.sender;
        address[] memory tokens = vault.underlyingTokens();
        if (tokens.length != 1 || tokens[0] != wsteth)
            revert InvalidTokenList();
        if (amount == 0) revert InvalidAmount();
        if (token == steth) {
+           uint256 balanceBefore = IERC20(steth).balanceOf(wrapper);
            IERC20(steth).safeTransferFrom(sender, wrapper, amount);
+           uint256 realAmount =  (IERC20(stETH).balanceOf(wrapper) - balanceBefore); 
-           amount = _stethToWsteth(amount);
+           amount = _stethToWsteth(realAmount);
            ...

Or as Lido recommends implement transferShares function to handle transfer amounts

Duplicate of #299