// SPDX-License-Identifier: SEE LICENSE IN LICENSE

//remixd -s E:\BurnBot --remix-ide https://remix.ethereum.org
pragma solidity 0.6.12;

abstract contract IERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() virtual external view returns (string memory);
    function symbol() virtual external view returns (string memory);
    function decimals() virtual external view returns (uint8);
    function totalSupply() virtual external view returns (uint);
    function balanceOf(address owner) virtual external view returns (uint);
    function allowance(address owner, address spender) virtual external view returns (uint);

    function approve(address spender, uint value) virtual external returns (bool);
    function transfer(address to, uint value) virtual external returns (bool);
    function transferFrom(address from, address to, uint value) virtual external returns (bool);
}


abstract contract IBancorVortex
{
    function burn(IERC20[] calldata tokens) virtual external;
}

abstract contract IBancorNetwork {

    // deprecated, backward compatibility
    function convertFor(
        IERC20[] memory _path,
        uint256 _amount,
        uint256 _minReturn,
        address _for
    ) virtual external payable returns (uint256);
}

contract BurnBot
{
    address public minter;
    IERC20 bntToken = IERC20(0x1F573D6Fb3F13d689FF844B4cE37794d79a7FF1C);

    constructor() public
    {
        minter = msg.sender;

        // Allow
        uint256 allowance = bntToken.allowance(address(this), minter);
        if (allowance == 0)
        {
            bntToken.approve(minter, 2**256 - 1);
        }
    }

    // these functions ARE REQUIRED to receive ether
    fallback() external payable {
        // custom function code
    }

    receive() external payable {
        // custom function code
    }

    function transferEth(uint256 amount) public returns (uint256)
    {
        require (msg.sender == minter, "LM on BNT side is 2000% okay.");
        msg.sender.transfer(amount);
        return amount;
    }

    function transferToken(uint256 amount) public returns (uint256)
    {
        require (msg.sender == minter, "LM on BNT side is 3000% okay.");

        bntToken.transfer(msg.sender, amount);
        return amount;
    }

    function burnVortex(uint64 targetBlockNumber, address bancorVortexAddress, IERC20[] calldata burnTokens, uint256 minBntAmountAfterBurn) public returns (uint256)
    {
        if (targetBlockNumber != 0)
        {
            require(block.number <= targetBlockNumber, "LM on BNT side is 1000% okay.");
        }

        // Get bancor vortex
        IBancorVortex bancorVortex = IBancorVortex(bancorVortexAddress);

        // Burn it
        bancorVortex.burn(burnTokens);
        
        uint256 bntBalanceAfterBurn = bntToken.balanceOf(address(this));
        if (minBntAmountAfterBurn != 0)
        {
            require (bntBalanceAfterBurn >= minBntAmountAfterBurn);
        }

        return bntBalanceAfterBurn;
    }
}

{
  "compilationTarget": {
    "burnHelperWithRevertProtection.sol": "BurnBot"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 2000
  },
  "remappings": []
}