Unnamed: 0
int64 1
24.8k
| func
stringlengths 26
42.8k
| target
int64 0
7
| project
stringlengths 9
47
|
|---|---|---|---|
11,060
|
function setReward_TOD4() public payable {
require (!claimed_TOD4);
require(msg.sender == owner_TOD4);
owner_TOD4.transfer(reward_TOD4);
reward_TOD4 = msg.value;
}
| 4
|
buggy_32.sol
|
10,001
|
function burn(uint256 value) public {
_burn(msg.sender, value);
}
| 0
|
buggy_14.sol
|
18,698
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0
|
buggy_32.sol
|
22,511
|
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
|
0x19cf8481ea15427a98ba3cdd6d9e14690011ab10.sol
|
5,697
|
function bug_intou8(uint8 p_intou8) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou8; // overflow bug
}
| 2
|
buggy_43.sol
|
20,955
|
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
| 0
|
buggy_29.sol
|
16,427
|
function claimReward_re_ent11() public {
// ensure there is a reward to give
require(redeemableEther_re_ent11[msg.sender] > 0);
uint transferValue_re_ent11 = redeemableEther_re_ent11[msg.sender];
msg.sender.transfer(transferValue_re_ent11); //bug
redeemableEther_re_ent11[msg.sender] = 0;
}
| 5
|
buggy_35.sol
|
13,278
|
function play_TOD33(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD33 = msg.sender;
}
}
| 4
|
buggy_40.sol
|
8,994
|
function getInstanceType() external view returns (bytes4 instanceType);
| 0
|
buggy_44.sol
|
13,902
|
function getReward_TOD37() payable public{
winner_TOD37.transfer(msg.value);
}
| 4
|
buggy_11.sol
|
13,109
|
function isCreator(address caller) public view returns (bool ok) {
ok = (caller == getCreator());
}
| 0
|
buggy_44.sol
|
12,609
|
function play_TOD33(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD33 = msg.sender;
}
}
| 4
|
buggy_35.sol
|
12,371
|
function getReward_TOD19() payable public{
winner_TOD19.transfer(msg.value);
}
| 4
|
buggy_20.sol
|
22,473
|
function bug_unchk_send5() payable public{
msg.sender.transfer(1 ether);}
| 7
|
buggy_22.sol
|
8,811
|
function allowance(address tokenOwner, address spender) view public returns(uint){
return allowed[tokenOwner][spender];
}
| 0
|
buggy_47.sol
|
23,494
|
function bug_unchk_send8() payable public{
msg.sender.transfer(1 ether);}
| 7
|
buggy_40.sol
|
521
|
function transferTo_txorigin27(address to, uint amount,address owner_txorigin27) public {
require(tx.origin == owner_txorigin27);
to.call.value(amount);
}
| 1
|
buggy_18.sol
|
19,168
|
function bug_tmstmp12 () public payable {
uint pastBlockTime_tmstmp12; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp12); // only 1 transaction per block //bug
pastBlockTime_tmstmp12 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
| 6
|
buggy_36.sol
|
1,888
|
function withdrawAll_txorigin38(address payable _recipient,address owner_txorigin38) public {
require(tx.origin == owner_txorigin38);
_recipient.transfer(address(this).balance);
}
| 1
|
buggy_50.sol
|
5,050
|
function increaseLockTime_intou1(uint _secondsToIncrease) public {
lockTime_intou1[msg.sender] += _secondsToIncrease; //overflow
}
| 2
|
buggy_35.sol
|
19,223
|
function play_tmstmp31(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp31 = msg.sender;}}
| 6
|
buggy_22.sol
|
12,418
|
function claimReward_TOD26(uint256 submission) public {
require (!claimed_TOD26);
require(submission < 10);
msg.sender.transfer(reward_TOD26);
claimed_TOD26 = true;
}
| 4
|
buggy_20.sol
|
22,255
|
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
| 0
|
buggy_23.sol
|
19,016
|
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
| 0
|
buggy_23.sol
|
15,964
|
function withdrawFunds_re_ent17 (uint256 _weiToWithdraw) public {
require(balances_re_ent17[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
(bool success,)=msg.sender.call.value(_weiToWithdraw)("");
require(success); //bug
balances_re_ent17[msg.sender] -= _weiToWithdraw;
}
| 5
|
buggy_36.sol
|
2,192
|
function getCreator() public view returns (address creator) {
// iFactory(...) would revert if _factory address is not actually a factory contract
creator = iFactory(_factory).getInstanceCreator(address(this));
}
| 0
|
buggy_43.sol
|
10,708
|
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = msg.sender;
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
| 0
|
buggy_30.sol
|
3,777
|
function bug_intou32(uint8 p_intou32) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou32; // overflow bug
}
| 2
|
buggy_3.sol
|
6,327
|
function increaseLockTime_intou1(uint _secondsToIncrease) public {
lockTime_intou1[msg.sender] += _secondsToIncrease; //overflow
}
| 2
|
buggy_12.sol
|
22,619
|
function isMaster() public view returns (bool)
{
return msg.sender == _master;
}
| 0
|
buggy_7.sol
|
21,555
|
function renounceMinter() public {
_removeMinter(msg.sender);
}
| 0
|
buggy_30.sol
|
12,706
|
function setReward_TOD40() public payable {
require (!claimed_TOD40);
require(msg.sender == owner_TOD40);
owner_TOD40.transfer(reward_TOD40);
reward_TOD40 = msg.value;
}
| 4
|
buggy_4.sol
|
12,626
|
function changeFeeAccount(address feeAccount_) public onlyOwner {
feeAccount = feeAccount_;
}
| 0
|
buggy_35.sol
|
2,980
|
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
| 0
|
buggy_14.sol
|
22,345
|
function EtherGet() {
owner = msg.sender;
}
| 0
|
0x52d2e0f9b01101a59b38a3d05c80b7618aeed984.sol
|
20,755
|
contract Grand is ERC223Token, Owned {
address winner_tmstmp34;
function play_tmstmp34(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp34 = msg.sender;}}
string public constant name = "Grand Coin";
function bug_tmstmp21() view public returns (bool) {
return block.timestamp >= 1546300800;
}
string public constant symbol = "GRAND";
address winner_tmstmp10;
function play_tmstmp10(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp10 = msg.sender;}}
uint8 public constant decimals = 18;
uint256 public tokenRemained = 2 * (10 ** 9) * (10 ** uint(decimals)); // 2 billion Grand, decimals set to 18
uint256 public totalSupply = 2 * (10 ** 9) * (10 ** uint(decimals));
address winner_tmstmp22;
function play_tmstmp22(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp22 = msg.sender;}}
bool public pause = false;
function bug_tmstmp12 () public payable {
uint pastBlockTime_tmstmp12; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp12); // only 1 transaction per block //bug
pastBlockTime_tmstmp12 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
mapping(address => bool) lockAddresses;
// constructor
constructor () public {
//allocate to ______
balances[0x96F7F180C6B53e9313Dc26589739FDC8200a699f] = totalSupply;
}
address winner_tmstmp7;
function play_tmstmp7(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp7 = msg.sender;}}
// change the contract owner
function changeOwner(address _new) public onlyOwner {
require(_new != address(0));
owner = _new;
}
address winner_tmstmp23;
function play_tmstmp23(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp23 = msg.sender;}}
// pause all the g on the contract
function pauseContract() public onlyOwner {
pause = true;
}
address winner_tmstmp14;
function play_tmstmp14(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp14 = msg.sender;}}
function resumeContract() public onlyOwner {
pause = false;
}
address winner_tmstmp30;
function play_tmstmp30(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp30 = msg.sender;}}
function is_contract_paused() public view returns (bool) {
return pause;
}
function bug_tmstmp8 () public payable {
uint pastBlockTime_tmstmp8; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp8); // only 1 transaction per block //bug
pastBlockTime_tmstmp8 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
// lock one's wallet
function lock(address _addr) public onlyOwner {
lockAddresses[_addr] = true;
}
address winner_tmstmp39;
function play_tmstmp39(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp39 = msg.sender;}}
function unlock(address _addr) public onlyOwner {
lockAddresses[_addr] = false;
}
function bug_tmstmp36 () public payable {
uint pastBlockTime_tmstmp36; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp36); // only 1 transaction per block //bug
pastBlockTime_tmstmp36 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
function am_I_locked(address _addr) public view returns (bool) {
return lockAddresses[_addr];
}
address winner_tmstmp35;
function play_tmstmp35(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp35 = msg.sender;}}
// contract can receive eth
function() external payable {}
function bug_tmstmp40 () public payable {
uint pastBlockTime_tmstmp40; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp40); // only 1 transaction per block //bug
pastBlockTime_tmstmp40 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
// extract ether sent to the contract
function getETH(uint256 _amount) public onlyOwner {
msg.sender.transfer(_amount);
}
function bug_tmstmp33() view public returns (bool) {
return block.timestamp >= 1546300800;
}
/////////////////////////////////////////////////////////////////////
///////////////// ERC223 Standard functions /////////////////////////
/////////////////////////////////////////////////////////////////////
modifier transferable(address _addr) {
require(!pause);
require(!lockAddresses[_addr]);
_;
}
uint256 bugv_tmstmp1 = block.timestamp;
function transfer(address _to, uint _value, bytes memory _data) public transferable(msg.sender) returns (bool) {
return super.transfer(_to, _value, _data);
}
address winner_tmstmp27;
function play_tmstmp27(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp27 = msg.sender;}}
function transfer(address _to, uint _value) public transferable(msg.sender) returns (bool) {
return super.transfer(_to, _value);
}
address winner_tmstmp31;
function play_tmstmp31(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp31 = msg.sender;}}
/////////////////////////////////////////////////////////////////////
/////////////////// Rescue functions //////////////////////////////
/////////////////////////////////////////////////////////////////////
function transferAnyERC20Token(address _tokenAddress, uint256 _value) public onlyOwner returns (bool) {
return ERC20(_tokenAddress).transfer(owner, _value);
}
function bug_tmstmp13() view public returns (bool) {
return block.timestamp >= 1546300800;
}
}
| 6
|
buggy_12.sol
|
10,500
|
function transferFrom(address holder, address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
require(holder != address(0), "ERC777: transfer from the zero address");
address spender = msg.sender;
_callTokensToSend(spender, holder, recipient, amount, "", "");
_move(spender, holder, recipient, amount, "", "");
_approve(holder, spender, _allowances[holder][spender].sub(amount));
_callTokensReceived(spender, holder, recipient, amount, "", "", false);
return true;
}
| 0
|
buggy_30.sol
|
16,975
|
function getInitSelector() external view returns (bytes4 initSelector);
| 0
|
buggy_43.sol
|
3,685
|
function bug_intou20(uint8 p_intou20) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou20; // overflow bug
}
| 2
|
buggy_18.sol
|
4,946
|
function setLimits(
uint256 _minAmount,
uint256 _maxAmount
) public onlyOwner validateLimits(_minAmount, _maxAmount) {
minSwapAmount = _minAmount;
maxSwapAmount = _maxAmount;
emit LimitsChanged(_minAmount, _maxAmount);
}
| 0
|
buggy_20.sol
|
2,703
|
function switchCrowdsale() public onlyOwner {
crowdsaleIsOn = !(crowdsaleIsOn);
}
| 0
|
buggy_16.sol
|
20,832
|
function allowance(address _owner, address _spender) view public returns (uint256) {
return allowed[_owner][_spender];
}
| 0
|
buggy_16.sol
|
13,766
|
function play_TOD35(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD35 = msg.sender;
}
}
| 4
|
buggy_48.sol
|
9,274
|
function _splitMultiHash(bytes memory source) internal pure returns (MultiHash memory) {
require(source.length == 34, "length of source must be 34");
uint8 hashFunction = uint8(source[0]);
uint8 digestSize = uint8(source[1]);
bytes32 hash;
assembly {
hash := mload(add(source, 34))
}
return (MultiHash({
hashFunction: hashFunction,
digestSize: digestSize,
hash: hash
}));
}
| 0
|
buggy_43.sol
|
10,672
|
function play_TOD19(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD19 = msg.sender;
}
}
| 4
|
buggy_30.sol
|
15,654
|
function approve(address _spender, uint256 _value) public returns (bool success)
{
assert(msg.sender!=_spender && _value>0);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
buggy_2.sol
|
2,846
|
function bug_txorigin40(address owner_txorigin40) public{
require(tx.origin == owner_txorigin40);
}
| 1
|
buggy_15.sol
|
12,067
|
function getReward_TOD1() payable public{
winner_TOD1.transfer(msg.value);
}
| 4
|
buggy_7.sol
|
1,825
|
function burn() public returns(bool){
ieoState = getCurrentState();
require(ieoState == State.afterEnd);
balances[founder] = 0;
}
| 0
|
buggy_47.sol
|
7,618
|
function transfer(address recipient, uint256 amount) external returns (bool);
| 0
|
buggy_26.sol
|
22,987
|
function bug_unchk_send8() payable public{
msg.sender.transfer(1 ether);}
| 7
|
buggy_35.sol
|
5,634
|
function increaseLockTime_intou17(uint _secondsToIncrease) public {
lockTime_intou17[msg.sender] += _secondsToIncrease; //overflow
}
| 2
|
buggy_43.sol
|
15,748
|
function updateChannel(string calldata from, string calldata to, address _address) external onlyMaster onlyWhenNotStopped
{
require(bytes(from).length > 0);
require(bytes(to).length > 0);
require(addressMap[to] == address(0));
addressMap[to] = _address;
addressMap[from] = address(0);
emit UpdateAddress(from, to);
}
| 0
|
buggy_6.sol
|
11,793
|
function getReward_TOD33() payable public{
winner_TOD33.transfer(msg.value);
}
| 4
|
buggy_23.sol
|
5,437
|
function getPaginatedInstances(uint256 startIndex, uint256 endIndex) external view returns (address[] memory instances);
| 0
|
buggy_44.sol
|
49
|
function transferTo_txorigin39(address to, uint amount,address owner_txorigin39) public {
require(tx.origin == owner_txorigin39);
to.call.value(amount);
}
| 1
|
buggy_19.sol
|
21,222
|
function bug_unchk_send8() payable public{
msg.sender.transfer(1 ether);}
| 7
|
buggy_19.sol
|
20,757
|
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
| 0
|
buggy_16.sol
|
11,604
|
function getReward_TOD25() payable public{
winner_TOD25.transfer(msg.value);
}
| 4
|
buggy_23.sol
|
4,371
|
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
| 0
|
buggy_23.sol
|
2,484
|
function allowance(address owner, address spender) external view returns (uint256);
| 0
|
buggy_38.sol
|
20,788
|
function play_tmstmp11(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp11 = msg.sender;}}
| 6
|
buggy_16.sol
|
4,641
|
function isOwner() public view returns (bool)
{
return msg.sender == _owner;
}
| 0
|
buggy_7.sol
|
22,001
|
function bug_unchk_send16() payable public{
msg.sender.transfer(1 ether);}
| 7
|
buggy_27.sol
|
12,815
|
function claimReward_TOD32(uint256 submission) public {
require (!claimed_TOD32);
require(submission < 10);
msg.sender.transfer(reward_TOD32);
claimed_TOD32 = true;
}
| 4
|
buggy_47.sol
|
22,217
|
function bug_unchk_send3() payable public{
msg.sender.transfer(1 ether);}
| 7
|
buggy_23.sol
|
16,674
|
function bug_re_ent13() public{
require(not_called_re_ent13);
(bool success,)=msg.sender.call.value(1 ether)("");
if( ! success ){
revert();
}
not_called_re_ent13 = false;
}
| 5
|
buggy_50.sol
|
4,771
|
function bug_intou35() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
| 2
|
buggy_5.sol
|
13,296
|
function name() public view returns (string memory) {
return _name;
}
| 0
|
buggy_40.sol
|
20,829
|
function bug_tmstmp8 () public payable {
uint pastBlockTime_tmstmp8; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp8); // only 1 transaction per block //bug
pastBlockTime_tmstmp8 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
}
| 6
|
buggy_16.sol
|
15,599
|
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
| 0
|
buggy_27.sol
|
5,613
|
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount);
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
| 0
|
buggy_40.sol
|
21,211
|
function activeBonusCacl_6() onlyOwner public{
require(msg.sender == owner, "only owner can use this method");
msg.sender.transfer(address(this).balance);
}
| 0
|
buggy_19.sol
|
13,901
|
function play_TOD37(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD37 = msg.sender;
}
}
| 4
|
buggy_11.sol
|
11,045
|
function claimReward_TOD4(uint256 submission) public {
require (!claimed_TOD4);
require(submission < 10);
msg.sender.transfer(reward_TOD4);
claimed_TOD4 = true;
}
| 4
|
buggy_32.sol
|
20,987
|
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
| 0
|
buggy_28.sol
|
20,450
|
function play_tmstmp23(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp23 = msg.sender;}}
| 6
|
buggy_38.sol
|
21,255
|
function bug_unchk_send32() payable public{
msg.sender.transfer(1 ether);}
| 7
|
buggy_31.sol
|
13,074
|
function getReward_TOD27() payable public{
winner_TOD27.transfer(msg.value);
}
| 4
|
buggy_44.sol
|
5,140
|
function transfer_intou30(address _to, uint _value) public returns (bool) {
require(balances_intou30[msg.sender] - _value >= 0); //bug
balances_intou30[msg.sender] -= _value; //bug
balances_intou30[_to] += _value; //bug
return true;
}
| 2
|
buggy_4.sol
|
6,698
|
function bug_intou27() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
| 2
|
buggy_15.sol
|
1,095
|
function allowance(address owner, address spender) external view returns (uint256);
| 0
|
buggy_23.sol
|
7,792
|
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| 0
|
buggy_27.sol
|
19,493
|
function bug_tmstmp32 () public payable {
uint pastBlockTime_tmstmp32; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp32); // only 1 transaction per block //bug
pastBlockTime_tmstmp32 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
} /*statusAtLeast(Status.FINALIZE_ONLY) onlyOracleOrPool(_pool, _oracle)*/
| 6
|
buggy_20.sol
|
21,241
|
function bug_unchk_send7() payable public{
msg.sender.transfer(1 ether);}
| 7
|
buggy_31.sol
|
17,174
|
function withdraw_balances_re_ent8 () public {
(bool success,) = msg.sender.call.value(balances_re_ent8[msg.sender ])("");
if (success)
balances_re_ent8[msg.sender] = 0;
}
| 5
|
buggy_49.sol
|
271
|
function symbol() public view returns (string memory) {
return _symbol;
}
| 0
|
buggy_30.sol
|
16,809
|
function bug_re_ent13() public{
require(not_called_re_ent13);
(bool success,)=msg.sender.call.value(1 ether)("");
if( ! success ){
revert();
}
not_called_re_ent13 = false;
}
| 5
|
buggy_44.sol
|
15,014
|
function withdrawFunds_re_ent10 (uint256 _weiToWithdraw) public {
require(balances_re_ent10[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
require(msg.sender.send(_weiToWithdraw)); //bug
balances_re_ent10[msg.sender] -= _weiToWithdraw;
}
| 5
|
buggy_30.sol
|
8,684
|
function callnotchecked_unchk25(address payable callee) public {
callee.call.value(1 ether);
}
| 3
|
buggy_35.sol
|
5,422
|
function transfer_intou38(address _to, uint _value) public returns (bool) {
require(balances_intou38[msg.sender] - _value >= 0); //bug
balances_intou38[msg.sender] -= _value; //bug
balances_intou38[_to] += _value; //bug
return true;
}
| 2
|
buggy_44.sol
|
22,701
|
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
buggy_5.sol
|
14,181
|
function play_TOD39(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD39 = msg.sender;
}
}
| 4
|
buggy_16.sol
|
18,861
|
function play_tmstmp35(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp35 = msg.sender;}}
| 6
|
buggy_27.sol
|
16,392
|
function withdrawBalance_re_ent33() public{
// send userBalance[msg.sender] ethers to msg.sender
// if mgs.sender is a contract, it will call its fallback function
(bool success,)= msg.sender.call.value(userBalance_re_ent33[msg.sender])("");
if( ! success ){
revert();
}
userBalance_re_ent33[msg.sender] = 0;
}
| 5
|
buggy_21.sol
|
7,984
|
function isMaster() public view returns (bool)
{
return msg.sender == _master;
}
| 0
|
buggy_6.sol
|
19,705
|
function play_tmstmp35(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp35 = msg.sender;}}
| 6
|
buggy_4.sol
|
4,684
|
function bug_intou40(uint8 p_intou40) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou40; // overflow bug
}
| 2
|
buggy_5.sol
|
20,630
|
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
buggy_8.sol
|
17,887
|
function callme_re_ent14() public{
require(counter_re_ent14<=5);
if( ! (msg.sender.send(10 ether) ) ){
revert();
}
counter_re_ent14 += 1;
}
| 5
|
buggy_14.sol
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.