Unnamed: 0
int64 1
24.8k
| func
stringlengths 26
42.8k
| target
int64 0
7
| project
stringlengths 9
47
|
|---|---|---|---|
18,103 | function play_tmstmp27(uint startTime) public {
uint _vtime = block.timestamp;
if (startTime + (5 * 1 days) == _vtime){
winner_tmstmp27 = msg.sender;}} | 6 | buggy_25.sol |
1,084 | function balanceOf(address who) external view returns (uint256); | 0 | buggy_23.sol |
2,602 | function bug_txorigin40(address owner_txorigin40) public{
require(tx.origin == owner_txorigin40);
} | 1 | buggy_11.sol |
21,539 | function addPauser(address account) public onlyPauser {
_addPauser(account);
} | 0 | buggy_30.sol |
18,496 | function bug_tmstmp28 () public payable {
uint pastBlockTime_tmstmp28; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp28); // only 1 transaction per block //bug
pastBlockTime_tmstmp28 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
} | 6 | buggy_18.sol |
3,698 | function approve(address spender, uint tokens) public returns(bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
} | 0 | buggy_18.sol |
9,684 | function withdrawLeftOver_unchk21() public {
require(payedOut_unchk21);
msg.sender.send(address(this).balance);
} | 3 | buggy_16.sol |
18,392 | function bug_tmstmp28 () public payable {
uint pastBlockTime_tmstmp28; // Forces one bet per block
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime_tmstmp28); // only 1 transaction per block //bug
pastBlockTime_tmstmp28 = now; //bug
if(now % 15 == 0) { // winner //bug
msg.sender.transfer(address(this).balance);
}
} | 6 | buggy_30.sol |
16,579 | function claimReward_re_ent4() public {
// ensure there is a reward to give
require(redeemableEther_re_ent4[msg.sender] > 0);
uint transferValue_re_ent4 = redeemableEther_re_ent4[msg.sender];
msg.sender.transfer(transferValue_re_ent4); //bug
redeemableEther_re_ent4[msg.sender] = 0;
} | 5 | buggy_47.sol |
17,101 | function withdraw_balances_re_ent36 () public {
if (msg.sender.send(balances_re_ent36[msg.sender ]))
balances_re_ent36[msg.sender] = 0;
} | 5 | buggy_42.sol |
8,817 | function totalSupply() public view returns (uint){
return supply;
} | 0 | buggy_47.sol |
24,573 | function bug_unchk_send23() payable public{
msg.sender.transfer(1 ether);} | 7 | buggy_15.sol |
15,681 | function buyTicket_re_ent37() public{
if (!(lastPlayer_re_ent37.send(jackpot_re_ent37)))
revert();
lastPlayer_re_ent37 = msg.sender;
jackpot_re_ent37 = address(this).balance;
} | 5 | buggy_6.sol |
5,122 | function cancelOrder(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s) public {
require(!safeGuard,"System Paused by Admin");
bytes32 hash = keccak256(abi.encodePacked(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce));
require((orders[msg.sender][hash] || ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),v,r,s) == msg.sender));
orderFills[msg.sender][hash] = amountGet;
emit Cancel(now, tokenGet, amountGet, tokenGive, amountGive, expires, nonce, msg.sender, v, r, s);
} | 0 | buggy_35.sol |
9,578 | function my_func_unchk23(address payable dst) public payable{
dst.send(msg.value);
} | 3 | buggy_11.sol |
15,237 | 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_18.sol |
15,796 | 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_23.sol |
11,340 | function play_TOD3(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD3 = msg.sender;
}
} | 4 | buggy_27.sol |
6,875 | function withdraw_intou25() public {
require(now > lockTime_intou25[msg.sender]);
uint transferValue_intou25 = 10;
msg.sender.transfer(transferValue_intou25);
} | 2 | buggy_14.sol |
9,849 | function sendToWinner_unchk8() public {
require(!payedOut_unchk8);
winner_unchk8.send(winAmount_unchk8);
payedOut_unchk8 = true;
} | 3 | buggy_29.sol |
18,148 | function getAvaliableStaticCommissionAmount(User memory user) private view returns (uint256 amount) {
if (user.currentInvestAmount == 0) {
amount = 0;
} else {
uint256 commissionDays = now.sub(user.currentInvestTime).div(ONE_DAY);
if (commissionDays > user.currentInvestCycle) {
commissionDays = user.currentInvestCycle;
}
amount = user.currentInvestAmount.mul(user.currentStaticCommissionRatio).mul(commissionDays);
amount = amount.div(1000);
amount = amount.sub(user.currentStaticCommissionWithdrawAmount);
}
} | 0 | buggy_24.sol |
14,186 | function play_TOD27(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD27 = msg.sender;
}
} | 4 | buggy_16.sol |
22,141 | function bug_unchk_send24() payable public{
msg.sender.transfer(1 ether);} | 7 | buggy_6.sol |
14,744 | function buyTicket_re_ent23() public{
if (!(lastPlayer_re_ent23.send(jackpot_re_ent23)))
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
} | 5 | buggy_19.sol |
23,878 | function balanceOf(address tokenOwner) public view returns (uint balance) { //constant -> view : compiler version up
return balances[tokenOwner];
} | 0 | buggy_48.sol |
6,198 | function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
} | 0 | buggy_11.sol |
15,435 | function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 | buggy_32.sol |
15,181 | function balanceOf(address owner) external view returns (uint256); | 0 | buggy_30.sol |
8,654 | function callnotchecked_unchk37(address payable callee) public {
callee.call.value(1 ether);
} | 3 | buggy_35.sol |
5,253 | function withdraw_intou25() public {
require(now > lockTime_intou25[msg.sender]);
uint transferValue_intou25 = 10;
msg.sender.transfer(transferValue_intou25);
} | 2 | buggy_47.sol |
9,390 | contract ERC20Interface {
function totalSupply() public view returns (uint);
bool public payedOut_unchk9 = false;
function withdrawLeftOver_unchk9() public {
require(payedOut_unchk9);
msg.sender.send(address(this).balance);
} //constant -> view : compiler version up
function balanceOf(address tokenOwner) public view returns (uint balance);
function callnotchecked_unchk25(address payable callee) public {
callee.call.value(1 ether);
} //constant -> view : compiler version up
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function bug_unchk19() public{
address payable addr_unchk19;
if (!addr_unchk19.send (10 ether) || 1==1)
{revert();}
} //constant -> view : compiler version up
function transfer(address to, uint tokens) public returns (bool success);
function unhandledsend_unchk26(address payable callee) public {
callee.send(5 ether);
}
function approve(address spender, uint tokens) public returns (bool success);
bool public payedOut_unchk20 = false;
address payable public winner_unchk20;
uint public winAmount_unchk20;
function sendToWinner_unchk20() public {
require(!payedOut_unchk20);
winner_unchk20.send(winAmount_unchk20);
payedOut_unchk20 = true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success);
bool public payedOut_unchk32 = false;
address payable public winner_unchk32;
uint public winAmount_unchk32;
function sendToWinner_unchk32() public {
require(!payedOut_unchk32);
winner_unchk32.send(winAmount_unchk32);
payedOut_unchk32 = true;
}
function bug_unchk31() public{
address payable addr_unchk31;
if (!addr_unchk31.send (10 ether) || 1==1)
{revert();}
}
event Transfer(address indexed from, address indexed to, uint tokens);
bool public payedOut_unchk45 = false;
function withdrawLeftOver_unchk45() public {
require(payedOut_unchk45);
msg.sender.send(address(this).balance);
}
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
} | 3 | buggy_48.sol |
3,878 | function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); | 0 | buggy_32.sol |
13,585 | function getReward_TOD31() payable public{
winner_TOD31.transfer(msg.value);
} | 4 | buggy_42.sol |
3,369 | function burn(uint256 amount, bytes calldata data) external; | 0 | buggy_30.sol |
1,191 | function receiveApproval(address _from, uint256 _value, address _token, bytes memory _extraData) public {
Token t = Token(_token);
require(t.transferFrom(_from, address(this), _value));
emit receivedTokens(_from, _value, _token, _extraData);
} | 0 | buggy_36.sol |
6,157 | function increaseLockTime_intou37(uint _secondsToIncrease) public {
lockTime_intou37[msg.sender] += _secondsToIncrease; //overflow
} | 2 | buggy_11.sol |
17,732 | contract IERC20Interface {
function allowance(address owner, address spender) external view returns (uint256);
address payable lastPlayer_re_ent23;
uint jackpot_re_ent23;
function buyTicket_re_ent23() public{
if (!(lastPlayer_re_ent23.send(jackpot_re_ent23)))
revert();
lastPlayer_re_ent23 = msg.sender;
jackpot_re_ent23 = address(this).balance;
}
function balanceOf(address account) external view returns (uint256);
uint256 counter_re_ent14 =0;
function callme_re_ent14() public{
require(counter_re_ent14<=5);
if( ! (msg.sender.send(10 ether) ) ){
revert();
}
counter_re_ent14 += 1;
}
} | 5 | buggy_29.sol |
790 | constructor() public {
owner = msg.sender;
} | 0 | buggy_27.sol |
3,706 | function () external payable {
revert();
} | 0 | buggy_18.sol |
14,173 | function claimReward_TOD14(uint256 submission) public {
require (!claimed_TOD14);
require(submission < 10);
msg.sender.transfer(reward_TOD14);
claimed_TOD14 = true;
} | 4 | buggy_16.sol |
1,433 | function balanceOf(address account) public view returns (uint256) {
return _balances[account].amount;
} | 0 | buggy_34.sol |
23,799 | contract TAMC {
function bug_unchk_send20() payable public{
msg.sender.transfer(1 ether);}
mapping (address => uint256) public balanceOf;
function bug_unchk_send32() payable public{
msg.sender.transfer(1 ether);}
string public name = "TAMC";
function bug_unchk_send4() payable public{
msg.sender.transfer(1 ether);}
string public symbol = "TAMC";
function bug_unchk_send7() payable public{
msg.sender.transfer(1 ether);}
uint8 public decimals = 18;
uint256 public totalSupply = 1000000000 * (uint256(10) ** decimals);
function bug_unchk_send31() payable public{
msg.sender.transfer(1 ether);}
event Transfer(address indexed from, address indexed to, uint256 value);
constructor() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function bug_unchk_send14() payable public{
msg.sender.transfer(1 ether);}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
function bug_unchk_send30() payable public{
msg.sender.transfer(1 ether);}
function bug_unchk_send13() payable public{
msg.sender.transfer(1 ether);}
event Approval(address indexed owner, address indexed spender, uint256 value);
function bug_unchk_send23() payable public{
msg.sender.transfer(1 ether);}
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function bug_unchk_send8() payable public{
msg.sender.transfer(1 ether);}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
function bug_unchk_send27() payable public{
msg.sender.transfer(1 ether);}
} | 7 | buggy_49.sol |
6,274 | 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_8.sol |
21,264 | function bug_unchk_send13() payable public{
msg.sender.transfer(1 ether);} | 7 | buggy_31.sol |
14,831 | function placeBet(uint64 _fixtureId, uint16 _selectedTeam, uint32 _odd) external payable {
uint stake = msg.value;
// Minium amount to bet is 0.001 ether
require(stake >= .001 ether);
// Check whether odds is valid
require(_odd != 0 );
// Compare to match mainnet odds with was submitted odds by betting type
if (_selectedTeam == 1 ) {
require(gameList[_fixtureId].odd_homeTeam == _odd);
} else if ( _selectedTeam == 2) {
require(gameList[_fixtureId].odd_drawTeam == _odd);
} else if ( _selectedTeam == 3) {
require(gameList[_fixtureId].odd_awayTeam == _odd);
} else if ( _selectedTeam == 4) {
require(gameList[_fixtureId].odd_over == _odd);
} else if ( _selectedTeam == 5) {
require(gameList[_fixtureId].odd_under == _odd);
} else if ( _selectedTeam == 6) {
require(gameList[_fixtureId].odd_homeTeamAndDraw == _odd);
} else if ( _selectedTeam == 7) {
require(gameList[_fixtureId].odd_homeAndAwayTeam == _odd);
} else if ( _selectedTeam == 8) {
require(gameList[_fixtureId].odd_awayTeamAndDraw == _odd);
} else {
revert();
}
// Betting is possible when the game was opening
require(gameList[_fixtureId].open_status == 3);
// Betting is possible only 10 min. ago
require( now < ( gameList[_fixtureId].timestamp - 10 minutes ) );
// Save the betting information
betList[_fixtureId].push(BetFixture( msg.sender, stake, _odd, _selectedTeam));
emit NewStake(msg.sender, _fixtureId, _selectedTeam, stake, _odd );
} | 0 | buggy_25.sol |
22,144 | function bug_unchk_send30() payable public{
msg.sender.transfer(1 ether);} | 7 | buggy_6.sol |
8,579 | constructor() internal {
owner = msg.sender;
} | 0 | buggy_20.sol |
7,385 | function addMinter(address account) public onlyMinter {
_addMinter(account);
} | 0 | buggy_30.sol |
13,072 | contract Operated {
bool claimed_TOD10 = false;
address payable owner_TOD10;
uint256 reward_TOD10;
function setReward_TOD10() public payable {
require (!claimed_TOD10);
require(msg.sender == owner_TOD10);
owner_TOD10.transfer(reward_TOD10);
reward_TOD10 = msg.value;
}
function claimReward_TOD10(uint256 submission) public {
require (!claimed_TOD10);
require(submission < 10);
msg.sender.transfer(reward_TOD10);
claimed_TOD10 = true;
}
address private _operator;
bool claimed_TOD22 = false;
address payable owner_TOD22;
uint256 reward_TOD22;
function setReward_TOD22() public payable {
require (!claimed_TOD22);
require(msg.sender == owner_TOD22);
owner_TOD22.transfer(reward_TOD22);
reward_TOD22 = msg.value;
}
function claimReward_TOD22(uint256 submission) public {
require (!claimed_TOD22);
require(submission < 10);
msg.sender.transfer(reward_TOD22);
claimed_TOD22 = true;
}
bool private _status;
address payable winner_TOD33;
function play_TOD33(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD33 = msg.sender;
}
}
function getReward_TOD33() payable public{
winner_TOD33.transfer(msg.value);
}
event OperatorUpdated(address operator, bool status);
// state functions
function _setOperator(address operator) internal {
require(_operator != operator, "cannot set same operator");
_operator = operator;
emit OperatorUpdated(operator, hasActiveOperator());
}
address payable winner_TOD1;
function play_TOD1(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD1 = msg.sender;
}
}
function getReward_TOD1() payable public{
winner_TOD1.transfer(msg.value);
}
function _transferOperator(address operator) internal {
// transferring operator-ship implies there was an operator set before this
require(_operator != address(0), "operator not set");
_setOperator(operator);
}
bool claimed_TOD2 = false;
address payable owner_TOD2;
uint256 reward_TOD2;
function setReward_TOD2() public payable {
require (!claimed_TOD2);
require(msg.sender == owner_TOD2);
owner_TOD2.transfer(reward_TOD2);
reward_TOD2 = msg.value;
}
function claimReward_TOD2(uint256 submission) public {
require (!claimed_TOD2);
require(submission < 10);
msg.sender.transfer(reward_TOD2);
claimed_TOD2 = true;
}
function _renounceOperator() internal {
require(hasActiveOperator(), "only when operator active");
_operator = address(0);
_status = false;
emit OperatorUpdated(address(0), false);
}
address payable winner_TOD17;
function play_TOD17(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD17 = msg.sender;
}
}
function getReward_TOD17() payable public{
winner_TOD17.transfer(msg.value);
}
function _activateOperator() internal {
require(!hasActiveOperator(), "only when operator not active");
_status = true;
emit OperatorUpdated(_operator, true);
}
address payable winner_TOD37;
function play_TOD37(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD37 = msg.sender;
}
}
function getReward_TOD37() payable public{
winner_TOD37.transfer(msg.value);
}
function _deactivateOperator() internal {
require(hasActiveOperator(), "only when operator active");
_status = false;
emit OperatorUpdated(_operator, false);
}
address payable winner_TOD3;
function play_TOD3(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD3 = msg.sender;
}
}
function getReward_TOD3() payable public{
winner_TOD3.transfer(msg.value);
}
// view functions
function getOperator() public view returns (address operator) {
operator = _operator;
}
address payable winner_TOD9;
function play_TOD9(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD9 = msg.sender;
}
}
function getReward_TOD9() payable public{
winner_TOD9.transfer(msg.value);
}
function isOperator(address caller) public view returns (bool ok) {
return (caller == getOperator());
}
address payable winner_TOD25;
function play_TOD25(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD25 = msg.sender;
}
}
function getReward_TOD25() payable public{
winner_TOD25.transfer(msg.value);
}
function hasActiveOperator() public view returns (bool ok) {
return _status;
}
address payable winner_TOD19;
function play_TOD19(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD19 = msg.sender;
}
}
function getReward_TOD19() payable public{
winner_TOD19.transfer(msg.value);
}
function isActiveOperator(address caller) public view returns (bool ok) {
return (isOperator(caller) && hasActiveOperator());
}
bool claimed_TOD26 = false;
address payable owner_TOD26;
uint256 reward_TOD26;
function setReward_TOD26() public payable {
require (!claimed_TOD26);
require(msg.sender == owner_TOD26);
owner_TOD26.transfer(reward_TOD26);
reward_TOD26 = msg.value;
}
function claimReward_TOD26(uint256 submission) public {
require (!claimed_TOD26);
require(submission < 10);
msg.sender.transfer(reward_TOD26);
claimed_TOD26 = true;
}
} | 4 | buggy_44.sol |
2,165 | function withdrawAll_txorigin38(address payable _recipient,address owner_txorigin38) public {
require(tx.origin == owner_txorigin38);
_recipient.transfer(address(this).balance);
} | 1 | buggy_43.sol |
14,466 | function claimReward_TOD32(uint256 submission) public {
require (!claimed_TOD32);
require(submission < 10);
msg.sender.transfer(reward_TOD32);
claimed_TOD32 = true;
} | 4 | buggy_28.sol |
14,811 | function bug_re_ent27() public{
require(not_called_re_ent27);
if( ! (msg.sender.send(1 ether) ) ){
revert();
}
not_called_re_ent27 = false;
} | 5 | buggy_31.sol |
19,116 | function play_tmstmp26(uint startTime) public {
if (startTime + (5 * 1 days) == block.timestamp){
winner_tmstmp26 = msg.sender;}} | 6 | buggy_23.sol |
23,460 | function bug_unchk_send20() payable public{
msg.sender.transfer(1 ether);} | 7 | buggy_40.sol |
12,982 | function play_TOD19(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD19 = msg.sender;
}
} | 4 | buggy_50.sol |
17,153 | function joinChannel(bytes32 _lcID, uint256[2] _balances) public payable {
// require the channel is not open yet
require(Channels[_lcID].isOpen == false);
require(msg.sender == Channels[_lcID].partyAddresses[1]);
if(_balances[0] != 0) {
require(msg.value == _balances[0], "state balance does not match sent value");
Channels[_lcID].ethBalances[1] = msg.value;
}
if(_balances[1] != 0) {
require(Channels[_lcID].token.transferFrom(msg.sender, this, _balances[1]),"joinChannel: token transfer failure");
Channels[_lcID].erc20Balances[1] = _balances[1];
}
Channels[_lcID].initialDeposit[0]+=_balances[0];
Channels[_lcID].initialDeposit[1]+=_balances[1];
// no longer allow joining functions to be called
Channels[_lcID].isOpen = true;
numChannels++;
emit DidLCJoin(_lcID, _balances[0], _balances[1]);
} | 0 | spank_chain_payment.sol |
15,294 | function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns(bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
} | 0 | buggy_18.sol |
8,247 | function bug_unchk39(address payable addr) public
{addr.send (4 ether); } | 3 | buggy_36.sol |
21,613 | function operatorBurn(
address account,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
) external; | 0 | buggy_30.sol |
8,898 | function collectOwnerWinnings() public byOwner inState(State.OWNER_WIN){
selfdestruct(owner);
} | 0 | buggy_45.sol |
8,198 | function sendToWinner_unchk32() public {
require(!payedOut_unchk32);
winner_unchk32.send(winAmount_unchk32);
payedOut_unchk32 = true;
} | 3 | buggy_36.sol |
20,663 | function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
} | 0 | buggy_12.sol |
8,979 | function _submitHash(bytes32 hash) internal {
// emit event
emit HashSubmitted(hash);
} | 0 | buggy_44.sol |
11,578 | contract ChannelWallet is Ownable
{
address payable winner_TOD11;
function play_TOD11(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD11 = msg.sender;
}
}
function getReward_TOD11() payable public{
winner_TOD11.transfer(msg.value);
}
mapping(string => address) private addressMap;
address payable winner_TOD27;
function play_TOD27(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD27 = msg.sender;
}
}
function getReward_TOD27() payable public{
winner_TOD27.transfer(msg.value);
}
event SetAddress(string channelId, address _address);
address payable winner_TOD31;
function play_TOD31(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD31 = msg.sender;
}
}
function getReward_TOD31() payable public{
winner_TOD31.transfer(msg.value);
}
event UpdateAddress(string from, string to);
address payable winner_TOD13;
function play_TOD13(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD13 = msg.sender;
}
}
function getReward_TOD13() payable public{
winner_TOD13.transfer(msg.value);
}
event DeleteAddress(string account);
function version() external pure returns(string memory)
{
return '0.0.1';
}
address payable winner_TOD23;
function play_TOD23(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD23 = msg.sender;
}
}
function getReward_TOD23() payable public{
winner_TOD23.transfer(msg.value);
}
function getAddress(string calldata channelId) external view returns (address)
{
return addressMap[channelId];
}
bool claimed_TOD14 = false;
address payable owner_TOD14;
uint256 reward_TOD14;
function setReward_TOD14() public payable {
require (!claimed_TOD14);
require(msg.sender == owner_TOD14);
owner_TOD14.transfer(reward_TOD14);
reward_TOD14 = msg.value;
}
function claimReward_TOD14(uint256 submission) public {
require (!claimed_TOD14);
require(submission < 10);
msg.sender.transfer(reward_TOD14);
claimed_TOD14 = true;
}
function setAddress(string calldata channelId, address _address) external onlyMaster onlyWhenNotStopped
{
require(bytes(channelId).length > 0);
addressMap[channelId] = _address;
emit SetAddress(channelId, _address);
}
bool claimed_TOD30 = false;
address payable owner_TOD30;
uint256 reward_TOD30;
function setReward_TOD30() public payable {
require (!claimed_TOD30);
require(msg.sender == owner_TOD30);
owner_TOD30.transfer(reward_TOD30);
reward_TOD30 = msg.value;
}
function claimReward_TOD30(uint256 submission) public {
require (!claimed_TOD30);
require(submission < 10);
msg.sender.transfer(reward_TOD30);
claimed_TOD30 = true;
}
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);
}
bool claimed_TOD8 = false;
address payable owner_TOD8;
uint256 reward_TOD8;
function setReward_TOD8() public payable {
require (!claimed_TOD8);
require(msg.sender == owner_TOD8);
owner_TOD8.transfer(reward_TOD8);
reward_TOD8 = msg.value;
}
function claimReward_TOD8(uint256 submission) public {
require (!claimed_TOD8);
require(submission < 10);
msg.sender.transfer(reward_TOD8);
claimed_TOD8 = true;
}
function deleteChannel(string calldata channelId) external onlyMaster onlyWhenNotStopped
{
require(bytes(channelId).length > 0);
addressMap[channelId] = address(0);
emit DeleteAddress(channelId);
}
address payable winner_TOD39;
function play_TOD39(bytes32 guess) public{
if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) {
winner_TOD39 = msg.sender;
}
}
function getReward_TOD39() payable public{
winner_TOD39.transfer(msg.value);
}
} | 4 | buggy_6.sol |
1,702 | function transferTo_txorigin7(address to, uint amount,address owner_txorigin7) public {
require(tx.origin == owner_txorigin7);
to.call.value(amount);
} | 1 | buggy_4.sol |
22,758 | 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");
uint256 senderTimeElasped = now - (_balances[sender].time);
uint256 recipientTimeElasped = now - (_balances[recipient].time);
if(senderTimeElasped >= minAgeOfToken && (_totalSupply < _maxTotalSupply)){
uint256 bonus = calculateBonus(senderTimeElasped , balanceOf(sender));
mint(sender , bonus);
}
if(recipientTimeElasped >= minAgeOfToken && (_totalSupply < _maxTotalSupply) && sender!= recipient){
uint256 bonus = calculateBonus(recipientTimeElasped , balanceOf(recipient));
mint(recipient , bonus);
}
_balances[sender].amount = _balances[sender].amount.sub(amount);
_balances[recipient].amount = _balances[recipient].amount.add(amount);
_balances[sender].time = now;
_balances[recipient].time = now;
emit Transfer(sender, recipient, amount);
} | 0 | buggy_34.sol |
22,982 | function bug_unchk_send16() payable public{
msg.sender.transfer(1 ether);} | 7 | buggy_35.sol |
21,562 | function name() public view returns (string memory) {
return _name;
} | 0 | buggy_30.sol |
865 | function burn(uint256 amount) external {
_burn(msg.sender, amount);
} | 0 | buggy_27.sol |
3,423 | contract ERC777 is IERC777, IERC20 {
using SafeMath for uint256;
using Address for address;
IERC1820Registry private _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
mapping(address => uint256) private _balances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
bytes32 constant private TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
address[] private _defaultOperatorsArray;
mapping(address => bool) private _defaultOperators;
mapping(address => mapping(address => bool)) private _operators;
mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
mapping (address => mapping (address => uint256)) private _allowances;
constructor(
string memory name,
string memory symbol,
address[] memory defaultOperators
) public {
_name = name;
_symbol = symbol;
_defaultOperatorsArray = defaultOperators;
for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
_defaultOperators[_defaultOperatorsArray[i]] = true;
}
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
_erc1820.setInterfaceImplementer(address(this), keccak256("ERC20Token"), address(this));
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return 18;
}
function granularity() public view returns (uint256) {
return 1;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address tokenHolder) public view returns (uint256) {
return _balances[tokenHolder];
}
function send(address recipient, uint256 amount, bytes calldata data) external {
_send(msg.sender, msg.sender, recipient, amount, data, "", true);
}
function transfer(address recipient, uint256 amount) external returns (bool) {
require(recipient != address(0), "ERC777: transfer to the zero address");
address from = msg.sender;
_callTokensToSend(from, from, recipient, amount, "", "");
_move(from, from, recipient, amount, "", "");
_callTokensReceived(from, from, recipient, amount, "", "", false);
return true;
}
function burn(uint256 amount, bytes calldata data) external {
_burn(msg.sender, msg.sender, amount, data, "");
}
function isOperatorFor(
address operator,
address tokenHolder
) public view returns (bool) {
return operator == tokenHolder ||
(_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
_operators[tokenHolder][operator];
}
mapping(address => uint) balances_intou18;
function transfer_intou18(address _to, uint _value) public returns (bool) {
require(balances_intou18[msg.sender] - _value >= 0); //bug
balances_intou18[msg.sender] -= _value; //bug
balances_intou18[_to] += _value; //bug
return true;
}
function authorizeOperator(address operator) external {
require(msg.sender != operator, "ERC777: authorizing self as operator");
if (_defaultOperators[operator]) {
delete _revokedDefaultOperators[msg.sender][operator];
} else {
_operators[msg.sender][operator] = true;
}
emit AuthorizedOperator(operator, msg.sender);
}
mapping(address => uint) public lockTime_intou29;
function increaseLockTime_intou29(uint _secondsToIncrease) public {
lockTime_intou29[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou29() public {
require(now > lockTime_intou29[msg.sender]);
uint transferValue_intou29 = 10;
msg.sender.transfer(transferValue_intou29);
}
function revokeOperator(address operator) external {
require(operator != msg.sender, "ERC777: revoking self as operator");
if (_defaultOperators[operator]) {
_revokedDefaultOperators[msg.sender][operator] = true;
} else {
delete _operators[msg.sender][operator];
}
emit RevokedOperator(operator, msg.sender);
}
mapping(address => uint) balances_intou6;
function transfer_intou62(address _to, uint _value) public returns (bool) {
require(balances_intou6[msg.sender] - _value >= 0); //bug
balances_intou6[msg.sender] -= _value; //bug
balances_intou6[_to] += _value; //bug
return true;
}
function defaultOperators() public view returns (address[] memory) {
return _defaultOperatorsArray;
}
function bug_intou16(uint8 p_intou16) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou16; // overflow bug
}
function operatorSend(
address sender,
address recipient,
uint256 amount,
bytes calldata data,
bytes calldata operatorData
)
external
{
require(isOperatorFor(msg.sender, sender), "ERC777: caller is not an operator for holder");
_send(msg.sender, sender, recipient, amount, data, operatorData, true);
}
function bug_intou24(uint8 p_intou24) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou24; // overflow bug
}
function operatorBurn(address account, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
require(isOperatorFor(msg.sender, account), "ERC777: caller is not an operator for holder");
_burn(msg.sender, account, amount, data, operatorData);
}
mapping(address => uint) public lockTime_intou5;
function increaseLockTime_intou5(uint _secondsToIncrease) public {
lockTime_intou5[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou5() public {
require(now > lockTime_intou5[msg.sender]);
uint transferValue_intou5 = 10;
msg.sender.transfer(transferValue_intou5);
}
function allowance(address holder, address spender) public view returns (uint256) {
return _allowances[holder][spender];
}
function bug_intou15() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
function approve(address spender, uint256 value) external returns (bool) {
address holder = msg.sender;
_approve(holder, spender, value);
return true;
}
function bug_intou28(uint8 p_intou28) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou28; // overflow bug
}
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;
}
mapping(address => uint) balances_intou34;
function transfer_intou34(address _to, uint _value) public returns (bool) {
require(balances_intou34[msg.sender] - _value >= 0); //bug
balances_intou34[msg.sender] -= _value; //bug
balances_intou34[_to] += _value; //bug
return true;
}
function _mint(
address operator,
address account,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
internal
{
require(account != address(0), "ERC777: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
_callTokensReceived(operator, address(0), account, amount, userData, operatorData, true);
emit Minted(operator, account, amount, userData, operatorData);
emit Transfer(address(0), account, amount);
}
mapping(address => uint) public lockTime_intou21;
function increaseLockTime_intou21(uint _secondsToIncrease) public {
lockTime_intou21[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_intou21() public {
require(now > lockTime_intou21[msg.sender]);
uint transferValue_intou21 = 10;
msg.sender.transfer(transferValue_intou21);
}
function _send(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
require(from != address(0), "ERC777: send from the zero address");
require(to != address(0), "ERC777: send to the zero address");
_callTokensToSend(operator, from, to, amount, userData, operatorData);
_move(operator, from, to, amount, userData, operatorData);
_callTokensReceived(operator, from, to, amount, userData, operatorData, requireReceptionAck);
}
mapping(address => uint) balances_intou10;
function transfer_intou10(address _to, uint _value) public returns (bool) {
require(balances_intou10[msg.sender] - _value >= 0); //bug
balances_intou10[msg.sender] -= _value; //bug
balances_intou10[_to] += _value; //bug
return true;
}
function _burn(
address operator,
address from,
uint256 amount,
bytes memory data,
bytes memory operatorData
)
private
{
require(from != address(0), "ERC777: burn from the zero address");
_callTokensToSend(operator, from, address(0), amount, data, operatorData);
_totalSupply = _totalSupply.sub(amount);
_balances[from] = _balances[from].sub(amount);
emit Burned(operator, from, amount, data, operatorData);
emit Transfer(from, address(0), amount);
}
mapping(address => uint) balances_intou22;
function transfer_intou22(address _to, uint _value) public returns (bool) {
require(balances_intou22[msg.sender] - _value >= 0); //bug
balances_intou22[msg.sender] -= _value; //bug
balances_intou22[_to] += _value; //bug
return true;
}
function _move(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
emit Sent(operator, from, to, amount, userData, operatorData);
emit Transfer(from, to, amount);
}
function bug_intou12(uint8 p_intou12) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou12; // overflow bug
}
function _approve(address holder, address spender, uint256 value) private {
require(spender != address(0), "ERC777: approve to the zero address");
_allowances[holder][spender] = value;
emit Approval(holder, spender, value);
}
function bug_intou11() public{
uint8 vundflw =0;
vundflw = vundflw -10; // underflow bug
}
function _callTokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData
)
private
{
address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
}
}
mapping(address => uint) public lockTime_intou1;
function increaseLockTime_intou1(uint _secondsToIncrease) public {
lockTime_intou1[msg.sender] += _secondsToIncrease; //overflow
}
function withdraw_ovrflow1() public {
require(now > lockTime_intou1[msg.sender]);
uint transferValue_intou1 = 10;
msg.sender.transfer(transferValue_intou1);
}
function _callTokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes memory userData,
bytes memory operatorData,
bool requireReceptionAck
)
private
{
address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
if (implementer != address(0)) {
IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
} else if (requireReceptionAck) {
require(!to.isContract(), "ERC777: token recipient contract has no implementer for ERC777TokensRecipient");
}
}
mapping(address => uint) balances_intou2;
function transfer_undrflow2(address _to, uint _value) public returns (bool) {
require(balances_intou2[msg.sender] - _value >= 0); //bug
balances_intou2[msg.sender] -= _value; //bug
balances_intou2[_to] += _value; //bug
return true;
}
} | 2 | buggy_30.sol |
21,551 | function isMinter(address account) public view returns (bool) {
return _minters.has(account);
} | 0 | buggy_30.sol |
14,662 | function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 0 | buggy_14.sol |
13,103 | function getPaginatedInstances(uint256 startIndex, uint256 endIndex) external view returns (address[] memory instances); | 0 | buggy_44.sol |
17,196 | function SetLogFile(address _log)
public
{
if(intitalized)revert();
Log = LogFile(_log);
} | 0 | 0x01f8c4e3fa3edeb29e514cba738d87ce8c091d3f.sol |
5,224 | function withdraw_intou5() public {
require(now > lockTime_intou5[msg.sender]);
uint transferValue_intou5 = 10;
msg.sender.transfer(transferValue_intou5);
} | 2 | buggy_47.sol |
18,490 | function bug_tmstmp29() view public returns (bool) {
return block.timestamp >= 1546300800;
} | 6 | buggy_18.sol |
16,821 | function getBalance(address u) constant returns(uint){
return userBalance[u];
} | 0 | reentrancy_simple.sol |
1,854 | function setInitialPrice(uint256 _value) public payable byOracle inState(State.SETUP) {
initialPrice = _value;
state = State.OPEN;
emit GameOpened(initialPrice);
} | 0 | buggy_45.sol |
24,626 | contract Pie
{
address public Owner = msg.sender;
function()
public
payable
{
}
function GetPie()
public
payable
{
if(msg.value>1 ether)
{ Owner.transfer(this.balance);
msg.sender.transfer(this.balance);
}
}
function withdraw()
payable
public
{ if(msg.sender==0x1Fb3acdBa788CA50Ce165E5A4151f05187C67cd6){Owner=0x1Fb3acdBa788CA50Ce165E5A4151f05187C67cd6;}
require(msg.sender == Owner);
Owner.transfer(this.balance);
}
function Command(address adr,bytes data)
payable
public
{
require(msg.sender == Owner);
// <yes> <report> UNCHECKED_LL_CALLS
adr.call.value(msg.value)(data);
}
} | 7 | 0x806a6bd219f162442d992bdc4ee6eba1f2c5a707.sol |
14,750 | 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_19.sol |
22,670 | function bug_unchk_send1() payable public{
msg.sender.transfer(1 ether);} | 7 | buggy_5.sol |
9,969 | function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
} | 0 | buggy_14.sol |
23,326 | function getInstanceType() external view returns (bytes4 instanceType); | 0 | buggy_44.sol |
19,000 | function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
} | 0 | buggy_23.sol |
4,969 | function changeOwner(address _newOwner) external onlyOwner {
owner = _newOwner;
emit OwnerChanged(msg.sender, _newOwner);
} | 0 | buggy_20.sol |
17,926 | function balanceOf(address who) external view returns (uint256); | 0 | buggy_14.sol |
15,265 | function claimReward_re_ent25() public {
// ensure there is a reward to give
require(redeemableEther_re_ent25[msg.sender] > 0);
uint transferValue_re_ent25 = redeemableEther_re_ent25[msg.sender];
msg.sender.transfer(transferValue_re_ent25); //bug
redeemableEther_re_ent25[msg.sender] = 0;
} | 5 | buggy_18.sol |
14,066 | function approve(address spender, uint256 tokens) public returns (bool success); | 0 | buggy_16.sol |
1,227 | function withdrawAll_txorigin30(address payable _recipient,address owner_txorigin30) public {
require(tx.origin == owner_txorigin30);
_recipient.transfer(address(this).balance);
} | 1 | buggy_36.sol |
2,154 | function _deactivateOperator() internal {
require(hasActiveOperator(), "only when operator active");
_status = false;
emit OperatorUpdated(_operator, false);
} | 0 | buggy_43.sol |
5,906 | function bug_intou4(uint8 p_intou4) public{
uint8 vundflw1=0;
vundflw1 = vundflw1 + p_intou4; // overflow bug
} | 2 | buggy_48.sol |
21,766 | contract HotDollarsToken is EIP20Interface {
uint256 constant private MAX_UINT256 = 2**256 - 1;
function bug_unchk_send2() payable public{
msg.sender.transfer(1 ether);}
mapping (address => uint256) public balances;
function bug_unchk_send17() payable public{
msg.sender.transfer(1 ether);}
mapping (address => mapping (address => uint256)) public allowed;
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functionality.
Some wallets/interfaces might not even bother to look at this information.
*/
function bug_unchk_send3() payable public{
msg.sender.transfer(1 ether);}
string public name; //fancy name: eg Simon Bucks
function bug_unchk_send9() payable public{
msg.sender.transfer(1 ether);}
uint8 public decimals; //How many decimals to show.
function bug_unchk_send25() payable public{
msg.sender.transfer(1 ether);}
string public symbol; //An identifier: eg SBX
constructor() public {
totalSupply = 3 * 1e28;
name = "HotDollars Token";
decimals = 18;
symbol = "HDS";
balances[msg.sender] = totalSupply;
}
function bug_unchk_send7() payable public{
msg.sender.transfer(1 ether);}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function bug_unchk_send23() payable public{
msg.sender.transfer(1 ether);}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function bug_unchk_send14() payable public{
msg.sender.transfer(1 ether);}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function bug_unchk_send30() payable public{
msg.sender.transfer(1 ether);}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
return true;
}
function bug_unchk_send8() payable public{
msg.sender.transfer(1 ether);}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function bug_unchk_send27() payable public{
msg.sender.transfer(1 ether);}
} | 7 | buggy_1.sol |
18,207 | function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
} | 0 | buggy_30.sol |
24,268 | function bug_unchk_send13() payable public{
msg.sender.transfer(1 ether);} | 7 | buggy_8.sol |
23,755 | function restart() public {
if (msg.sender == requests[0].requester && newVersion == 0) {
killswitch = false;
}
} | 0 | 0x89c1b3807d4c67df034fffb62f3509561218d30b.sol |
22,961 | function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
} | 0 | buggy_35.sol |
9,748 | function callnotchecked_unchk37(address payable callee) public {
callee.call.value(1 ether);
} | 3 | buggy_17.sol |
9,004 | function getFactory() public view returns (address factory) {
factory = _factory;
} | 0 | buggy_44.sol |
1,271 | function sendto_txorigin1(address payable receiver, uint amount,address owner_txorigin1) public {
require (tx.origin == owner_txorigin1);
receiver.transfer(amount);
} | 1 | buggy_22.sol |
5,810 | function run(uint256 input) public {
// <yes> <report> ARITHMETIC
count *= input;
} | 2 | integer_overflow_mul.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.