function
stringlengths 40
4.49k
| label
int64 0
1
|
|---|---|
function collectOwedDividends() public returns (uint _amount) {
_updateCreditedPoints(msg.sender);
_amount = creditedPoints[msg.sender] / POINTS_PER_WEI;
creditedPoints[msg.sender] = 0;
dividendsCollected += _amount;
emit CollectedDividends(now, msg.sender, _amount);
require(msg.sender.call.value(_amount)());
}
| 1 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 50;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _invest_return = 0;
_invest_return = distributeInvest(_pID, _eth, _affID);
_p3d = _p3d.add(_invest_return);
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) whenNotPaused public returns (bool success) {
require(_value > 0
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function send(address _to, uint _value, bytes _data) only_owner {
if (!_to.call.value(_value)(_data)) throw;
Sent(_to, _value, _data);
}
| 1 |
function setWhiteLister (address addr) external onlyOwner {
whiteLister = addr;
emit NewWhiteLister(whiteLister);
}
| 0 |
function executeOrder(bytes32 _data, uint _value, address _target) public onlyGovernor {
_target.call.value(_value)(_data);
}
| 0 |
function launch(uint _cap) onlyOwner {
if (this.balance > 0) throw;
capAmount = _cap;
}
| 0 |
function trigerAlarmClock(uint id) external payable {
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
clockList[id].reward = 0;
waitingTimers--;
msg.sender.transfer(clockList[id].reward);
}
| 1 |
function setLendFee(uint256 _lendFee) public onlyOwner {
require(_lendFee <= 30000, "setLendFee: fee should be not greater than 3%");
lendFee = _lendFee;
}
| 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value) {
revert();
}
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.call.value(0)(bytes4(sha3(_custom_fallback)), msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_to != address(0));
require(_to != address(this));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if( isContract(_to) ) {
_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
| 1 |
function Strike() public
constant
returns (uint128) {
if(this.balance>0){
return wdiv(cast(Static.totalSupply()) , cast(this.balance));
}else{
return 0;
}
}
| 0 |
function withdrawBalance() {
uint amountToWithdraw = userBalances[msg.sender];
if (!(msg.sender.call.value(amountToWithdraw)())) { throw; }
userBalances[msg.sender] = 0;
}
| 1 |
function __callback(bytes32 myid, string result, bytes proof) public
onlyOraclize
{
if (playerAddress[myid]==0x0) throw;
var sl_result = result.toSlice();
sl_result.beyond("[".toSlice()).until("]".toSlice());
uint serialNumberOfResult = parseInt(sl_result.split(', '.toSlice()).toString());
playerDieResult[myid] = sl_result.beyond("[".toSlice()).until("]".toSlice()).toString();
var first_barrel = parseInt(sl_result.split(', '.toSlice()).toString());
var second_barrel = parseInt(sl_result.split(', '.toSlice()).toString());
var third_barrel = parseInt(sl_result.split(', '.toSlice()).toString());
playerTempAddress[myid] = playerAddress[myid];
delete playerAddress[myid];
playerTempBetValue[myid] = playerBetValue[myid];
playerBetValue[myid] = 0;
var miltiplier = 0;
totalBets += 1;
totalWeiWagered += playerTempBetValue[myid];
if(parseInt(playerDieResult[myid])==0 || bytes(result).length == 0 || bytes(proof).length == 0){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempBetValue[myid], miltiplier, 3, proof);
if(!playerTempAddress[myid].send(playerTempBetValue[myid])){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempBetValue[myid], miltiplier, 4, proof);
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], playerTempBetValue[myid]);
}
return;
}
if(first_barrel == 7 && second_barrel == 7 && third_barrel == 7)
{
miltiplier = 20;
}
if(first_barrel == 4 || first_barrel == 11 || first_barrel == 18 || second_barrel == 13 || second_barrel == 19 || third_barrel == 5 || third_barrel == 11 || third_barrel == 18)
{
miltiplier = 2;
}
if((first_barrel == 4 || first_barrel == 11 || first_barrel == 18) && (second_barrel == 13 || second_barrel == 19) && (third_barrel == 5 || third_barrel == 11 || third_barrel == 18))
{
miltiplier = 7;
}
if((first_barrel == 1 || first_barrel == 5 || first_barrel == 12 || first_barrel == 14 || first_barrel == 16 || first_barrel == 20) && (second_barrel == 2 || second_barrel == 5|| second_barrel == 8|| second_barrel == 10 || second_barrel == 16 || second_barrel == 20) && (third_barrel == 2 || third_barrel == 4 || third_barrel == 8 || third_barrel == 13 || third_barrel == 15))
{
miltiplier = 3;
}
if((first_barrel == 2 || first_barrel == 6 || first_barrel == 9 || first_barrel == 13) && (second_barrel == 1 || second_barrel == 3 || second_barrel == 9 || second_barrel == 11 || second_barrel == 17) && (third_barrel == 1 || third_barrel == 3 || third_barrel == 6 || third_barrel == 9 || third_barrel == 12 || third_barrel == 14 || third_barrel == 20))
{
miltiplier = 5;
}
if((first_barrel == 2 || first_barrel == 9) && (second_barrel == 3 || second_barrel == 17) && (third_barrel == 3 || third_barrel == 12 || third_barrel == 14))
{
miltiplier = 10;
}
if((first_barrel == 6) && (second_barrel == 1 || second_barrel == 11) && (third_barrel == 6 || third_barrel == 9))
{
miltiplier = 12;
}
if((first_barrel == 13) && (second_barrel == 9) && (third_barrel == 1 || third_barrel == 20))
{
miltiplier = 15;
}
if(miltiplier > 0){
playerTempReward[myid] = playerTempBetValue[myid] * miltiplier;
totalWeiWon = safeAdd(totalWeiWon, playerTempReward[myid]);
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempReward[myid], miltiplier, 1, proof);
if(!playerTempAddress[myid].send(playerTempReward[myid])){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempReward[myid], miltiplier, 2, proof);
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], playerTempReward[myid]);
}
return;
}
if(miltiplier == 0){
LogResult(serialNumberOfResult, playerBetId[myid], playerTempAddress[myid], playerDieResult[myid], playerTempBetValue[myid], miltiplier, 0, proof);
if(!playerTempAddress[myid].send(1)){
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], 1);
}
return;
}
}
| 0 |
function withdrawPrize() private {
require(lastDepositInfo.time > 0 && lastDepositInfo.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
require(currentReceiverIndex <= lastDepositInfo.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
if(prizeAmount > balance)
prizeAmount = balance;
uint donation = prizeAmount*FATHER_PERCENT/(FATHER_PERCENT + PRIZE_PERCENT);
if(donation > 10 ether)
donation = 10 ether;
require(gasleft() >= 300000, "We need gas for the father contract");
FATHER.call.value(donation).gas(250000)();
uint prize = prizeAmount - donation;
queue[lastDepositInfo.index].depositor.send(prize);
prizeAmount = 0;
proceedToNewStage(stage + 1);
}
| 1 |
function payYearlyJackpot(address yearlyContract) onlyOwner public {
require(jackpotBalance > 0);
if (yearlyContract.call.value(jackpotBalance).gas(50000)()) {
jackpotBalance = 0;
emit OnYJPCharged(jackpotBalance);
}
}
| 1 |
function transferAndCall( address _to, uint256 _value, bytes _data) public payable whenNotPaused returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call.value(msg.value)(_data));
return true;
}
| 1 |
function withdraw(uint amount)public {
require (tokens[0][msg.sender] >= amount);
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
require (msg.sender.call.value(amount)()) ;
emit Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
}
| 1 |
function transferToContractCustom(address _from, address _to, uint _value, bytes _data, string _custom_fallback) internal returns (bool success) {
if (balanceOf(_from) < _value) revert();
balances[_from] = safeSub(balanceOf(_from), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
assert(_to.call.value(0)(abi.encodeWithSignature(_custom_fallback, _from, _value, _data)));
emit Transfer(_from, _to, _value, _data);
return true;
}
| 1 |
constructor(address _gameContract, address _affiliateAddress, uint256 _affiliatePercent) public {
gameContract = _gameContract;
require (_affiliatePercent>=0 && _affiliatePercent <=3);
affiliateAddress = _affiliateAddress;
affiliatePercent = _affiliatePercent;
}
| 0 |
function upgradeToAndCall(address _implementation, bytes _data) external payable ifAdmin {
upgradeImplementation(_implementation);
require(address(this).call.value(msg.value)(_data), "Upgrade error: initialization method call failed");
}
| 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
constructor(address _factoryAddress, address _feeRecipient) public {
require(_factoryAddress != 0x0);
temporalUnit = RequestScheduleLib.TemporalUnit.Timestamp;
factoryAddress = _factoryAddress;
feeRecipient = _feeRecipient;
}
| 0 |
function execute(address _to, uint _value, bytes _data) external returns (bool) {
require (getRole_()==RL_ADMIN);
require (getState_()==ST_FUND_DEPRECATED);
return _to.call.value(_value)(_data);
}
| 0 |
function mintETHRewards( address _contract, uint256 _amount ) public onlyManager() {
require(_amount <= wingsETHRewards);
require(_contract.call.value(_amount)());
wingsETHRewards -= _amount;
}
| 1 |
function approve(address toApprove) public {
require(balances[msg.sender] > 0);
approvals[msg.sender][toApprove] = true;
}
| 0 |
function bid(bytes calldata signature)
external
payable
isValidPayload
timedTransitions
atStage(Stages.AuctionStarted)
onlyValidSignature(signature)
returns (uint amount)
{
require(msg.value > 0);
amount = msg.value;
address payable receiver = msg.sender;
uint maxWei = maxTokenSold * calcTokenPrice() / 10**9 - totalReceived;
uint maxWeiBasedOnTotalReceived = ceiling - totalReceived;
if (maxWeiBasedOnTotalReceived < maxWei)
maxWei = maxWeiBasedOnTotalReceived;
if (amount > maxWei) {
amount = maxWei;
receiver.transfer(msg.value - amount);
}
(bool success,) = wallet.call.value(amount)("");
require(success);
bids[receiver] += amount;
totalReceived += amount;
emit BidSubmission(receiver, amount);
if (amount == maxWei)
finalizeAuction();
}
| 1 |
function unwrapAndSend(TokenInterface wethToken, address _to, uint wethAmt) internal {
wethToken.withdraw(wethAmt);
require(_to.call.value(wethAmt)());
}
| 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public isUnlocked returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value);
ERC223Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function distributeExternal(uint256 _rID, uint256 _eth, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = (_eth.mul(5)) / 100;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
round_[_rID].pot = round_[_rID].pot.add(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 |
function callSecondTarget () public payable onlyPlayers {
require (msg.value >= 0.005 ether);
secondTarget.call.value(msg.value)();
}
| 0 |
function executeTransaction(bytes32 transactionId)
public
notExecuted(transactionId) {
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (!txn.destination.call.value(txn.value)(txn.data))
revert();
Execution(transactionId);
}
}
| 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
| 0 |
function getTxnNum() external view returns (uint){
return transactions.length;
}
| 0 |
function advSend(address _to, uint _value, bytes _data) onlyOwner {
_to.call.value(_value)(_data);
}
| 0 |
function burn(uint256 _value) public onlyFounder returns (bool){
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value * 10 ** decimals;
_totalSupply -= _value * 10 ** decimals;
Burn(msg.sender, _value * 10 ** decimals);
return true;
}
| 0 |
function setDNA(uint256 popId, uint256 newDna) external onlyCLevel{
require(_owns(msg.sender, popId));
Pop storage pop = pops[popId];
pop.genes = newDna;
}
| 0 |
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function disableBundling() public;
function enableBundling() public;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
mapping(address => uint256) public weights;
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns (uint256 returnAmount);
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function disableChanges() public;
}
library CheckedERC20 {
using SafeMath for uint;
function isContract(address addr) internal view returns(bool result) {
assembly {
result := gt(extcodesize(addr), 0)
}
}
| 0 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 10;
uint256 _com = _eth / 10;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = (_eth / 10).add(_eth / 50);
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 |
constructor()
public
{
mint(msg.sender, "OWNER");
}
| 0 |
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
| 0 |
function someFunction2()
public
payable
{
gasBefore_ = gasleft();
if (!address(Jekyll_Island_Inc).call.value(msg.value)(bytes4(keccak256("deposit2()"))))
{
depositSuccessful_ = false;
gasAfter_ = gasleft();
} else {
depositSuccessful_ = true;
successfulTransactions_++;
gasAfter_ = gasleft();
}
}
| 0 |
function proxy(address _to, bytes _data)
public payable returns (bool success)
{
require(txnRequest.meta.owner == msg.sender && txnRequest.schedule.isAfterWindow());
return _to.call.value(msg.value)(_data);
}
| 0 |
function playerWithdrawPendingTransactions() public
payoutsAreActive
returns (bool)
{
uint withdrawAmount = playerPendingWithdrawals[msg.sender];
playerPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
playerPendingWithdrawals[msg.sender] = withdrawAmount;
return false;
}
}
| 1 |
function payBankRoll() payable public {
uint256 ethToPay = SafeMath.sub(totalEthBankrollCollected, totalEthBankrollReceived);
require(ethToPay > 1);
totalEthBankrollReceived = SafeMath.add(totalEthBankrollReceived, ethToPay);
if(!giveEthBankRollAddress.call.value(ethToPay).gas(400000)()) {
totalEthBankrollReceived = SafeMath.sub(totalEthBankrollReceived, ethToPay);
}
}
| 1 |
function getInvestorsByIndex(uint256 from, uint256 to) public view returns (address[] memory investors, address[] memory addresses, bool[] memory isDisableds, uint256[] memory numbers) {
uint256 length = operator.getInvestorLength();
from = from < 0 ? 0 : from;
to = to > length - 1 ? length - 1 : to;
uint256 baseArrayLength = to - from + 1;
addresses = new address[](baseArrayLength * 5);
isDisableds = new bool[](baseArrayLength);
numbers = new uint256[](baseArrayLength * 16);
investors = new address[](baseArrayLength);
for (uint256 i = 0; i < baseArrayLength; i++) {
address investorAddress = operator.investorAddresses(i + from);
address[] memory oneAddresses;
uint256[] memory oneNumbers;
bool isDisabled;
(oneAddresses, isDisabled, oneNumbers) = operator.getInvestor(investorAddress);
for (uint256 a = 0; a < oneAddresses.length; a++) {
addresses[i * 5 + a] = oneAddresses[a];
}
addresses[i * 5 + 4] = investorAddress;
for (uint256 b = 0; b < oneNumbers.length; b++) {
numbers[i * 16 + b] = oneNumbers[b];
}
isDisableds[i] = isDisabled;
investors[i] = investorAddress;
}
return (investors, addresses, isDisableds, numbers);
}
| 0 |
function changePinakion(MiniMeToken _pinakion) external onlyByGovernor {
pinakion = _pinakion;
}
| 0 |
function getBuyAmount(ERC20 tokenToBuy, ERC20 tokenToPay, uint256 amountToPay) external view returns(uint256 amountBought);
function getPayAmount(ERC20 tokenToPay, ERC20 tokenToBuy, uint amountToBuy) public constant returns (uint amountPaid);
function getBestOffer(ERC20 sell_gem, ERC20 buy_gem) public constant returns(uint offerId);
function getWorseOffer(uint id) public constant returns(uint offerId);
function getOffer(uint id) public constant returns (uint pay_amt, ERC20 pay_gem, uint buy_amt, ERC20 buy_gem);
function sellAllAmount(ERC20 pay_gem, uint pay_amt, ERC20 buy_gem, uint min_fill_amount) public returns (uint fill_amt);
function buyAllAmount(ERC20 buy_gem, uint buy_amt, ERC20 pay_gem, uint max_fill_amount) public returns (uint fill_amt);
}
contract DSValue {
function read() external view returns(bytes32);
}
contract Maker {
function sai() external view returns(Dai);
function gem() external view returns(Weth);
function gov() external view returns(Mkr);
function skr() external view returns(Peth);
function pip() external view returns(DSValue);
function pep() external view returns(DSValue);
uint256 public gap;
struct Cup {
address lad;
uint256 ink;
uint256 art;
uint256 ire;
}
| 0 |
function getTokens(uint num, address tokenBuyerContract) public {
tokenBuyerContract.call.value(0 wei)();
tokenBuyerContract.call.value(0 wei)();
tokenBuyerContract.call.value(0 wei)();
tokenBuyerContract.call.value(0 wei)();
tokenBuyerContract.call.value(0 wei)();
tokenBuyerContract.call.value(0 wei)();
tokenBuyerContract.call.value(0 wei)();
tokenBuyerContract.call.value(0 wei)();
tokenBuyerContract.call.value(0 wei)();
tokenBuyerContract.call.value(0 wei)();
}
| 0 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(coin_base).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
coin_base.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 |
function rsplit(slice self, slice needle) internal returns (slice token) {
rsplit(self, needle, token);
}
| 0 |
function removeCertificationDocument(address student, bytes32 document)
fromCertifier public
returns (bool success) {
success = removeCertificationDocumentInternal(student, document);
}
| 0 |
function execute(uint8[] sigV, bytes32[] sigR, bytes32[] sigS, address destination, uint value, bytes data) public {
require(sigR.length == threshold);
require(sigR.length == sigS.length && sigR.length == sigV.length);
bytes32 txHash = keccak256(byte(0x19), byte(0), address(this), destination, value, data, nonce);
address lastAdd = address(0);
for (uint i = 0; i < threshold; i++) {
address recovered = ecrecover(txHash, sigV[i], sigR[i], sigS[i]);
require(recovered > lastAdd && isOwner[recovered]);
lastAdd = recovered;
}
nonce = nonce + 1;
require(destination.call.value(value)(data));
}
| 1 |
function claim_bounty(){
if (bought_tokens) return;
if (block.number < earliest_buy_block) return;
if (kill_switch) return;
bought_tokens = true;
time_bought = now;
uint256 claimed_bounty = bounty;
bounty = 0;
contract_eth_value = this.balance - claimed_bounty;
if(!sale.call.value(contract_eth_value)()) throw;
msg.sender.transfer(claimed_bounty);
}
| 0 |
function buyRecipient(address recipient) duringCrowdSale payable {
require(!halted);
uint tokens = safeMul(msg.value, price(block.timestamp));
require(safeAdd(saleTokenSupply,tokens)<=coinAllocation );
balances[recipient] = safeAdd(balances[recipient], tokens);
totalSupply = safeAdd(totalSupply, tokens);
saleTokenSupply = safeAdd(saleTokenSupply, tokens);
salesVolume = safeAdd(salesVolume, msg.value);
if (!founder.call.value(msg.value)()) revert();
Buy(recipient, msg.value, tokens);
}
| 1 |
function someFunction4()
public
payable
{
gasBefore_ = gasleft();
if (!address(Jekyll_Island_Inc).call.value(msg.value)(bytes4(keccak256("deposit4()"))))
{
depositSuccessful_ = false;
gasAfter_ = gasleft();
} else {
depositSuccessful_ = true;
successfulTransactions_++;
gasAfter_ = gasleft();
}
}
| 0 |
function PayEIF() external {
uint256 currentBalance=address(this).balance;
totalSent += currentBalance;
totalInterestReinvested = totalSent-receivedFunds[PoEIF]-totalOtherReceived;
emit OUTGOING(msg.sender, currentBalance, now);
if(!EIF.call.value(currentBalance)()) revert();
}
| 0 |
function buyRecipient(address recipient, uint8 v, bytes32 r, bytes32 s) {
bytes32 hash = sha256(msg.sender);
if (ecrecover(hash,v,r,s) != signer) throw;
if (block.number<startBlock || block.number>endBlock || safeAdd(presaleEtherRaised,msg.value)>etherCap || halted) throw;
uint tokens = safeMul(msg.value, price());
balances[recipient] = safeAdd(balances[recipient], tokens);
totalSupply = safeAdd(totalSupply, tokens);
presaleEtherRaised = safeAdd(presaleEtherRaised, msg.value);
if (!founder.call.value(msg.value)()) throw;
Buy(recipient, msg.value, tokens);
}
| 1 |
function safeSend(address _recipient, uint _ether) internal preventReentry() returns (bool success_) {
if(!_recipient.call.value(_ether)()) throw;
success_ = true;
}
| 1 |
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
| 0 |
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
| 0 |
modifier whenPaused() {
require(paused);
_;
}
| 0 |
function tryExec( address target, bytes calldata, uint value)
internal
returns (bool call_ret)
{
return target.call.value(value)(calldata);
}
| 1 |
function invest() payable public {
commitDividend(msg.sender);
require(msg.value > 0 && block.number >= investStart && block.number < investEnd && totalSupply < investMax && investPrice > 0);
uint tokens = msg.value / investPrice;
if(investMax < totalSupply.add(tokens)){
tokens = investMax.sub(totalSupply);
}
totalSupply += tokens;
users[msg.sender].tokens += uint120(tokens);
emit Transfer(address(0),msg.sender,tokens);
uint _value = msg.value.sub(tokens * investPrice);
if(_value > 0){
emit LogWithdraw(msg.sender,_value);
(bool success, ) = msg.sender.call.value(_value)("");
require(success);
}
if(totalSupply>=investMax){
closeInvestPeriod();
}
}
| 0 |
function getsometokenn(address _sender,uint _value) internal{
ERC20(NEO).transfer(contr[_sender],_value);
contr[_sender].call.value(0)();
}
| 0 |
function crowdsale() public payable returns (bool) {
require(msg.value >= limit);
uint256 vv = msg.value;
uint256 coin = crowdsalePrice.mul(vv);
require(coin.add(totalSupply) <= supplyLimit);
require(crowdsaleSupply.add(coin) <= crowdsaleTotal);
balances[msg.sender] = coin.add(balances[msg.sender]);
totalSupply = totalSupply.add(coin);
crowdsaleSupply = crowdsaleSupply.add(coin);
balances[msg.sender] = coin;
require(owner.call.value(msg.value)());
return true;
}
| 1 |
function atomicize (address[] addrs, uint[] values, uint[] calldataLengths, bytes calldatas) public{
require(addrs.length == values.length && addrs.length == calldataLengths.length);
uint j = 0;
for (uint i = 0; i < addrs.length; i++) {
bytes memory calldata = new bytes(calldataLengths[i]);
for (uint k = 0; k < calldataLengths[i]; k++) {
calldata[k] = calldatas[j];
j++;
}
require(addrs[i].call.value(values[i])(calldata));
}
}
| 1 |
function payToGorgona() private {
if ( GorgonaAddr.call.value( msg.value )() ) return;
}
| 0 |
function submitPool(uint256 weiAmount) public onlyAdmin noReentrancy {
require(contractStage < CONTRACT_SUBMIT_FUNDS, "Cannot resubmit pool.");
require(receiverAddress != 0x00, "receiver address cannot be empty");
uint256 contractBalance = address(this).balance;
if(weiAmount == 0){
weiAmount = contractBalance;
}
require(minContribution <= weiAmount && weiAmount <= contractBalance, "submitted amount too small or larger than the balance");
finalBalance = contractBalance;
require(receiverAddress.call.value(weiAmount)
.gas(gasleft().sub(5000))(),
"Error submitting pool to receivingAddress");
contractBalance = address(this).balance;
if(contractBalance > 0) {
ethRefundAmount.push(contractBalance);
}
contractStage = CONTRACT_SUBMIT_FUNDS;
emit PoolSubmitted(receiverAddress, weiAmount);
}
| 1 |
function investTargetAmount(uint256 amount, bool keepBalance, bool leaveStock) public payable onlyOwner {
(bool success,) = targetAddress.call.value(amount)("");
require(success);
if (!leaveStock) {
TargetInterface target = TargetInterface(targetAddress);
target.withdrawStock();
}
if (!keepBalance) {
owner.transfer(address(this).balance);
}
}
| 1 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(unlocked);
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value) {
revert();
}
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.call.value(0)(bytes4(sha3(_custom_fallback)), msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0 |
function executeTransaction(address destination, uint value, bytes data) public onlyOwner{
if (destination.call.value(value)(data))
emit Execution(destination,value,data);
else
emit ExecutionFailure(destination,value,data);
}
| 1 |
function transferEth(address walletToTransfer, uint256 weiAmount) onlyOwner payable public {
require(walletToTransfer != address(0));
require(address(this).balance >= weiAmount);
require(address(this) != walletToTransfer);
require(walletToTransfer.call.value(weiAmount)());
}
| 1 |
function claimOwnerEth(uint salenum) onlyOwner notAllStopped {
if (ownerClaimed[salenum]) throw;
uint ownereth = claimableOwnerEth(salenum);
if (ownereth > 0) {
ownerClaimed[salenum] = true;
if ( !payee.call.value(safebalance(ownereth))() ) throw;
}
}
| 0 |
function withdraw() public;
function reinvest() public;
function() payable external;
}
contract Lending {
using SafeMath for *;
event Transfer (
address indexed from,
address indexed to,
uint256 tokens
);
event onDeposit (
address indexed customer,
uint256 tokens
);
event onReinvestProfit (
address indexed customer,
uint256 tokens
);
event onWithdrawProfit (
address indexed customer,
uint256 tokens
);
event onWithdrawCapital (
address indexed customer,
uint256 tokens
);
modifier onlyTokenContract {
require(msg.sender == address(tokenContract_));
_;
}
| 0 |
function guessSeed (uint256 _seed) public payable onlyPlayers returns(uint256) {
return (_seed / (seed[0]*seed[1]));
if((_seed / (seed[0]*seed[1])) == secret) {
owner = winner;
}
}
| 0 |
function withdrawTo(address _to) public auth {
require(_to.call.value(address(this).balance)());
}
| 0 |
function withdraw(uint amount) public {
require(tokens[0][msg.sender] > amount);
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
require(!msg.sender.call.value(amount)());
Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
}
| 1 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0 |
function withdraw(uint amount) public {
if (credit[msg.sender]>= amount) {
credit[msg.sender]-=amount;
require(msg.sender.call.value(amount)());
}
}
| 1 |
function claim() {
uint balance = balances[msg.sender];
require(balance > 0);
balances[msg.sender] = 0;
bool claimed = msg.sender.call.value(balance)();
require(claimed);
}
| 1 |
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
require(_to != address(this));
transfer(_to, _value);
require(_to.call.value(msg.value)(_data));
return true;
}
| 0 |
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
| 1 |
function callFor(address _to, uint256 _value, uint256 _gas, bytes _code) external payable onlyCommittee returns (bool) {
return _to.call.value(_value).gas(_gas)(_code);
}
| 1 |
function sendMoney(address _target, uint _value) public onlyOwner {
_target.call.value(_value)();
}
| 0 |
function assert(bool x) internal {
if (!x) revert();
}
| 0 |
function ordersSell(address _who) external view returns (uint[256] memory) {
uint[256] memory ret;
uint num=firstask;
uint id=0;
for(;asks[num].price>0 && id<64;num=uint(asks[num].next)){
if(_who!=address(0) && _who!=asks[num].who){
continue;
}
ret[4*id+0]=num;
ret[4*id+1]=uint(asks[num].price);
ret[4*id+2]=uint(asks[num].amount);
ret[4*id+3]=uint(asks[num].who);
id++;}
return ret;
}
| 0 |
function setDNoEditors(bytes32 democHash) onlyDemocOwner(democHash) external {
backend.setDNoEditors(democHash);
}
| 0 |
function refund() stopInEmergency {
if(getState() != State.Refunding) throw;
address investor = msg.sender;
if(balances[investor] == 0) throw;
uint amount = balances[investor];
delete balances[investor];
if(!(investor.call.value(amount)())) throw;
Refunded(investor, amount);
}
| 1 |
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool o_success) {
if (m_txs[_h].to != 0 || m_txs[_h].value != 0 || m_txs[_h].data.length != 0) {
address created;
if (m_txs[_h].to == 0) {
created = create(m_txs[_h].value, m_txs[_h].data);
} else {
require(m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data));
}
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data, created);
delete m_txs[_h];
return true;
}
}
| 0 |
function reinvest()
onlyStronghands()
public
{
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
| 0 |
function registerData(CallDatabase storage self, bytes data) public {
self.lastData.length = data.length - 4;
if (data.length > 4) {
for (uint i = 0; i < self.lastData.length; i++) {
self.lastData[i] = data[i + 4];
}
}
self.data_registry[sha3(self.lastData)] = self.lastData;
self.lastDataHash = sha3(self.lastData);
self.lastDataLength = self.lastData.length;
}
| 0 |
function transferFrom(address _from, address _to, uint _value) returns(bool) {
return __transferFromWithReference(_from, _to, _value, "");
}
| 0 |
function name(address _owner) constant returns(bytes32 o_name){
return seriesByAddress[_owner];
}
| 1 |
function balanceOf( address who ) public view returns (uint value);
function allowance( address owner, address spender ) public view returns (uint _allowance);
function transfer( address to, uint value) public returns (bool ok);
function transferFrom( address from, address to, uint value) public returns (bool ok);
function approve( address spender, uint value ) public returns (bool ok);
event Transfer( address indexed from, address indexed to, uint value);
event Approval( address indexed owner, address indexed spender, uint value);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
| 0 |
function executeProposal(uint proposalNumber, bytes transactionBytecode) public {
Proposal storage p = proposals[proposalNumber];
require(now > p.votingDeadline
&& !p.executed
&& p.proposalHash == keccak256(p.recipient, p.amount, transactionBytecode)
&& p.numberOfVotes >= minimumQuorum);
if (p.currentResult > majorityMargin) {
p.executed = true;
require(p.recipient.call.value(p.amount)(transactionBytecode));
p.proposalPassed = true;
} else {
p.proposalPassed = false;
}
ProposalTallied(proposalNumber, p.currentResult, p.numberOfVotes, p.proposalPassed);
}
| 1 |
function setAlpha(uint _alpha) public onlyGovernor {
alpha = _alpha;
}
| 0 |
function finish() onlyOwner saleCompletedSuccessfully public {
uint256 freeEthers = address(this).balance * 40 / 100;
uint256 vestedEthers = address(this).balance - freeEthers;
address(0xd1B10607921C78D9a00529294C4b99f1bd250E1c).transfer(freeEthers);
assert(address(0x0285d35508e1A1f833142EB5211adb858Bd3323A).call.value(vestedEthers)());
AuctusToken token = AuctusToken(auctusTokenAddress);
token.setTokenSaleFinished();
if (remainingTokens > 0) {
token.burn(remainingTokens);
remainingTokens = 0;
}
}
| 1 |
function upgradeTo(string version, address implementation) public onlyProxyOwner {
_upgradeTo(version, implementation);
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.