Thunder Loan

Description

In ThunderLoan.sol:153-154, deposit() calls assetToken.updateExchangeRate(calculatedFee):

// File: src/protocol/ThunderLoan.sol                                                   
    function deposit(IERC20 token, uint256 amount) external revertIfZero(amount)        

revertIfNotAllowedToken(token) {
AssetToken assetToken = s_tokenToAssetToken[token];
uint256 exchangeRate = assetToken.getExchangeRate();
uint256 mintAmount = (amount * assetToken.EXCHANGE_RATE_PRECISION()) /
exchangeRate;
emit Deposit(msg.sender, token, amount);
assetToken.mint(msg.sender, mintAmount);
@> uint256 calculatedFee = getCalculatedFee(token, amount);
@> assetToken.updateExchangeRate(calculatedFee);
token.safeTransferFrom(msg.sender, address(assetToken), amount);
}

However, a depositor only transfers amount of the underlying token—no fee is paid into the
protocol during deposit. Invoking updateExchangeRate(calculatedFee) inflates
s_exchangeRate without adding corresponding backing assets to the contract.

When liquidity providers attempt to redeem their AssetToken shares via redeem():

uint256 amountUnderlying = (amountOfAssetToken * exchangeRate) / assetToken.            

EXCHANGE_RATE_PRECISION();
assetToken.transferUnderlyingTo(msg.sender, amountUnderlying);

The contract does not hold sufficient tokens to satisfy the inflated redemption amount. If
there is a sole liquidity provider, they can never redeem their full balance and their
funds become permanently trapped. If multiple providers exist, early redeemers siphon
other users' capital until the pool is insolvent.

Risk

Likelihood: High

Impact: High

Proof of Concept

function test_WRRE_DepositInflatesExchangeRateCausingInsolvency() public {              
    ERC20Mock cleanToken = new ERC20Mock();                                             
    mockPoolFactory.createPool(address(cleanToken));                                    
                                                                                        
    vm.prank(thunderLoan.owner());                                                      
    AssetToken cleanAsset = thunderLoan.setAllowedToken(cleanToken, true);              
                                                                                        
    address soleLP = address(789);                                                      
    uint256 depositAmt = 100e18;                                                        
    cleanToken.mint(soleLP, depositAmt);                                                
                                                                                        
    vm.startPrank(soleLP);                                                              
    cleanToken.approve(address(thunderLoan), depositAmt);                               
    thunderLoan.deposit(cleanToken, depositAmt);                                        
                                                                                        
    // Exchange rate artificially inflated from 1e18 to 1.003e18 without any fee        

received
assertEq(cleanAsset.getExchangeRate(), 1003000000000000000);

    // LP attempts to redeem their full deposit                                         
    uint256 lpShares = cleanAsset.balanceOf(soleLP);                                    
    // Reverts with ERC20 transfer amount exceeds balance because contract only holds   

100e18 tokens
vm.expectRevert();
thunderLoan.redeem(cleanToken, lpShares);
vm.stopPrank();
}

Recommended Mitigation

Remove the updateExchangeRate invocation from deposit(). The exchange rate should only be
updated when actual flash loan fees are collected:

--- a/src/protocol/ThunderLoan.sol                                                      
+++ b/src/protocol/ThunderLoan.sol                                                      
@@ -150,8 +150,6 @@ contract ThunderLoan is Initializable, OwnableUpgradeable,          

UUPSUpgradeable, Ora
uint256 mintAmount = (amount * assetToken.EXCHANGE_RATE_PRECISION()) /
exchangeRate;
emit Deposit(msg.sender, token, amount);
assetToken.mint(msg.sender, mintAmount);
- uint256 calculatedFee = getCalculatedFee(token, amount);
- assetToken.updateExchangeRate(calculatedFee);
token.safeTransferFrom(msg.sender, address(assetToken), amount);