fix(ATokenVaultMerklRewardClaimer): do not allow claiming and forwarding of aToken

- The change is intended to protect against an attack which leverages a
  malicious distributor contract which enters into the ATokenVault
  via depositATokens(uint256 assets, address receiver) then forwards
  the aToken after the IMerklDistributor::claim call executes,
  effectively allowing an actor to obtain vault shares for free

Author: aa-eyup

src/ATokenVaultMerklRewardClaimer.sol

@@ -45,6 +45,7 @@ contract ATokenVaultMerklRewardClaimer is ATokenVault, IATokenVaultMerklRewardCl
 
         uint256[] memory currentBalancesOfRewardTokens = new uint256[](rewardTokensToForward.length);
         for (uint256 i = 0; i < rewardTokensToForward.length; i++) {
+            require(rewardTokensToForward[i] != address(ATOKEN), "CANNOT_FORWARD_ATOKEN");
             currentBalancesOfRewardTokens[i] = IERC20Upgradeable(rewardTokensToForward[i]).balanceOf(address(this));
         }
 

test/ATokenVaultMerklRewardClaimer.t.sol

@@ -76,7 +76,7 @@ contract ATokenVaultMerklRewardClaimerTest is ATokenVaultBaseTest {
     }
 
     function testClaimMerklRewardsAndForwardPartialTokenToDestination() public {
-        // Context: 2 tokens will be rewarded, but only one will be forwarded to the destination.
+        // Context: 2 tokens will be rewarded, but only one (the non-aToken) will be forwarded to the destination.
         _setMerklDistributor();
 
         uint256 amountOfATokenRewarded = 789 * 1e18;
@@ -127,8 +127,8 @@ contract ATokenVaultMerklRewardClaimerTest is ATokenVaultBaseTest {
         assertEq(_aDai.balanceOf(address(_vaultMerklRewardClaimer)), beforeBalanceOfAToken + amountOfATokenRewarded);
     }
 
-    function testClaimMerklRewardsAndForwardFullTokenToDestination() public {
-        // Context: 2 tokens will be rewarded, and both will be forwarded to the destination.
+    function testClaimMerklRewardsAndForwardFailsGivenATokenIsForwarded() public {
+        // Context: 2 tokens will be rewarded, and both will be attempted to be forwarded to the destination.
         _setMerklDistributor();
 
         uint256 amountOfATokenRewarded = 789 * 1e18;
@@ -160,24 +160,10 @@ contract ATokenVaultMerklRewardClaimerTest is ATokenVaultBaseTest {
         rewardTokensToForward[0] = address(_aDai);
         rewardTokensToForward[1] = address(_dai);
         address destination = makeAddr("destination");
-        
-        // Check that the vault does not have any aDAI.
-        uint256 beforeBalanceOfAToken = _aDai.balanceOf(address(_vaultMerklRewardClaimer));
-        uint256 beforeBalanceOfDAI = _dai.balanceOf(address(_vaultMerklRewardClaimer));
 
-        vm.expectEmit(true, true, false, true, address(_vaultMerklRewardClaimer));
-        emit IATokenVaultMerklRewardClaimer.MerklRewardsClaimed(address(_merklDistributor), mockRewardTokens, mockAmounts);
-        vm.expectEmit(true, true, false, true, address(_vaultMerklRewardClaimer));
-        emit IATokenVaultMerklRewardClaimer.MerklRewardsTokenForwarded(address(_dai), destination, amountOfDAIRewarded);
+        vm.expectRevert(bytes("CANNOT_FORWARD_ATOKEN"));
         vm.prank(OWNER);
         _vaultMerklRewardClaimer.claimMerklRewards(mockRewardTokens, mockAmounts, proofs, rewardTokensToForward, destination);
-
-        // Check that the destination received the DAI and aDAI.
-        assertEq(_dai.balanceOf(destination), amountOfDAIRewarded);
-        assertEq(_aDai.balanceOf(destination), amountOfATokenRewarded);
-        // Check that the vault did not hold onto the aDAI and DAI.
-        assertEq(_aDai.balanceOf(address(_vaultMerklRewardClaimer)), beforeBalanceOfAToken);
-        assertEq(_dai.balanceOf(address(_vaultMerklRewardClaimer)), beforeBalanceOfDAI);
     }
 
     function testClaimMerklRewardsIfATokenIsRewarded() public {

test/ATokenVaultMerklRewardClaimerFork.t.sol

@@ -70,36 +70,20 @@ contract ATokenVaultMerklRewardClaimerForkTest is ATokenVaultBaseTest {
         assertEq(IERC20(WRAPPED_A_HOR_RWA_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS), beforeBalanceOfWrappedAHorRwaRLUSD);
     }
 
-    function testOwnerCanClaimMerklRewardsAndForwardToDestination() public {      
-        uint256 expectedAmountOfAHorRwaRLUSDReceived = 3772222577889726879658;
+    function testOwnerCanNotClaimMerklRewardsAndForwardToDestination() public {
         _setMerklDistributor();
         // Set the code for an address that has claimable rewards as of the fork block
         // We will use this in place of the vault deployment
         _etchVault(ADDRESS_WITH_CLAIMABLE_REWARDS);
         address destination = makeAddr("destination");
-
-        uint256 beforeBalanceOfAHorRwaRLUSD = IERC20(A_HOR_RWA_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS);
-        uint256 beforeBalanceOfWrappedAHorRwaRLUSD = IERC20(WRAPPED_A_HOR_RWA_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS);
 
         (address[] memory tokens, uint256[] memory amounts, bytes32[][] memory proofs) = _buildMerklRewardsClaimData();
         address[] memory rewardTokensToForward = new address[](1);
         rewardTokensToForward[0] = address(A_HOR_RWA_RLUSD);
 
-        vm.expectEmit(true, true, false, true, ADDRESS_WITH_CLAIMABLE_REWARDS);
-        emit IATokenVaultMerklRewardClaimer.MerklRewardsClaimed(MERKL_DISTRIBUTOR, tokens, amounts);
-        vm.expectEmit(true, true, false, true, ADDRESS_WITH_CLAIMABLE_REWARDS);
-        emit IATokenVaultMerklRewardClaimer.MerklRewardsTokenForwarded(address(A_HOR_RWA_RLUSD), destination, expectedAmountOfAHorRwaRLUSDReceived);
+        vm.expectRevert(bytes("CANNOT_FORWARD_ATOKEN"));
         vm.prank(OWNER);
         IATokenVaultMerklRewardClaimer(ADDRESS_WITH_CLAIMABLE_REWARDS).claimMerklRewards(tokens, amounts, proofs, rewardTokensToForward, destination);
-
-        // Check that the vault did not hold onto the A tokens.
-        assertEq(IERC20(A_HOR_RWA_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS), beforeBalanceOfAHorRwaRLUSD);
-        // Check that total assets is the same as the balance of the A tokens.
-        assertEq(IERC20(A_HOR_RWA_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS), IATokenVault(ADDRESS_WITH_CLAIMABLE_REWARDS).totalAssets());
-        // Check that the vault's balance of the wrapped aToken is unchcanged.
-        assertEq(IERC20(WRAPPED_A_HOR_RWA_RLUSD).balanceOf(ADDRESS_WITH_CLAIMABLE_REWARDS), beforeBalanceOfWrappedAHorRwaRLUSD);
-        // Check that the destination received the A tokens.
-        assertEq(IERC20(A_HOR_RWA_RLUSD).balanceOf(destination), expectedAmountOfAHorRwaRLUSDReceived);
     }
 
     function _buildMerklRewardsClaimData() internal pure returns (address[] memory tokens, uint256[] memory amounts, bytes32[][] memory proofs) {