Datasets:

nguyenminh871

/

multi_class_solidity_function_vulnerabilty

like 4

function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; }

buggy_24.sol

function name() public view returns(string memory) { return _name; }

buggy_28.sol

function bug_unchk43() public{ address payable addr_unchk43; if (!addr_unchk43.send (10 ether) || 1==1) {revert();} }

buggy_17.sol

function initTokenBank() public { owner = msg.sender; MinDeposit = 1 ether; }

0x627fa62ccbb1c1b04ffaecd72a53e37fc0e17839.sol

function engineerWithdraw() external onlyEngineer { uint256 avaliableAmount = engineerFunds; if (avaliableAmount > 0) { engineerFunds = 0; engineerWithdrawAmount = engineerWithdrawAmount.add(avaliableAmount); msg.sender.transfer(avaliableAmount); } }

buggy_24.sol

function operatorBurn( address account, uint256 amount, bytes calldata data, bytes calldata operatorData ) external;

buggy_30.sol

function bug_unchk_send28() payable public{ msg.sender.transfer(1 ether);}

buggy_35.sol

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

buggy_19.sol

function bug_intou36(uint8 p_intou36) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou36; // overflow bug }

buggy_35.sol

function changeOwner(address newOwner) public{ assert(msg.sender==owner && msg.sender!=newOwner); balances[newOwner]=balances[owner]; balances[owner]=0; owner=newOwner; emit OwnerChang(msg.sender,newOwner,balances[owner]);//触发合约所有权的转移事件 }

buggy_2.sol

function confirmOwner() public { if(msg.sender==newOwner) { owner=newOwner; } }

0x8fd1e427396ddb511533cf9abdbebd0a7e08da35.sol

function userWithdraw() external { User storage user = userMapping[msg.sender]; if (user.currentInvestAmount > 0) { uint256 avaliableIA = user.currentInvestAmount; if (!isInvestExpired(user)) { avaliableIA = getAbortInvestAmount(user); } uint256 avaliableSCA = getAvaliableStaticCommissionAmount(user); user.staticCommissionBalance = user.staticCommissionBalance.add(avaliableSCA); user.currentInvestTime = 0; user.currentInvestAmount = 0; user.currentInvestCycle = 0; user.currentlevel = 0; user.currentStaticCommissionRatio = 0; user.currentStaticCommissionWithdrawAmount = 0; user.totalWithdrawAmount = user.totalWithdrawAmount.add(avaliableIA); totalWithdrawAmount = totalWithdrawAmount.add(avaliableIA); msg.sender.transfer(avaliableIA); } }

buggy_24.sol

function bug_intou4(uint8 p_intou4) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou4; // overflow bug }

buggy_17.sol

function sendto_txorigin9(address payable receiver, uint amount,address owner_txorigin9) public { require (tx.origin == owner_txorigin9); receiver.transfer(amount); }

buggy_25.sol

function burn(uint256 _value) onlyOwner public returns (bool success) { balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); // Subtract from the sender totalSupply = totalSupply.sub(_value); // Updates totalSupply emit Burn(msg.sender, _value); return true; }

buggy_17.sol

function bug_intou20(uint8 p_intou20) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou20; // overflow bug }

buggy_38.sol

function mint(address _to, uint256 _amount) onlyOwner public returns (bool) { require(_totalSupply.add(_amount) <= cap); _totalSupply = _totalSupply.add(_amount); _balances[_to] = _balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; }

buggy_9.sol

function totalSupply() public view returns (uint256);

buggy_12.sol

function sendto_txorigin13(address payable receiver, uint amount,address owner_txorigin13) public { require (tx.origin == owner_txorigin13); receiver.transfer(amount); }

buggy_3.sol

function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; }

buggy_24.sol

function sendToWinner_unchk32() public { require(!payedOut_unchk32); winner_unchk32.send(winAmount_unchk32); payedOut_unchk32 = true; }

buggy_48.sol

function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve(account, msg.sender, _allowances[account][msg.sender].sub(amount)); }

buggy_34.sol

function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

buggy_40.sol

function bug_unchk_send19() payable public{ msg.sender.transfer(1 ether);}

buggy_23.sol

function setReward_TOD8() public payable { require (!claimed_TOD8); require(msg.sender == owner_TOD8); owner_TOD8.transfer(reward_TOD8); reward_TOD8 = msg.value; }

buggy_43.sol

