//License 1.0
pragma solidity ^0.6.6;
import "./FlashLoanReceiverBase.sol";
import "./ILendingPoolAddressesProvider.sol";
import "./ILendingPool.sol";
contract FlashloanV1 is FlashLoanReceiverBaseV1 {
    constructor(address _addressProvider) FlashLoanReceiverBaseV1(_addressProvider) public{}
 /**        Flash loan 1000000000000000000 wei (1 ether) worth of `_asset`     */
function flashloan(address _asset) public onlyOwner {
     bytes memory data = "";
     uint amount = 10000 ether;
     ILendingPoolV1 lendingPool = ILendingPoolV1(addressesProvider.getLendingPool());
     lendingPool.flashLoan(address(this), _asset, amount, data);
    }
    /**
  This function is called after your contract has received the flash loaned amount
     */
  
function executeOperation(
        address _reserve,
        uint256 _amount,
        uint256 _fee,      
        bytes calldata _params
    )
      
external override
  
{
        require(_amount <= getBalanceInternal(address(this), _reserve), "Invalid balance, was the flashLoan successful?");
       //
        // Main logic goes here.
        // !! Ensure that *this contract* has enough of `_reserve` funds to payback the `_fee` !!
        //
        uint totalDebt = _amount.add(_fee);
        transferFundsBackToPoolInternal(_reserve, totalDebt);
    }
}
abstract contract FlashLoanReceiverBaseV1 is IFlashLoanReceiverV1, Withdrawable {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    address constant ethAddress = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    ILendingPoolAddressesProviderV1 public addressesProvider;
    constructor(address _addressProvider) public {
        addressesProvider = ILendingPoolAddressesProviderV1(_addressProvider);
    }
    receive() payable external {}
    function transferFundsBackToPoolInternal(address _reserve, uint256 _amount) internal {
      
address payable core = addressesProvider.getLendingPoolCore();
        transferInternal(core, _reserve, _amount);
    }
    function transferInternal(address payable _destination, address _reserve, uint256 _amount) internal {      
if(_reserve == ethAddress) {
            (bool success, ) = _destination.call{value: _amount}("");
            
            require(success == true, "Couldn't transfer ETH");
            return;
        }
        IERC20(_reserve).safeTransfer(_destination, _amount);
    }
    function getBalanceInternal(address _target, address _reserve) internal view returns(uint256) {
        if(_reserve == ethAddress) {
            return _target.balance;
        }
        return IERC20(_reserve).balanceOf(_target);
    }
}