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 saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.