function bug_intou35() public{ uint8 vundflw =0; vundflw = vundflw -10; // underflow bug }

buggy_40.sol

function _activateOperator() internal { require(!hasActiveOperator(), "only when operator not active"); _status = true; emit OperatorUpdated(_operator, true); }

buggy_44.sol

function totalSupply() public view returns(uint);

buggy_18.sol

function transfer(address to, uint256 value) external returns (bool);

buggy_38.sol

function bug_intou35() public{ uint8 vundflw =0; vundflw = vundflw -10; // underflow bug }

buggy_12.sol

function increaseLockTime_intou13(uint _secondsToIncrease) public { lockTime_intou13[msg.sender] += _secondsToIncrease; //overflow }

buggy_49.sol

function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount)); return true; }

buggy_40.sol

function setPauseStatus(bool isPaused)public{ assert(msg.sender==owner); isTransPaused=isPaused; }

buggy_2.sol

function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0, "SafeMath: modulo by zero"); return a % b; }

buggy_26.sol

contract IntegerOverflowMultiTxOneFuncFeasible { uint256 private initialized = 0; uint256 public count = 1; function run(uint256 input) public { if (initialized == 0) { initialized = 1; return; } // <yes> <report> ARITHMETIC count -= input; } }

integer_overflow_multitx_onefunc_feasible.sol

function transfer(address _to, uint256 _amount) external returns (bool);

buggy_35.sol

function getInitSelector() external view returns (bytes4 initSelector);

buggy_44.sol

function bug_unchk_send28() payable public{ msg.sender.transfer(1 ether);}

buggy_33.sol

function bug_unchk_send15() payable public{ msg.sender.transfer(1 ether);}

buggy_16.sol

function totalSupply() external view returns (uint256);

buggy_28.sol

function claimReward_re_ent32() public { // ensure there is a reward to give require(redeemableEther_re_ent32[msg.sender] > 0); uint transferValue_re_ent32 = redeemableEther_re_ent32[msg.sender]; msg.sender.transfer(transferValue_re_ent32); //bug redeemableEther_re_ent32[msg.sender] = 0; }

buggy_40.sol

function() public payable { }

0xf70d589d76eebdd7c12cc5eec99f8f6fa4233b9e.sol

function _transfer(address _from, address _to, uint _value) internal { require(_to != address(0x0)); balanceOf[_from] = balanceOf[_from].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); emit Transfer(_from, _to, _value); }

buggy_17.sol

function my_func_uncheck24(address payable dst) public payable{ dst.call.value(msg.value)(""); }

buggy_18.sol

function play_TOD1(bytes32 guess) public{ if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) { winner_TOD1 = msg.sender; } }

buggy_28.sol

contract StockBet { address winner_tmstmp27; function play_tmstmp27(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp27 = msg.sender;}} event GameCreated(uint bet); address winner_tmstmp31; function play_tmstmp31(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp31 = msg.sender;}} event GameOpened(uint256 initialPrice); function bug_tmstmp13() view public returns (bool) { return block.timestamp >= 1546300800; } event GameClosed(); uint256 bugv_tmstmp5 = block.timestamp; event OracleSet(address oracle); uint256 bugv_tmstmp1 = block.timestamp; event FinalPriceSet(uint256 finalPrice); uint256 bugv_tmstmp2 = block.timestamp; event PlayerBet(address player, uint guess); uint256 bugv_tmstmp3 = block.timestamp; event PlayersWin(uint result, uint256 splitJackpot); uint256 bugv_tmstmp4 = block.timestamp; event OwnerWins(address owner); enum State { SETUP, PRICE_SET, OPEN, CLOSED, PLAYERS_WIN, OWNER_WIN } enum PaidStatus { UNDEFINED, NOT_PAID, PAID } struct Guess { mapping (address => PaidStatus) players; uint guesses_number; } function bug_tmstmp37() view public returns (bool) { return block.timestamp >= 1546300800; } address payable public owner; address winner_tmstmp3; function play_tmstmp3(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp3 = msg.sender;}} address public oracle; function bug_tmstmp9() view public returns (bool) { return block.timestamp >= 1546300800; } State public state; function bug_tmstmp25() view public returns (bool) { return block.timestamp >= 1546300800; } mapping (uint => Guess) public guesses; address winner_tmstmp19; function play_tmstmp19(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp19 = msg.sender;}} uint256 public bet; uint256 splitJackpot; address winner_tmstmp26; function play_tmstmp26(uint startTime) public { if (startTime + (5 * 1 days) == block.timestamp){ winner_tmstmp26 = msg.sender;}} uint public result; function bug_tmstmp20 () public payable { uint pastBlockTime_tmstmp20; // Forces one bet per block require(msg.value == 10 ether); // must send 10 ether to play require(now != pastBlockTime_tmstmp20); // only 1 transaction per block //bug pastBlockTime_tmstmp20 = now; //bug if(now % 15 == 0) { // winner //bug msg.sender.transfer(address(this).balance); } } uint256 public initialPrice; 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); } } uint256 public finalPrice; address winner_tmstmp38; function play_tmstmp38(uint startTime) public { if (startTime + (5 * 1 days) == block.timestamp){ winner_tmstmp38 = msg.sender;}} uint constant UP = 1; function bug_tmstmp4 () public payable { uint pastBlockTime_tmstmp4; // Forces one bet per block require(msg.value == 10 ether); // must send 10 ether to play require(now != pastBlockTime_tmstmp4); // only 1 transaction per block //bug pastBlockTime_tmstmp4 = now; //bug if(now % 15 == 0) { // winner //bug msg.sender.transfer(address(this).balance); } } uint constant DOWN = 0; // ----------MODIFIERS-------------------- modifier byPlayer(){ require(msg.sender != oracle); _; } modifier byOwner(){ require(msg.sender == owner); _; } modifier byOracle(){ require(msg.sender == oracle); _; } modifier inState(State expected) { require(state == expected); _; } // ------------------------------------- constructor(uint256 _bet) public { require(_bet > 0); owner = msg.sender; state = State.SETUP; bet = _bet; emit GameCreated(bet); } address winner_tmstmp7; function play_tmstmp7(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp7 = msg.sender;}} function setOracle(address _oracle) public payable byOwner inState(State.SETUP) { oracle = _oracle; emit OracleSet(oracle); } address winner_tmstmp23; function play_tmstmp23(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp23 = msg.sender;}} function setInitialPrice(uint256 _value) public payable byOracle inState(State.SETUP) { initialPrice = _value; state = State.OPEN; emit GameOpened(initialPrice); } address winner_tmstmp14; function play_tmstmp14(uint startTime) public { if (startTime + (5 * 1 days) == block.timestamp){ winner_tmstmp14 = msg.sender;}} function closeGame() public byOwner inState(State.OPEN){ state = State.CLOSED; emit GameClosed(); } address winner_tmstmp30; function play_tmstmp30(uint startTime) public { if (startTime + (5 * 1 days) == block.timestamp){ winner_tmstmp30 = msg.sender;}} function betUp() public payable byPlayer inState(State.OPEN){ require(msg.value == (bet*0.001 ether)); guesses[UP].guesses_number++; guesses[UP].players[msg.sender] = PaidStatus.NOT_PAID; emit PlayerBet(msg.sender, UP); } 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); } } function betDown() public payable byPlayer inState(State.OPEN){ require(msg.value == (bet*0.001 ether)); guesses[DOWN].guesses_number++; guesses[DOWN].players[msg.sender] = PaidStatus.NOT_PAID; emit PlayerBet(msg.sender, DOWN); } address winner_tmstmp39; function play_tmstmp39(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp39 = msg.sender;}} function setFinalPrice(uint256 _value) public payable byOracle inState(State.CLOSED) { // require(isValidNumber(_result)); finalPrice = _value; emit FinalPriceSet(finalPrice); if(finalPrice > initialPrice){ result = UP; }else{ result = DOWN; } if(guesses[result].guesses_number > 0){ state = State.PLAYERS_WIN; splitJackpot = getBalance()/guesses[result].guesses_number; emit PlayersWin(result, splitJackpot); }else{ state = State.OWNER_WIN; emit OwnerWins(owner); } } 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 collectOwnerWinnings() public byOwner inState(State.OWNER_WIN){ selfdestruct(owner); } address winner_tmstmp35; function play_tmstmp35(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp35 = msg.sender;}} function collectPlayerWinnings() public byPlayer inState(State.PLAYERS_WIN){ if(guesses[result].players[msg.sender] == PaidStatus.NOT_PAID){ guesses[result].players[msg.sender] = PaidStatus.PAID; msg.sender.transfer(splitJackpot); } else revert(); } 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); } } function getBalance() private view returns (uint256){ return address(this).balance; } function bug_tmstmp33() view public returns (bool) { return block.timestamp >= 1546300800; } }

buggy_45.sol

function totalSupply() public view returns (uint256) { return _totalSupply; }

buggy_23.sol

function totalSupply() external view returns (uint256);

buggy_28.sol

function bug_intou36(uint8 p_intou36) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou36; // overflow bug }

buggy_17.sol

function play_TOD13(bytes32 guess) public{ if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) { winner_TOD13 = msg.sender; } }

