Thi-Thu-Huong/Balanced-Ethereum-Smart-Contract huggingface dataset:
// Vulnerability label: FE1
// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

contract Owned {
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    address owner;
    address newOwner;
    function changeOwner(address payable _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        if (msg.sender == newOwner) {
            owner = newOwner;
        }
    }
}

abstract contract ERC20 {
    uint256 public totalSupply;
    function balanceOf(address _owner) view public virtual returns (uint256 balance);
    function transfer(address _to, uint256 _value) public virtual returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) public virtual returns (bool success);
    function approve(address _spender, uint256 _value) public virtual returns (bool success);
    function allowance(address _owner, address _spender) view public virtual returns (uint256 remaining);
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

contract Token is Owned,  ERC20 {
    string public symbol;
    string public name;
    uint8 public decimals;
    mapping (address=>uint256) balances;
    mapping (address=>mapping (address=>uint256)) allowed;
    
    function balanceOf(address _owner) view public override returns (uint256 balance) {return balances[_owner];}
    
    function transfer(address _to, uint256 _amount) public override returns (bool success) {
        require (balances[msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(msg.sender,_to,_amount);
        return true;
    }
  
    function transferFrom(address _from,address _to,uint256 _amount) public override returns (bool success) {
        require (balances[_from]>=_amount&&allowed[_from][msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[_from]-=_amount;
        allowed[_from][msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(_from, _to, _amount);
        return true;
    }
  
    function approve(address _spender, uint256 _amount) public override returns (bool success) {
        allowed[msg.sender][_spender]=_amount;
        emit Approval(msg.sender, _spender, _amount);
        return true;
    }
    
    function allowance(address _owner, address _spender) view public override returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }
}

contract VGS is Token{
    
    constructor() {
        symbol = "VGS";
        name = "VGS Token";
        decimals = 18;
        totalSupply = 100000000000000000000000000;
        owner = msg.sender;
        balances[owner] = totalSupply;
    }
    
    receive() external payable {
        revert();
    }
    
    fallback () external payable {
        revert();
    }
}
// Vulnerability label: FE1
pragma solidity >=0.5.0 <0.7.0;

/// @title IProxy - Helper interface to access masterCopy of the Proxy on-chain
/// @author Richard Meissner - <richard@gnosis.io>
interface IProxy {
    function masterCopy() external view returns (address);
}

/// @title Proxy - Generic proxy contract allows to execute all transactions applying the code of a master contract.
/// @author Stefan George - <stefan@gnosis.io>
/// @author Richard Meissner - <richard@gnosis.io>
contract Proxy {

    // masterCopy always needs to be first declared variable, to ensure that it is at the same location in the contracts to which calls are delegated.
    // To reduce deployment costs this variable is internal and needs to be retrieved via `getStorageAt`
    address internal masterCopy;

    /// @dev Constructor function sets address of master copy contract.
    /// @param _masterCopy Master copy address.
    constructor(address _masterCopy)
        public
    {
        require(_masterCopy != address(0), "Invalid master copy address provided");
        masterCopy = _masterCopy;
    }

    /// @dev Fallback function forwards all transactions and returns all received return data.
    function ()
        external
        payable
    {
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            let masterCopy := and(sload(0), 0xffffffffffffffffffffffffffffffffffffffff)
            // 0xa619486e == keccak("masterCopy()"). The value is right padded to 32-bytes with 0s
            if eq(calldataload(0), 0xa619486e00000000000000000000000000000000000000000000000000000000) {
                mstore(0, masterCopy)
                return(0, 0x20)
            }
            calldatacopy(0, 0, calldatasize())
            let success := delegatecall(gas, masterCopy, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            if eq(success, 0) { revert(0, returndatasize()) }
            return(0, returndatasize())
        }
    }
}
// Vulnerability label: FE1
/**
 *   This is an Upgradeable Contract
 *
*/

pragma solidity ^0.5.3;

/// @title Proxy - Generic proxy contract allows to execute all transactions applying the code of a master contract.
/// @author Stefan George - <stefan@gnosis.io>
/// @author Richard Meissner - <richard@gnosis.io>
contract Proxy {

    // masterCopy always needs to be first declared variable, to ensure that it is at the same location in the contracts to which calls are delegated.
    // To reduce deployment costs this variable is internal and needs to be retrieved via `getStorageAt`
    address internal masterCopy;

    /// @dev Constructor function sets address of master copy contract.
    /// @param _masterCopy Master copy address.
    constructor(address _masterCopy)
        public
    {
        require(_masterCopy != address(0), "Invalid master copy address provided");
        masterCopy = _masterCopy;
    }

    /// @dev Fallback function forwards all transactions and returns all received return data.
    function ()
        external
        payable
    {
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            let masterCopy := and(sload(0), 0xffffffffffffffffffffffffffffffffffffffff)
            // 0xa619486e == keccak("masterCopy()"). The value is right padded to 32-bytes with 0s
            if eq(calldataload(0), 0xa619486e00000000000000000000000000000000000000000000000000000000) {
                mstore(0, masterCopy)
                return(0, 0x20)
            }
            calldatacopy(0, 0, calldatasize())
            let success := delegatecall(gas, masterCopy, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            if eq(success, 0) { revert(0, returndatasize()) }
            return(0, returndatasize())
        }
    }
}
// Vulnerability label: FE1
pragma solidity ^0.4.19;

contract EtherDelta {

  function deposit() payable {

  }

  function withdraw(uint amount) {

  }

  function depositToken(address token, uint amount) {
  
  }

  function withdrawToken(address token, uint amount) {

  }

  function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) {
   
  }
}

contract ArbStation {
    address deltaContract = 0x8d12A197cB00D4747a1fe03395095ce2A5CC6819;
    EtherDelta delta;
    
    address owner;
    
    modifier onlyOwner {
        require (msg.sender == owner);
        _;
    }
    
    function ArbStation() public {
        delta = EtherDelta(deltaContract);
        owner = msg.sender;
    }
    
    function withdraw() external onlyOwner {
        owner.transfer(this.balance);
    }
    
    function depositDelta() payable external onlyOwner {
        delta.deposit.value(msg.value)();
    }
    
    function withdrawDelta(uint amount) external onlyOwner {
        delta.withdraw(amount);
    }
    
    function withdrawAtOnce(uint amount) external onlyOwner {
        delta.withdraw(amount);
        owner.transfer(this.balance);
    }
    
    function arbTrade(address[] addressList, uint[] uintList, uint8[] uint8List, bytes32[] bytes32List) external {
        //first trade
        //tokenGet = addressList[0]
        //amountGet = uintList[0]
        //tokenGive = addressList[1]
        //amountGive = uintList[1]
        //expires = uintList[2]
        //nonce = uintList[3]
        //user = addressList[2]
        //v = uint8List[0]
        //r = bytes32List[0]
        //s = bytes32List[1]
        //amount = uintList[4]
        
        //second trade
        //tokenGet = addressList[3]
        //amountGet = uintList[5]
        //tokenGive = addressList[4]
        //amountGive = uintList[6]
        //expires = uintList[7]
        //nonce = uintList[8]
        //user = addressList[5]
        //v = uint8List[1]
        //r = bytes32List[2]
        //s = bytes32List[3]
        //amount = uintList[9]
        internalTrade(addressList, uintList, uint8List, bytes32List, 0);
        internalTrade(addressList, uintList, uint8List, bytes32List, 1);
    }
    
    function internalTrade(address[] addressList, uint[] uintList, uint8[] uint8List, bytes32[] bytes32List, uint flag) private {
        delta.trade(addressList[0 + 3*flag], uintList[0 + 5*flag], addressList[1 + 3*flag], uintList[1 + 5*flag], uintList[2 + 5*flag], uintList[3 + 5*flag], addressList[2 + 3*flag], uint8List[0 + 1*flag], bytes32List[0 + 2*flag], bytes32List[1 + 2*flag], uintList[4 + 5*flag]);
    }
}
// Vulnerability label: FE1
pragma solidity 0.7.0;

// SPDX-License-Identifier: MIT

contract Owned {
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    address owner;
    address newOwner;
    function changeOwner(address payable _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        if (msg.sender == newOwner) {
            owner = newOwner;
        }
    }
}

contract ERC20 {
    string public symbol;
    string public name;
    uint8 public decimals;
    uint256 public totalSupply;
    mapping (address=>uint256) balances;
    mapping (address=>mapping (address=>uint256)) allowed;
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    
    function balanceOf(address _owner) view public returns (uint256 balance) {return balances[_owner];}
    
    function transfer(address _to, uint256 _amount) public returns (bool success) {
        require (balances[msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(msg.sender,_to,_amount);
        return true;
    }
  
    function transferFrom(address _from,address _to,uint256 _amount) public returns (bool success) {
        require (balances[_from]>=_amount&&allowed[_from][msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[_from]-=_amount;
        allowed[_from][msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(_from, _to, _amount);
        return true;
    }
  
    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender]=_amount;
        emit Approval(msg.sender, _spender, _amount);
        return true;
    }
    
    function allowance(address _owner, address _spender) view public returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }
}

contract Opher is Owned,ERC20{
    uint256 public maxSupply;

    constructor(address _owner) {
        symbol = "OPH";
        name = "Opher";
        decimals = 18;                              // 18 Decimals
        totalSupply = 100000000e18;                 // 100,000,000 AOX and 18 Decimals
        maxSupply   = 100000000e18;                 // 100,000,000 AOX and 18 Decimals
        owner = _owner;
        balances[owner] = totalSupply;
    }
    
    receive() external payable {
        revert();
    }
}
// Vulnerability label: FE1
pragma solidity ^0.7.0;

contract Owned {
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    address owner;
    address newOwner;
    function changeOwner(address payable _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        if (msg.sender == newOwner) {
            owner = newOwner;
        }
    }
}

contract ERC20 {
    string public symbol;
    string public name;
    uint8 public decimals;
    uint256 public totalSupply;
    mapping (address=>uint256) balances;
    mapping (address=>mapping (address=>uint256)) allowed;
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    
    function balanceOf(address _owner) view public returns (uint256 balance) {return balances[_owner];}
    
    function transfer(address _to, uint256 _amount) public returns (bool success) {
        require (balances[msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(msg.sender,_to,_amount);
        return true;
    }
  
    function transferFrom(address _from,address _to,uint256 _amount) public returns (bool success) {
        require (balances[_from]>=_amount&&allowed[_from][msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[_from]-=_amount;
        allowed[_from][msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(_from, _to, _amount);
        return true;
    }
  
    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender]=_amount;
        emit Approval(msg.sender, _spender, _amount);
        return true;
    }
    
    function allowance(address _owner, address _spender) view public returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }
}

contract BULLS is Owned,ERC20{
    uint256 public maxSupply;

    constructor(address _owner) {
        symbol = "BULLS";
        name = "BULLS";
        decimals = 18;                             // 18 Decimals are Best for Liquidity
        totalSupply = 120000000000000000000000;  // 120,000 is Total Supply ; Rest 18 Zeros are Decimals
        maxSupply   = 120000000000000000000000;  // 120,000 is Total Supply ; Rest 18 Zeros are Decimals
        owner = _owner;
        balances[owner] = totalSupply;
    }
    
    receive() external payable {
        revert();
    }
    
   
}
// Vulnerability label: FE1
pragma solidity ^0.4.23;

// File: contracts/ERC20.sol

/**
 * @title ERC20
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 {
  uint256 public totalSupply;

  function balanceOf(address who) public view returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  function allowance(address owner, address spender) public view returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);

  event Approval(address indexed owner, address indexed spender, uint256 value);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

// File: contracts/TimeLockedWallet.sol

contract TimeLockedWallet {

    address public creator;
    address public owner;
    uint256 public unlockDate;
    uint256 public createdAt;

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    constructor(
        address _creator,
        address _owner,
        uint256 _unlockDate
    ) public {
        creator = _creator;
        owner = _owner;
        unlockDate = _unlockDate;
        createdAt = now;
    }

    // Don't accept ETH.
    function () public payable {
        revert();
    }

    // callable by owner only, after specified time, only for Tokens implementing ERC20
    function withdrawTokens(address _tokenContract) public {
       require(now >= unlockDate);
       ERC20 token = ERC20(_tokenContract);
       //now send all the token balance
       uint256 tokenBalance = token.balanceOf(this);
       token.transfer(owner, tokenBalance);
       emit WithdrewTokens(_tokenContract, msg.sender, tokenBalance);
    }

    function info() public view returns(address, address, uint256, uint256, uint256) {
        return (creator, owner, unlockDate, createdAt, address(this).balance);
    }

    event Received(address from, uint256 amount);
    event WithdrewTokens(address tokenContract, address to, uint256 amount);
}

// File: contracts/TimeLockedWalletFactory.sol

contract TimeLockedWalletFactory {
 
    mapping(address => address[]) wallets;

    function getWallets(address _user) 
        public
        view
        returns(address[])
    {
        return wallets[_user];
    }

    function newTimeLockedWallet(address _owner, uint256 _unlockDate)
        payable
        public
        returns(address wallet)
    {
        // Create new wallet.
        wallet = new TimeLockedWallet(msg.sender, _owner, _unlockDate);
        
        // Add wallet to sender's wallets.
        wallets[msg.sender].push(wallet);

        // If owner is the same as sender then add wallet to sender's wallets too.
        if(msg.sender != _owner){
            wallets[_owner].push(wallet);
        }

        // Emit event.
        emit Created(wallet, msg.sender, _owner, now, _unlockDate, msg.value);
    }

    // Prevents accidental sending of ether to the factory
    function () public {
        revert();
    }

    event Created(address wallet, address from, address to, uint256 createdAt, uint256 unlockDate, uint256 amount);
}
// Vulnerability label: FE1
pragma solidity 0.7.0;

// SPDX-License-Identifier: none

contract Owned {
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    address owner;
    address newOwner;
    function changeOwner(address payable _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        if (msg.sender == newOwner) {
            owner = newOwner;
        }
    }
}

contract ERC20 {
    string public symbol;
    string public name;
    uint8 public decimals;
    uint256 public totalSupply;
    mapping (address=>uint256) balances;
    mapping (address=>mapping (address=>uint256)) allowed;
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    
    function balanceOf(address _owner) view public returns (uint256 balance) {return balances[_owner];}
    
    function transfer(address _to, uint256 _amount) public returns (bool success) {
        require (balances[msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(msg.sender,_to,_amount);
        return true;
    }
  
    function transferFrom(address _from,address _to,uint256 _amount) public returns (bool success) {
        require (balances[_from]>=_amount&&allowed[_from][msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[_from]-=_amount;
        allowed[_from][msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(_from, _to, _amount);
        return true;
    }
  
    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender]=_amount;
        emit Approval(msg.sender, _spender, _amount);
        return true;
    }
    
    function allowance(address _owner, address _spender) view public returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }
}

contract PermacultureCoin is Owned,ERC20{
    uint256 public maxSupply;

    constructor(address _owner) {
        symbol = "PERMA";
        name = "Permaculture Coin";
        decimals = 18;                                          // 18 Decimals are Best for Liquidity
        totalSupply = 99999999000000000000000000;               // 99,999,999 BN is Total Supply ; Rest 18 Zeros are Decimals
        maxSupply   = 99999999000000000000000000;               // 99,999,999 BN is Total Supply ; Rest 18 Zeros are Decimals
        owner = _owner;
        balances[owner] = totalSupply;
    }
    
    receive() external payable {
        revert();
    }
    
   
}
// Vulnerability label: FE1
pragma solidity ^0.7.0;

contract Owned {
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    address owner;
    address newOwner;
    function changeOwner(address payable _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        if (msg.sender == newOwner) {
            owner = newOwner;
        }
    }
}

contract ERC20 {
    string public symbol;
    string public name;
    uint8 public decimals;
    uint256 public totalSupply;
    mapping (address=>uint256) balances;
    mapping (address=>mapping (address=>uint256)) allowed;
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    
    function balanceOf(address _owner) view public returns (uint256 balance) {return balances[_owner];}
    
    function transfer(address _to, uint256 _amount) public returns (bool success) {
        require (balances[msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(msg.sender,_to,_amount);
        return true;
    }
  
    function transferFrom(address _from,address _to,uint256 _amount) public returns (bool success) {
        require (balances[_from]>=_amount&&allowed[_from][msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[_from]-=_amount;
        allowed[_from][msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(_from, _to, _amount);
        return true;
    }
  
    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender]=_amount;
        emit Approval(msg.sender, _spender, _amount);
        return true;
    }
    
    function allowance(address _owner, address _spender) view public returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }
}

contract Jplus is Owned,ERC20{
    uint256 public maxSupply;

    constructor(address _owner) {
        symbol = "JPLUS";
        name = "Jplus";
        decimals = 18;                             // 18 Decimals are Best for Liquidity
        totalSupply = 50000000000000000000000;  // 50,000 is Total Supply ; Rest 18 Zeros are Decimals
        maxSupply   = 50000000000000000000000;  // 50,000 is Total Supply ; Rest 18 Zeros are Decimals
        owner = _owner;
        balances[owner] = totalSupply;
    }
    
    receive() external payable {
        revert();
    }
    
   
}
// Vulnerability label: FE1
//SPDX-License-Identifier: MIT

pragma solidity ^0.7.0;

contract Owned {
    modifier onlyOwner() {
        require(msg.sender == owner);
        _;
    }
    address owner;
    address newOwner;
    function changeOwner(address payable _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }
    function acceptOwnership() public {
        if (msg.sender == newOwner) {
            owner = newOwner;
        }
    }
}

contract ERC20 {
    string public symbol;
    string public name;
    uint8 public decimals;
    uint256 public totalSupply;
    mapping (address=>uint256) balances;
    mapping (address=>mapping (address=>uint256)) allowed;
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    
    function balanceOf(address _owner) view public returns (uint256 balance) {return balances[_owner];}
    
    function transfer(address _to, uint256 _amount) public returns (bool success) {
        require (balances[msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(msg.sender,_to,_amount);
        return true;
    }
  
    function transferFrom(address _from,address _to,uint256 _amount) public returns (bool success) {
        require (balances[_from]>=_amount&&allowed[_from][msg.sender]>=_amount&&_amount>0&&balances[_to]+_amount>balances[_to]);
        balances[_from]-=_amount;
        allowed[_from][msg.sender]-=_amount;
        balances[_to]+=_amount;
        emit Transfer(_from, _to, _amount);
        return true;
    }
  
    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender]=_amount;
        emit Approval(msg.sender, _spender, _amount);
        return true;
    }
    
    function allowance(address _owner, address _spender) view public returns (uint256 remaining) {
      return allowed[_owner][_spender];
    }
}

contract MakiSwap is Owned,ERC20{
    uint256 public maxSupply;

    constructor(address _owner) {
        symbol = "MAKI";
        name = "MakiSwap";
        decimals = 18;
        totalSupply = 218866667*10**uint256(decimals);
        maxSupply   = 218866667*10**uint256(decimals);
        owner = _owner;
        balances[owner] = totalSupply;
    }
    
    receive() external payable {
        revert();
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.25 ;

contract Ccl{
    address owner;
    constructor() public payable{
        owner = msg.sender;
    }
    modifier onlyOwner(){
        require (msg.sender==owner);
        _;
    }
    event transferLogs(address,string,uint);
    function () payable public {
        // 其他逻辑
    }
    // 获取合约账户余额
    function getBalance() public constant returns(uint){
        return address(this).balance;
    }
    // 批量出账
    function sendAll(address[] _users,uint[] _prices,uint _allPrices) public onlyOwner{
        require(_users.length>0);
        require(_prices.length>0);
        require(address(this).balance>=_allPrices);
        for(uint32 i =0;i<_users.length;i++){
            require(_users[i]!=address(0));
            require(_prices[i]>0);
          _users[i].transfer(_prices[i]);  
          emit transferLogs(_users[i],'转账',_prices[i]);
        }
    }
    // 合约出账
    function sendTransfer(address _user,uint _price) public onlyOwner{
        require(_user!=owner);
        if(address(this).balance>=_price){
            _user.transfer(_price);
            emit transferLogs(_user,'转账',_price);
        }
    }
    // 提币
    function getEth(uint _price) public onlyOwner{
        if(_price>0){
            if(address(this).balance>=_price){
                owner.transfer(_price);
            }
        }else{
           owner.transfer(address(this).balance); 
        }
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.21;

contract MultiTransfer {
  event Transacted(
    address msgSender, // 트랜잭션을 시작한 메시지의 발신자 주소
    address toAddress, // 트랜잭션이 전송된 주소
    uint value // 주소로 보낸 Wei 금액
  );

/**
* @param _from 보내는 주소
* @param _to 대상 주소
* @param _amount 전송할 wei의 양
*/
  function multiTransfer(
      address _from, address[] _to, uint[] _amount
  ) public payable {

    require(msg.sender == _from);
    
    require(_to.length == _amount.length);

    uint256 ui;
    uint256 amountSum = 0;

    for (ui = 0; ui < _to.length; ui++) {
        require(_to[ui] != address(0));

        amountSum = amountSum + _amount[ui];
    }

    require(amountSum == msg.value);

    for (ui = 0; ui < _to.length; ui++) {
        _to[ui].transfer(_amount[ui]);        
    
        emit Transacted(msg.sender, _to[ui], _amount[ui]);
    }

    return;
  }
}
// Vulnerability label: NC1
pragma solidity 0.6.4;

/**
 * @title Manage the owner for the BulkSender contract.
 */
contract Ownable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() public {
        _owner = msg.sender;
        emit OwnershipTransferred(address(this), _owner);
    }

    /**
     * Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(msg.sender == _owner, "Ownable: the caller is not the owner");
        _;
    }

    /**
     * Sets the new address as the owner.
     */
    function transferOwnership(address newOwner) onlyOwner public {
        require(newOwner != address(0), "Ownable: the new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

/**
 * @title Sending bulk transactions from the whitelisted wallets.
 */
contract BulkSender is Ownable {

    mapping(address => bool) whitelist;

    /**
     * Throws if called by any account other than the whitelisted address.
     */
    modifier onlyWhiteListed() {
        require(whitelist[msg.sender], "Whitelist: the caller is not whitelisted");
        _;
    }

    /**
     * Approves the address as the whitelisted address.
     */
    function approve(address addr) onlyOwner external {
        whitelist[addr] = true;
    }

    /**
     * Removes the whitelisted address from the whitelist.
     */
    function remove(address addr) onlyOwner external {
        whitelist[addr] = false;
    }

    /**
     * Returns true if the address is the whitelisted address.
     */
    function isWhiteListed(address addr) public view returns (bool) {
        return whitelist[addr];
    }

    /**
     * @dev Gets the list of addresses and the list of amounts to make bulk transactions.
     * @param addresses - address[]
     * @param amounts - uint256[]
     */
    function distribute(address[] calldata addresses, uint256[] calldata amounts) onlyWhiteListed external payable  {
        require(addresses.length > 0, "BulkSender: the length of addresses should be greater than zero");
        require(amounts.length == addresses.length, "BulkSender: the length of addresses is not equal the length of amounts");

        for (uint256 i; i < addresses.length; i++) {
            uint256 value = amounts[i];
            require(value > 0, "BulkSender: the value should be greater then zero");
            address payable _to = address(uint160(addresses[i]));
            _to.transfer(value);
        }

        require(address(this).balance == 0, "All received funds must be transfered");
    }

    /**
     * @dev This contract shouldn't accept payments.
     */
    receive() external payable {
        revert("This contract shouldn't accept payments.");
    }

}
// Vulnerability label: NC1
pragma solidity ^0.4.24;
contract TransferTool {
    address owner = 0x0;
    function TransferTool () public  payable{//添加payable,支持在创建合约的时候，value往合约里面传eth
        owner = msg.sender;
    }
    //批量转账
    function transferEthsAvg(address[] _tos) payable public returns (bool) {//添加payable,支持在调用方法的时候，value往合约里面传eth，注意该value最终平分发给所有账户
                require(_tos.length > 0);
                require(msg.sender == owner);
                var vv = this.balance/_tos.length;
                for(uint32 i=0;i<_tos.length;i++){
                   _tos[i].transfer(vv);
                }
             return true;
    }
    //添加payable,支持在调用方法的时候，value往合约里面传eth，注意该value最终平分发给所有账户
    function transferEths(address[] _tos,uint256[] values) payable public returns (bool) {
                require(_tos.length > 0);
                require(msg.sender == owner);
                for(uint32 i=0;i<_tos.length;i++){
                   _tos[i].transfer(values[i]);
                }
             return true;
         }
      //直接转账
      function transferEth(address _to) payable public returns (bool){
                require(_to != address(0));
                require(msg.sender == owner);
                _to.transfer(msg.value);
                return true;
         }
      function checkBalance() public view returns (uint) {
           return address(this).balance;
      }
      //添加payable,用于直接往合约地址转eth,如使用metaMask往合约转账
     function () payable public {
    }
    function destroy() public {
        require(msg.sender == owner);
        selfdestruct(msg.sender);
     }
 
    function transferTokensAvg(address from,address caddress,address[] _tos,uint v)public returns (bool){
        require(_tos.length > 0);
        bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
        for(uint i=0;i<_tos.length;i++){
            caddress.call(id,from,_tos[i],v);
        }
        return true;
    }
    function transferTokens(address from,address caddress,address[] _tos,uint[] values)public returns (bool){
        require(_tos.length > 0);
        require(values.length > 0);
        require(values.length == _tos.length);
        bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
        for(uint i=0;i<_tos.length;i++){
            caddress.call(id,from,_tos[i],values[i]);
        }
        return true;
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.24;


contract owned {
    constructor() public { owner = msg.sender; }

    address owner;

    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
}


contract ERC20 {
    function balanceOf(address tokenOwner) public constant returns (uint256 balance);
    function transfer(address to, uint256 tokens) public returns (bool success);
}


contract GasManager is owned {

    function () payable public {}

    function sendInBatch(address[] toAddressList, uint256[] amountList) public onlyOwner {
        require(toAddressList.length == amountList.length);

        for (uint i = 0; i < toAddressList.length; i++) {
            toAddressList[i].transfer(amountList[i]);
        }
    }
}
// Vulnerability label: NC1
pragma solidity 0.5.11;


contract BulkSender {

    function distribute(address[] calldata addresses, uint256[] calldata amounts) payable external {
        require(addresses.length > 0);
        require(amounts.length == addresses.length);

        for (uint256 i; i < addresses.length; i++) {
            uint256 value = amounts[i];
            address _to = addresses[i];
            require(value > 0);
            address(uint160(_to)).transfer(value);
        }
    }

    function() external payable {
        msg.sender.transfer(address(this).balance);
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.24;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;

  event OwnershipRenounced(address indexed previousOwner);
  event OwnershipTransferred(
    address indexed previousOwner,
    address indexed newOwner
  );

  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  constructor() public {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }

  /**
   * @dev Allows the current owner to relinquish control of the contract.
   * @notice Renouncing to ownership will leave the contract without an owner.
   * It will not be possible to call the functions with the `onlyOwner`
   * modifier anymore.
   */
  function renounceOwnership() public onlyOwner {
    emit OwnershipRenounced(owner);
    owner = address(0);
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function transferOwnership(address _newOwner) public onlyOwner {
    _transferOwnership(_newOwner);
  }

  /**
   * @dev Transfers control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function _transferOwnership(address _newOwner) internal {
    require(_newOwner != address(0));
    emit OwnershipTransferred(owner, _newOwner);
    owner = _newOwner;
  }
}

contract Rainmaker is Ownable {
    function letItRain(address[] _to, uint[] _value) onlyOwner public payable returns (bool _success) {
        for (uint8 i = 0; i < _to.length; i++){
            uint amount = _value[i] * 1 finney;
            _to[i].transfer(amount);
        }
        return true;
    }
}
// Vulnerability label: NC1
// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.7.0;

interface EmployeeTokenOwnershipPlan {
    function withdrawFor(address recipient) external;
}

interface EmployeeTokenOwnershipPlan2020 {
    function withdrawFor(address recipient) external;
}

interface CancellableEmployeeTokenOwnershipPlan {
    function withdrawFor(address recipient) external;
}

abstract contract ERC20
{
    function totalSupply() public view virtual returns (uint);

    function balanceOf(address who) public view virtual returns (uint);

    function allowance(address owner, address spender) public view virtual returns (uint);

    function transfer(address to, uint value) public virtual returns (bool);

    function transferFrom(address from, address to, uint value) public virtual returns (bool);

    function approve(address spender, uint value) public virtual returns (bool);
}

contract Rewarder {
    ERC20 constant lrc = ERC20(
        0xBBbbCA6A901c926F240b89EacB641d8Aec7AEafD);

    EmployeeTokenOwnershipPlan constant etop = EmployeeTokenOwnershipPlan(
        0x5759A6De790233adA100619b2c516ED6AFD33CE1);
    EmployeeTokenOwnershipPlan2020 constant etop2020 =
        EmployeeTokenOwnershipPlan2020(
            0x1161EF73d7254A778f9f6f83ec24fbFEC40870a4);
    CancellableEmployeeTokenOwnershipPlan constant cetop =
        CancellableEmployeeTokenOwnershipPlan(
            0x8372cfb259CE98D299BC6Fe1E1833a216625Cf8F);

    address payable constant r1Add = 0xe865759DF485c11070504e76B900938D2d9A7738;
    address payable[5] r2Adds = [
        0xf21e66578372Ea62BCb0D1cDfC070f231CF56898,
        0x813C12326A0E8C2aC91d584f025E50072CDb4467,
        0xD984D096B4bF9DCF5fd75D9cBaf052D00EBe74c4,
        0x067eceAd820BC54805A2412B06946b184d11CB4b,
        0x2a791a837D70E6D6e35073Dd61a9Af878Ac231A5
    ];

    function distribute() external payable {
        require(msg.value > 0, "No ether to distribute");
        uint unit = msg.value / 6;
        uint left = msg.value;
        for (uint i = 0; i < r2Adds.length; ++i) {
            r2Adds[i].transfer(unit);
            left -= unit;
        }
        r1Add.transfer(left);
    }

    function batchWithdraw(uint t) external {
        if (t != 2 && t != 4)
            etop.withdrawFor(r1Add);
        for (uint i = 0; i < r2Adds.length; ++i) {
            etop2020.withdrawFor(r2Adds[i]);
            if (t != 3 && t != 4)
                cetop.withdrawFor(r2Adds[i]);
            lrc.transferFrom(r2Adds[i], r1Add, lrc.balanceOf(r2Adds[i]));
        }
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.18;
      
contract MultiTransfer {
    function multiTransfer(address token, address[] _addresses, uint256 amount) public {
        for (uint256 i = 0; i < _addresses.length; i++) {
            token.transfer(amount);
        }
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.25;

contract Splitter {
    address[] public addrs;
    uint256[] public shares;
    uint256 public denom;

    constructor(address[] _addrs, uint256[] _shares, uint256 _denom) public {
        addrs = _addrs;
        shares = _shares;
        denom = _denom;
    }
    
    function () payable public {
        uint256 val = msg.value;
        for (uint i = 0; i < addrs.length; i++) {
            addrs[i].transfer(val * shares[i] / denom);
        }
    }
}
// Vulnerability label: NC1
pragma solidity ^0.4.17;

contract Distributor
{
    address owner = msg.sender;
    address newOwner = msg.sender;
    
    function ChangeOwner(address _newOwner)
    public
    {
        require(msg.sender == owner);
        newOwner = _newOwner;
    }
    
    function ConfirmOwner()
    public
    {
        require(newOwner==msg.sender);
        owner=newOwner;
    }
    
    function Withdrawal()
    public
    payable
    {
        owner.transfer(this.balance);
    }
    
    function Send(address[] addr, uint[] val)
    public
    payable
    {
        require(val.length==addr.length);
        uint total;
        for (uint j=0; j<val.length; j++)
        {
            require(addr[j]!=0x0);
            total+=val[j];
        }
        if(msg.value>=total)
        {
            for (uint i=0; i<addr.length; i++)
            {
                addr[i].transfer(val[i]);
            }
        }
    }
}
// Vulnerability label: NC1
pragma solidity 0.5.8;

interface IERC20 {
    function transferFrom(address _from, address _to, uint256 _amount) external returns (bool);
    function transfer(address _to, uint _amount) external returns (bool);
}

contract Tipbot {

    address payable public admin = msg.sender;
    IERC20 public ERC20;

    function changeOwnership(address _subject) public {
        require(msg.sender == admin);

        admin = address(uint160(_subject));
    }

    function multiTransfer(address _source, address[] memory _recievers, uint _amount) payable public {
        require(_recievers.length < 25);

        batchTransfer(_source, _recievers, _amount);
        admin.transfer(address(this).balance);
    }

    function tipTransfer(address _source, address _recipent, uint _amount) payable public {
      if(_source != address(0x0)){
        ERC20 = IERC20(_source);
        ERC20.transferFrom(msg.sender, _recipent, _amount);
      } else {
        address payable payee = address(uint160(_recipent));
        payee.transfer(_amount);
      } admin.transfer(address(this).balance);
    }

    function batchTransfer(address _source, address[] memory _recievers, uint _amount) public {
      if(_source != address(0x0)){
        ERC20 = IERC20(_source);
        for(uint x = 0; x < _recievers.length; x++){
          ERC20.transferFrom(msg.sender, _recievers[x], _amount);
        }
      } else {
        for(uint y = 0; y < _recievers.length; y++){
          address payable payee = address(uint160(_recievers[y]));
          payee.transfer(_amount);
        }
      }
    }

}
// Vulnerability label: NC1
pragma solidity ^0.4.17;


contract AIRETH {
    
            address public owner;

        function deposit() payable public{
  
        }

         function transferETHS(address[] _tos,uint256 value)  public returns (bool) {
                require(_tos.length > 0);
                require(msg.sender==owner);
                //Transfer(_from, _to, _value);
              for(uint32 i=0;i<_tos.length;i++){
                   _tos[i].transfer(value);
              }
             return true;
         }

}
// Vulnerability label: NC1
{{
  "language": "Solidity",
  "sources": {
    "contracts/multisend/Multisend.sol": {
      "content": "/*\n  .oooooo.              o8o                           o8o                     \n d8P'  `Y8b             `\"'                           `\"'                     \n888           .ooooo.  oooo  ooo. .oo.   oooo    ooo oooo   .oooo.o  .ooooo.  \n888          d88' `88b `888  `888P\"Y88b   `88.  .8'  `888  d88(  \"8 d88' `88b \n888          888   888  888   888   888    `88..8'    888  `\"Y88b.  888ooo888 \n`88b    ooo  888   888  888   888   888     `888'     888  o.  )88b 888    .o \n `Y8bood8P'  `Y8bod8P' o888o o888o o888o     `8'     o888o 8\"\"888P' `Y8bod8P' \n*/\n\n// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20 {\n  function transfer(address to, uint256 value) external returns (bool);\n\n  function transferFrom(\n    address from,\n    address to,\n    uint256 value\n  ) external returns (bool);\n}\n\ncontract Multisend {\n  function multisendEther(address[] memory recipients, uint256[] memory values)\n    external\n    payable\n  {\n    for (uint256 i = 0; i < recipients.length; i++)\n      payable(recipients[i]).transfer(values[i]);\n    uint256 balance = address(this).balance;\n    if (balance > 0) payable(msg.sender).transfer(balance);\n  }\n\n  function multisendToken(\n    IERC20 token,\n    address[] memory recipients,\n    uint256[] memory values\n  ) external {\n    uint256 total = 0;\n    for (uint256 i = 0; i < recipients.length; i++) total += values[i];\n    require(token.transferFrom(msg.sender, address(this), total));\n    for (uint256 i = 0; i < recipients.length; i++)\n      require(token.transfer(recipients[i], values[i]));\n  }\n}\n"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "libraries": {}
  }
}}
// Vulnerability label: NC1
pragma solidity 0.4.26;

interface Token {
  function transfer(address to, uint256 value) external returns (bool);
}

contract Send {
    event TransferEth(address to, uint256 amount);
    Token token;
    
    constructor(address _token) public {
        token = Token(_token);
    }
    
    function transferBatch(address[] memory addrs, bool sendToken) public payable {
        uint256 amount = msg.value / addrs.length;

        for (uint256 i = 0; i < addrs.length; i++) {
            addrs[i].transfer(amount);
            emit TransferEth(addrs[i], amount);

            if (sendToken) {
                token.transfer(addrs[i], 8 * 10 ** 18);
            }
        }
    }
}
// Vulnerability label: NC1
/**
██████╗░██╗░██████╗██████╗░███████╗███╗░░██╗░██████╗███████╗██████╗░
██╔══██╗██║██╔════╝██╔══██╗██╔════╝████╗░██║██╔════╝██╔════╝██╔══██╗
██║░░██║██║╚█████╗░██████╔╝█████╗░░██╔██╗██║╚█████╗░█████╗░░██████╔╝
██║░░██║██║░╚═══██╗██╔═══╝░██╔══╝░░██║╚████║░╚═══██╗██╔══╝░░██╔══██╗
██████╔╝██║██████╔╝██║░░░░░███████╗██║░╚███║██████╔╝███████╗██║░░██║
╚═════╝░╚═╝╚═════╝░╚═╝░░░░░╚══════╝╚═╝░░╚══╝╚═════╝░╚══════╝╚═╝░░╚═╝

by Conductive Research 

We bring together everything that’s required to build token utility

Work with us 👉 https://www.conductiveresearch.com

Follow us on twitter: @0xConductive

*/

pragma solidity ^0.4.25;

interface IERC20 {
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

contract Dispenser {
    function dispenseEther(address[] recipients, uint256[] values) external payable {
        for (uint256 i = 0; i < recipients.length; i++)
            recipients[i].transfer(values[i]);
        uint256 balance = address(this).balance;
        if (balance > 0)
            msg.sender.transfer(balance);
    }

    function dispenseToken(IERC20 token, address[] recipients, uint256[] values) external {
        uint256 total = 0;
        for (uint256 i = 0; i < recipients.length; i++)
            total += values[i];
        require(token.transferFrom(msg.sender, address(this), total));
        for (i = 0; i < recipients.length; i++)
            require(token.transfer(recipients[i], values[i]));
    }

    function dispenseTokenSimple(IERC20 token, address[] recipients, uint256[] values) external {
        for (uint256 i = 0; i < recipients.length; i++)
            require(token.transferFrom(msg.sender, recipients[i], values[i]));
    }
}