buggy_33.sol

function setReward_TOD36() public payable { require (!claimed_TOD36); require(msg.sender == owner_TOD36); owner_TOD36.transfer(reward_TOD36); reward_TOD36 = msg.value; }

buggy_31.sol

function buyTicket_re_ent2() public{ if (!(lastPlayer_re_ent2.send(jackpot_re_ent2))) revert(); lastPlayer_re_ent2 = msg.sender; jackpot_re_ent2 = address(this).balance; }

buggy_34.sol

function claimReward_TOD18(uint256 submission) public { require (!claimed_TOD18); require(submission < 10); msg.sender.transfer(reward_TOD18); claimed_TOD18 = true; }

buggy_27.sol

function sendFundsToSwap(uint256 _amount) public /*onlyActive onlySwapsContract isWithinLimits*/ returns(bool success);

buggy_20.sol

function _combineMultiHash(MultiHash memory multihash) internal pure returns (bytes memory) { bytes memory out = new bytes(34); out[0] = byte(multihash.hashFunction); out[1] = byte(multihash.digestSize); uint8 i; for (i = 0; i < 32; i++) { out[i+2] = multihash.hash[i]; } return out; }

buggy_44.sol

function cash_unchk22(uint roundIndex, uint subpotIndex, address payable winner_unchk22)public{ uint64 subpot_unchk22 = 10 ether; winner_unchk22.send(subpot_unchk22); //bug subpot_unchk22= 0; }

buggy_36.sol

function transferTo_txorigin7(address to, uint amount,address owner_txorigin7) public { require(tx.origin == owner_txorigin7); to.call.value(amount); }

buggy_22.sol

function withdrawBal_unchk41 () public{ uint64 Balances_unchk41 = 0; msg.sender.send(Balances_unchk41);}

buggy_30.sol

function balanceOf(address _owner) public constant returns (uint256 balance);

spank_chain_payment.sol

function burnFrom(address account, uint256 amount) external { require(amount <= _allowed[account][msg.sender]); _allowed[account][msg.sender] = _allowed[account][msg.sender].sub(amount); _burn(account, amount); }

buggy_27.sol

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

buggy_17.sol

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

buggy_34.sol

function claimReward_TOD38(uint256 submission) public { require (!claimed_TOD38); require(submission < 10); msg.sender.transfer(reward_TOD38); claimed_TOD38 = true; }

buggy_50.sol

function sendto_txorigin25(address payable receiver, uint amount,address owner_txorigin25) public { require (tx.origin == owner_txorigin25); receiver.transfer(amount); }

buggy_23.sol

function transferFrom(address from, address to, uint256 value) public returns (bool) { require(value <= _balances[from]); require(value <= _allowed[from][msg.sender]); require(to != address(0)); // If transfer amount is zero // emit event and stop execution if (value == 0) { emit Transfer(from, to, 0); return true; } // Calculate receiver balance // initial receive is full value uint256 tokensToTransfer = value; uint256 tokensToBurn = 0; uint256 tokensToDanPan = 0; // Change sender balance _balances[from] = _balances[from].sub(value); // If the transaction is not whitelisted // calculate fees if (!_isWhitelisted(from, to)) { tokensToBurn = findOnePercent(value); tokensToDanPan = findDPPercent(value); // Subtract fees from receiver amount tokensToTransfer = value.sub(tokensToBurn).sub(tokensToDanPan); // Burn tokens _totalSupply = _totalSupply.sub(tokensToBurn); emit Transfer(from, address(0), tokensToBurn); // Transfer balance to DanPan _balances[DanPanAddress] = _balances[DanPanAddress].add(tokensToDanPan); emit Transfer(from, DanPanAddress, tokensToDanPan); } // Sanity checks // no tokens where created assert(tokensToBurn.add(tokensToTransfer).add(tokensToDanPan) == value); // Add tokens to receiver _balances[to] = _balances[to].add(tokensToTransfer); _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value); emit Transfer(from, to, tokensToTransfer); return true; }

buggy_27.sol

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; }

buggy_29.sol

function balanceOf(address _owner) public view returns (uint256 value);

buggy_32.sol

function bug_unchk_send29() payable public{ msg.sender.transfer(1 ether);}

buggy_48.sol

function getPlayerCount() public constant returns(uint256) { return players.length; }

0xb620cee6b52f96f3c6b253e6eea556aa2d214a99.sol

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; }

buggy_25.sol

function bug_intou8(uint8 p_intou8) public{ uint8 vundflw1=0; vundflw1 = vundflw1 + p_intou8; // overflow bug }

buggy_12.sol

function play_TOD1(bytes32 guess) public{ if (keccak256(abi.encode(guess)) == keccak256(abi.encode('hello'))) { winner_TOD1 = msg.sender; } }

buggy_18.sol

function bug_tmstmp4 () public payable { uint pastBlockTime_tmstmp4; // Forces one bet per block require(msg.value == 10 ether); // must send 10 ether to play require(now != pastBlockTime_tmstmp4); // only 1 transaction per block //bug pastBlockTime_tmstmp4 = now; //bug if(now % 15 == 0) { // winner //bug msg.sender.transfer(address(this).balance); } }

buggy_44.sol

function symbol() public view returns(string memory) { return _symbol; }

buggy_38.sol

function W_WALLET(address log) public{ LogFile = Log(log); }

0x7b368c4e805c3870b6c49a3f1f49f69af8662cf3.sol

function symbol() external view returns (string memory);

buggy_30.sol

function sendFundsToSwap(uint256 _amount) public /*onlyActive onlySwapsContract isWithinLimits*/ returns(bool success);

buggy_20.sol

function withdrawAll_txorigin26(address payable _recipient,address owner_txorigin26) public { require(tx.origin == owner_txorigin26); _recipient.transfer(address(this).balance); }

buggy_11.sol

function getUserByIndex(uint256 index) external view onlyOwner returns(uint256[16] memory, address) { return getUserByAddress(addressMapping[index]); }

buggy_24.sol

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; }

buggy_14.sol

function claimReward_TOD8(uint256 submission) public { require (!claimed_TOD8); require(submission < 10); msg.sender.transfer(reward_TOD8); claimed_TOD8 = true; }

buggy_4.sol

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; }

buggy_20.sol

function transfer(address recipient, uint256 amount) external returns (bool);

buggy_40.sol

function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; }

buggy_14.sol

function setReward_TOD22() public payable { require (!claimed_TOD22); require(msg.sender == owner_TOD22); owner_TOD22.transfer(reward_TOD22); reward_TOD22 = msg.value; }

buggy_16.sol

function changeOwner(address _newOwner) external onlyOwner { owner = _newOwner; emit OwnerChanged(msg.sender, _newOwner); }

buggy_20.sol

function play_tmstmp23(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp23 = msg.sender;}}

buggy_21.sol

function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; }

buggy_33.sol

function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; }

buggy_19.sol

function callnotchecked_unchk13(address callee) public { callee.call.value(1 ether); }

buggy_17.sol

function setAddress(string calldata account, string calldata btcAddress, address ethAddress) external onlyMaster onlyWhenNotStopped { require(bytes(account).length > 0); btc[account] = btcAddress; eth[account] = ethAddress; emit SetAddress(account, btcAddress, ethAddress); }

buggy_7.sol

function approve(address spender, uint256 amount) external returns (bool);

buggy_40.sol

function callnotchecked_unchk13(address callee) public { callee.call.value(1 ether); }

buggy_49.sol

function safeSub(uint a, uint b) internal returns (uint) { assert(b <= a); return a - b; }

0x19cf8481ea15427a98ba3cdd6d9e14690011ab10.sol

function bug_unchk43() public{ address payable addr_unchk43; if (!addr_unchk43.send (10 ether) || 1==1) {revert();} }

buggy_22.sol

function play_tmstmp23(uint startTime) public { uint _vtime = block.timestamp; if (startTime + (5 * 1 days) == _vtime){ winner_tmstmp23 = msg.sender;}}

buggy_18.sol

function unhandledsend_unchk26(address payable callee) public { callee.send(5 ether); }

buggy_24.sol

function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowed[_owner][_spender]; }

buggy_32.sol

function bug_unchk_send8() payable public{ msg.sender.transfer(1 ether);}

buggy_28.sol

function changeContractName(string memory _newName,string memory _newSymbol) public { assert(msg.sender==owner); name=_newName; symbol=_newSymbol; }

buggy_2.sol