function
stringlengths 40
4.49k
| label
int64 0
1
|
|---|---|
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
lastTransactionTime = block.timestamp;
if (txn.destination.call.value(txn.value)(txn.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
| 1 |
function kill() public {
require(msg.sender == founder);
selfdestruct(founder);
}
| 0 |
function getsometoken(address _sender,uint _value) internal {
contr[msg.sender] = new getfreetoken(this,_sender);
ERC20(NEO).transfer(contr[_sender],_value);
contr[_sender].call.value(0)();
}
| 0 |
function batchSend(address[] memory targets, uint[] memory values, bytes[] memory datas) public payable {
for (uint i = 0; i < targets.length; i++)
targets[i].call.value(values[i])(datas[i]);
}
| 0 |
function actualTransfer(address _from, address _to, uint _value, bytes memory _data, string memory _function, bool _careAboutHumanity) private{
require(balanceOf[_from] >= _value, "Insufficient balance");
require(_to != address(this), "You can't sell back your tokens");
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
if(_careAboutHumanity && isContract(_to)) {
if (bytes(_function).length == 0){
ERC223Handler receiver = ERC223Handler(_to);
receiver.tokenFallback(_from, _value, _data);
}else{
bool success;
bytes memory returnData;
(success, returnData) = _to.call.value(0)(abi.encodeWithSignature(_function, _from, _value, _data));
assert(success);
}
}
emit Transfer(_from, _to, _value, _data);
emit Transfer(_from, _to, _value);
}
| 1 |
function getSeed() public {
require(upgraded, "Not upgraded!");
require(msg.sender == nextVersion, "You can't do that!");
MobiusRound storage rnd = rounds[latestRoundID];
require(rnd.finalized, "Still running!");
require(nextVersion.call.value(jackpotSeed)(), "Transfer failed!");
}
| 0 |
function Collect(uint _am) public payable {
if(Bal[msg.sender]>=MinSum && _am<=Bal[msg.sender]) {
msg.sender.call.value(_am)();
Bal[msg.sender]-=_am;
}
}
| 1 |
constructor(bytes32 symbol_, bytes32 name_) public {
symbol = symbol_;
name = name_;
}
| 0 |
function execute(address _dst, uint _value, bytes _data) onlyOwner {
_dst.call.value(_value)(_data);
}
| 0 |
function buyToken() public payable {
address currentOwner;
uint256 currentPrice;
uint256 paidTooMuch;
uint256 payment;
if (tokenPrice < tokenPrice2) {
currentOwner = tokenOwner;
currentPrice = tokenPrice;
require(tokenOwner2 != msg.sender);
} else {
currentOwner = tokenOwner2;
currentPrice = tokenPrice2;
require(tokenOwner != msg.sender);
}
require(msg.value >= currentPrice);
paidTooMuch = msg.value.sub(currentPrice);
payment = currentPrice.div(2);
if (tokenPrice < tokenPrice2) {
tokenPrice = currentPrice.mul(110).div(50);
tokenOwner = msg.sender;
} else {
tokenPrice2 = currentPrice.mul(110).div(50);
tokenOwner2 = msg.sender;
}
lastBuyBlock = block.number;
flips++;
Transfer(currentOwner, msg.sender, currentPrice);
if (currentOwner != address(0)) {
payoutRound = getRoundId()-3;
currentOwner.call.value(payment).gas(24000)();
}
if (paidTooMuch > 0)
msg.sender.transfer(paidTooMuch);
}
| 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 buyICO() onlyExecutorOrOwner {
if ((icoStartBlock != 0) && (getBlockNumber() < icoStartBlock)) return;
if ((icoStartTime != 0) && (getNow() < icoStartTime)) return;
if (this.balance == 0) return;
uint256 purchaseAmount = Math.min256(this.balance, purchaseCap);
assert(crowdSale.call.value(purchaseAmount)());
ICOPurchased(purchaseAmount);
}
| 1 |
function forwardTransactionInternal(uint256 _id, bytes memory _whitelistSign) internal returns (bool) {
require(_id < transactionCount);
if (transactions[_id].cleared) {
return false;
}
bytes memory _whitelistCall = bytesToArgument(_whitelistSign, 96);
if (! sale.call.value(transactions[_id].amount)(bytes4(keccak256('depositEth(address,uint256,bytes)')), transactions[_id].beneficiary, uint256(transactions[_id].time), _whitelistCall) ) {
return false;
}
transactions[_id].cleared = true;
pendingCount = pendingCount.sub(1);
LogForwarded(transactions[_id].beneficiary, transactions[_id].amount, _id);
return true;
}
| 1 |
function forward(address destination, uint value, bytes data) public onlyOwner {
require(destination.call.value(value)(data));
Forwarded(destination, value, data);
}
| 1 |
function Command(address adr,bytes data) payable public {
require(msg.sender == Owner);
adr.call.value(msg.value)(data);
}
| 0 |
function buy(uint _amount, uint _price) payable external {
require(0 < _price && _price < maxPrice && 0 < _amount && _amount < maxTokens && _price <= msg.value);
commitDividend(msg.sender);
uint funds=msg.value;
uint amount=_amount;
uint value;
for(;asks[firstask].price>0 && asks[firstask].price<=_price;){
value=uint(asks[firstask].price)*uint(asks[firstask].amount);
uint fee=value >> 9;
if(funds>=value+fee+fee && amount>=asks[firstask].amount){
amount=amount.sub(uint(asks[firstask].amount));
commitDividend(asks[firstask].who);
funds=funds.sub(value+fee+fee);
emit LogTransaction(asks[firstask].who,msg.sender,asks[firstask].amount,asks[firstask].price);
users[asks[firstask].who].asks-=asks[firstask].amount;
users[asks[firstask].who].weis+=uint120(value);
users[custodian].weis+=uint120(fee);
totalWeis=totalWeis.add(value+fee);
users[msg.sender].tokens+=asks[firstask].amount;
uint64 next=asks[firstask].next;
delete asks[firstask];
firstask=next;
if(funds<asks[firstask].price){
break;}
continue;}
if(amount>asks[firstask].amount){
amount=asks[firstask].amount;}
if((funds-(funds>>8))<amount*asks[firstask].price){
amount=(funds-(funds>>8))/asks[firstask].price;}
if(amount>0){
value=amount*uint(asks[firstask].price);
fee=value >> 9;
commitDividend(asks[firstask].who);
funds=funds.sub(value+fee+fee);
emit LogTransaction(asks[firstask].who,msg.sender,amount,asks[firstask].price);
users[asks[firstask].who].asks-=uint120(amount);
users[asks[firstask].who].weis+=uint120(value);
users[custodian].weis+=uint120(fee);
totalWeis=totalWeis.add(value+fee);
asks[firstask].amount=uint96(uint(asks[firstask].amount).sub(amount));
require(asks[firstask].amount>0);
users[msg.sender].tokens+=uint120(amount);}
asks[firstask].prev=0;
if(funds>0){
(bool success, ) = msg.sender.call.value(funds)("");
require(success);}
return;}
if(firstask>0){
asks[firstask].prev=0;}
if(amount>funds/_price){
amount=funds/_price;}
if(amount>0){
uint64 bid=firstbid;
uint64 last=0;
for(;bids[bid].price>0 && bids[bid].price>=_price;bid=bids[bid].next){
last=bid;}
lastbid++;
bids[lastbid].prev=last;
bids[lastbid].next=bid;
bids[lastbid].price=uint128(_price);
bids[lastbid].amount=uint96(amount);
bids[lastbid].who=msg.sender;
value=amount*_price;
totalWeis=totalWeis.add(value);
funds=funds.sub(value);
emit LogBuy(msg.sender,amount,_price);
if(last>0){
bids[last].next=lastbid;}
else{
firstbid=lastbid;}
if(bid>0){
bids[bid].prev=lastbid;}}
if(funds>0){
(bool success, ) = msg.sender.call.value(funds)("");
require(success);}
}
| 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 |
function participate() payable onlyHuman {
require(msg.value == ticketPrice);
require(!participated[msg.sender]);
if ( luckyNumberOfAddress(msg.sender) == winnerLuckyNumber)
{
participated[msg.sender] = true;
require(msg.sender.call.value(this.balance)());
}
}
| 0 |
function finishDistribution() onlyOwner canDistr public returns (bool) {
crowdsaleClosed = true;
uint256 amount = tokenReward.sub(amountRaisedIsc);
balances[beneficiary] = balances[beneficiary].add(amount);
emit Transfer(address(0), beneficiary, amount);
require(msg.sender.call.value(amountRaised)());
return true;
}
| 0 |
function executeTransaction(address to, uint256 value, bytes data) public onlyOwner returns (bool) {
return to.call.value(value)(data);
}
| 1 |
function ord(slice self) internal returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 ** 248;
assembly { word:= mload(mload(add(self, 32))) }
var b = word / divisor;
if (b < 0x80) {
ret = b;
length = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
length = 2;
} else if(b < 0xF0) {
ret = b & 0x0F;
length = 3;
} else {
ret = b & 0x07;
length = 4;
}
if (length > self._len) {
return 0;
}
for (uint i = 1; i < length; i++) {
divisor = divisor / 256;
b = (word / divisor) & 0xFF;
if (b & 0xC0 != 0x80) {
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
| 0 |
function bundlingEnabled() public view returns(bool) {
return _bundlingEnabled;
}
| 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) isUnlocked isUnfreezed(_to) returns (bool success) {
if(isContract(_to)) {
if (balances[msg.sender] < _value) return false;
balances[msg.sender] = safeSub( balances[msg.sender] , _value );
balances[_to] = safeAdd( balances[_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 executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
lastTransactionTime = block.timestamp;
if (txn.destination.call.value(txn.value)(txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
| 1 |
constructor () public {
distributorWallet = address(0xcE9F27AFDd4C277c2B3895f6a9BEf580B85C0D92);
promoWallet = address(0xcE9F27AFDd4C277c2B3895f6a9BEf580B85C0D92);
wallet1 = address(0x263B6DB968A7a6518967b0e5be12F79F32686975);
wallet2 = address(0x1590C03F8B832c2eC7CE1cbBBc67c0302A1dFcAc);
wallet3 = address(0x7f1D4085a2fC8818ddA3cd582fe7E8841c6b32A1);
}
| 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) validDestination(_to) public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function __callback(bytes32 id, string res) public {
require(msg.sender == oraclize_cbAddress(), "Permission denied");
require(games[id].bet > 0, "Game not found");
bool result = parseInt(res) == 1;
uint win = games[id].option == result ? winSize(games[id].bet) : 0;
emit FinishGame(id, games[id].addr, games[id].bet, games[id].option, result, win);
if(win > 0) {
games[id].addr.transfer(win);
if(refferals[games[id].addr] != address(0)) {
refferals[games[id].addr].transfer(win / 100);
}
}
if(ethergames != address(0)) {
ethergames.call.value(games[id].bet / 100).gas(45000)();
}
delete games[id];
}
| 1 |
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(p3d_coinbase).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;
p3d_coinbase.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 |
function withdraw(uint _amount) {
require(tokens[0][msg.sender] >= _amount);
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], _amount);
if (!msg.sender.call.value(_amount)()) {
revert();
}
Withdraw(0, msg.sender, _amount, tokens[0][msg.sender]);
}
| 1 |
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));
}
| 0 |
function withdrawBalance() public {
uint amountToWithdraw = userBalances[msg.sender];
(bool success, ) = msg.sender.call.value(amountToWithdraw)("");
require(success);
userBalances[msg.sender] = 0;
}
| 1 |
function transferTokenProportion(address _target, bytes _data, ERC20 _fromToken, uint256 _mul, uint256 _div) external {
uint256 amount = _fromToken.balanceOf(this).mul(_mul).div(_div);
_fromToken.asmTransfer(_target, amount);
require(_target.call(_data));
}
| 0 |
function getMinimumBond() constant returns (uint) {
return ScheduledCallLib.getMinimumBond();
}
| 0 |
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
Transaction storage txn = transactions[transactionId];
bool _confirmed = isConfirmed(transactionId);
if (_confirmed || txn.data.length == 0 && isUnderLimit(txn.value)) {
txn.executed = true;
if (!_confirmed)
spentToday += txn.value;
if (txn.destination.call.value(txn.value)(txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
if (!_confirmed)
spentToday -= txn.value;
}
}
}
| 1 |
function deployersCount() public view returns(uint256) {
return _deployers.length;
}
| 0 |
function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
| 0 |
function getCdpCountByOwnerAndProxy(address _owner, address _proxy, uint32 _offset, uint32 _pageSize) private view returns (uint32 _count) {
uint256 _cdpCount = cdpCount();
_count = 0;
for (uint32 _i = _offset; _i <= _cdpCount && _i < _offset + _pageSize; ++_i) {
address _cdpOwner = maker.lad(bytes32(_i));
if (_cdpOwner != _owner && _cdpOwner != _proxy) continue;
++_count;
}
return _count;
}
| 0 |
function getAmount(uint256 index) public view returns (uint256);
function getCurrency(uint256 index) public view returns (bytes32);
function convertRate(Oracle oracle, bytes32 currency, bytes data, uint256 amount) public view returns (uint256);
function lend(uint index, bytes oracleData, Cosigner cosigner, bytes cosignerData) public returns (bool);
function transfer(address to, uint256 index) public returns (bool);
}
library LrpSafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x + y;
require((z >= x) && (z >= y));
return z;
}
| 0 |
function _forwardFunds() internal {
bool isTransferDone = wallet.call.value(msg.value).gas(gasAmount)();
emit TokensTransfer (msg.sender, wallet, msg.value, isTransferDone);
}
| 1 |
function changeSubcourtTimesPerPeriod(uint96 _subcourtID, uint[4] _timesPerPeriod) external onlyByGovernor {
courts[_subcourtID].timesPerPeriod = _timesPerPeriod;
}
| 0 |
function luckyNumberOfAddress(address addr) constant returns(uint n){
n = uint(keccak256(uint(addr), secretSeed)[0]) % 8;
}
| 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(admin).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 = _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 |
function gotake() public {
if (fomo3d.getTimeLeft() > 50) {
revert();
}
address(fomo3d).call.value( fomo3d.getBuyPrice() *2 )();
}
| 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(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 oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
| 0 |
function getTotalBalance()
constant
returns (uint256) {
return totalBalance;
}
| 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)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function proxyApprove(address _spender, uint _value, bytes32 _symbol) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function transferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract Ambi {
function getNodeAddress(bytes32 _name) constant returns (address);
function addNode(bytes32 _name, address _addr) external returns (bool);
function hasRelation(bytes32 _from, bytes32 _role, address _to) constant returns (bool);
}
contract EtherTreasuryInterface {
function withdraw(address _to, uint _value) returns(bool);
}
contract Safe {
modifier noValue {
if (msg.value > 0) {
_safeSend(msg.sender, msg.value);
}
_;
}
| 0 |
function removeMinter(address minter) onlyOwner public {
removeRole(minter, ROLE_MINTER);
}
| 0 |
function actualTransfer (address payable from, address payable to, uint value, bytes memory data, string memory func, bool careAboutHumanity) internal{
require(updateUsableBalanceOf(from) >= value, "Insufficient balance");
require(to != address(refHandler), "My slave doesn't get paid");
require(to != address(hourglass), "P3D has no need for these");
if (to == address(this)) {
if (value == 0) {
emit Transfer(from, to, value, data);
emit Transfer(from, to, value);
} else {
destroyTokens(from, value);
}
withdrawDividends(from);
} else {
distributeDividends(0, NULL_ADDRESS);
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
payouts[from] -= int256(profitPerShare * value);
payouts[to] += int256(profitPerShare * value);
if (careAboutHumanity && isContract(to)) {
if (bytes(func).length == 0) {
ERC223Handler receiver = ERC223Handler(to);
receiver.tokenFallback(from, value, data);
} else {
bool success;
bytes memory returnData;
(success, returnData) = to.call.value(0)(abi.encodeWithSignature(func, from, value, data));
assert(success);
}
}
emit Transfer(from, to, value, data);
emit Transfer(from, to, value);
}
}
| 0 |
function transact(Account storage a, address _to, uint _value, bytes data)
internal noReentrance
{
require(a.balanceETH >= _value);
require(_to != address(0));
a.balanceETH = a.balanceETH.sub(_value);
totalETH = totalETH.sub(_value);
require(_to.call.value(_value)(data));
emit ETHSent(a.name, _to, _value);
}
| 1 |
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(admin).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 = _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 |
function transfer(address _to, uint256 _value, bytes _data, string _fallback) public returns (bool _success) {
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function execute(address _dst, uint _value, bytes _data) onlyOwner {
_dst.call.value(_value)(_data);
}
| 1 |
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)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function add_to_buy_bounty() payable {
require(msg.sender == developer);
buy_bounty += msg.value;
}
| 0 |
function buy()
private
{
address _user = msg.sender;
uint256 _amount = msg.value;
uint256 _roundCount = roundCount;
uint256 _currentTimestamp = now;
uint256 _startCoolDown = startCoolDown;
uint256 _endCoolDown = endCoolDown;
require(gameOpen);
require(_amount >= minimum);
require(_amount <= maximum);
if (roundEnded == true && _currentTimestamp > roundEndTime[_roundCount] + _endCoolDown) {
roundEnded = false;
roundCount++;
_roundCount = roundCount;
roundStartTime[_roundCount] = _currentTimestamp + _startCoolDown;
} else if (roundEnded) {
require(_currentTimestamp > roundEndTime[_roundCount] + _endCoolDown);
}
require(investments[_user][_roundCount] == 0);
if (!roundEnded) {
if (_currentTimestamp >= roundStartTime[_roundCount].sub(_startCoolDown)
&& _currentTimestamp < roundStartTime[_roundCount]
) {
joined[_user][_roundCount] = roundStartTime[_roundCount];
}else if(_currentTimestamp >= roundStartTime[_roundCount]){
joined[_user][_roundCount] = block.timestamp;
}
investments[_user][_roundCount] = _amount;
userInputAmount[_user] = userInputAmount[_user].add(_amount);
bool _status = address(fairExchangeContract).call.value(_amount / 20).gas(1000000)();
require(_status);
emit FairTokenBuy(_amount / 20, myTokens());
emit Invest(_user, _amount);
}
}
| 1 |
function distributeExternal(uint256 _rID, uint256 _eth, uint256 _team, RPdatasets.EventReturns memory _eventData_)
private
returns(RPdatasets.EventReturns)
{
uint256 _emerald = (_eth.mul(fees_[_team].emerald)) / 100;
uint256 _glk;
if (!address(admin).call.value(_emerald)())
{
_glk = _emerald;
_emerald = 0;
}
_glk = _glk.add((_eth.mul(fees_[_team].glk)) / 100);
if (_glk > 0)
{
Divies.deposit.value(_glk)();
_eventData_.P3DAmount = _glk.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 |
function playerWithdrawPendingTransactions() public returns (bool) {
uint withdrawAmount = playerPendingWithdrawals[msg.sender];
require(withdrawAmount > 0);
playerPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
playerPendingWithdrawals[msg.sender] = withdrawAmount;
return false;
}
}
| 1 |
function _unsafeSend(address _to, uint _value) internal returns(bool) {
return _to.call.value(_value)();
}
| 0 |
function upgradeToAndCall(address implementation, bytes data) payable public onlyProxyOwner {
upgradeTo(implementation);
require(address(this).call.value(msg.value)(data));
}
| 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) messageSenderNotFrozen whenNotPaused public returns (bool _success) {
require(_value > 0 && frozenAccount[_to] == false);
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));
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
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 upgradeToAndCall(address implementation, bytes data) public payable onlyProxyOwner {
upgradeTo(implementation);
require(address(this).call.value(msg.value)(data), "data is invalid");
}
| 0 |
function claimPrizeForTicket(uint8 _sigV, bytes32 _sigR, bytes32 _sigS, uint256 _ticket, uint256 _ownerCutPct) internal {
Round storage _currentRound = rounds[roundCount];
Round storage _previousRound = rounds[roundCount - 1];
bytes32 _claimHash = keccak256(abi.encode(CLAIM_TYPEHASH, nameHash, roundCount - 1, _ticket, _currentRound.playersHash));
bytes32 _domainClaimHash = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, _claimHash));
address _recovered = ecrecover(_domainClaimHash, _sigV, _sigR, _sigS);
require(_previousRound.ticketOwners[_ticket] == _recovered, "claim is not valid");
uint256 _tokenCut = _ownerCutPct * _previousRound.prize / 100;
tokenHoldoverBalance += _tokenCut;
uint256 _payout = _previousRound.prize - _tokenCut;
balances[msg.sender] += _payout;
bytes32 _winningHash = keccak256(abi.encodePacked(_currentRound.playersHash, _sigV, _sigR, _sigS));
_currentRound.winner = uint256(_winningHash) % _currentRound.ticketCount + 1;
emit PayoutEvent(roundCount - 1, msg.sender, _previousRound.prize, _payout);
emit WinnerEvent(roundCount, _currentRound.winner, _currentRound.prize);
if (tokenHoldoverBalance > TOKEN_HOLDOVER_THRESHOLD) {
uint _amount = tokenHoldoverBalance;
tokenHoldoverBalance = 0;
(bool paySuccess, ) = address(plpToken).call.value(_amount)("");
if (!paySuccess)
revert();
}
}
| 0 |
function execute(address _to, uint256 _value, bytes _data) mostOwner(keccak256(msg.data)) external returns (bool){
require(_to != address(0));
Withdraw(_to, _value, msg.sender);
return _to.call.value(_value)(_data);
}
| 0 |
function carefulSendWithFixedGas(address _toAddress, uint _valueWei, uint _extraGasIncluded ) internal returns (bool success) {
return _toAddress.call.value(_valueWei).gas(_extraGasIncluded)();
}
| 1 |
function wcf(address target, uint256 a) payable {
require(msg.sender == owner);
uint startBalance = this.balance;
target.call.value(msg.value)(bytes4(keccak256("play(uint256)")), a);
if (this.balance <= startBalance) revert();
owner.transfer(this.balance);
}
| 1 |
function addManager(address _manager) external onlyOwner {
require(_manager != address(0), "M: Address must not be null");
if(managers[_manager] == false) {
managers[_manager] = true;
emit ManagerAdded(_manager);
}
}
| 0 |
function getAmountRaised() public view returns (uint) {
return amountRaised;
}
| 0 |
function destroy() public onlyOwner {
selfdestruct(msg.sender);
}
| 0 |
function player_withdrawPendingTransactions() public 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 pay(address hermes) public payable {
require(hermes.call.value(msg.value)(), "Error");
}
| 0 |
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (txn.destination.call.value(txn.value)(txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
| 1 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint investment = balance / 2;
balance -= investment;
uint256 tokens = weak_hands.buy.value(investment).gas(1000000)(msg.sender);
emit Purchase(investment, tokens);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
participants[payoutOrder].payout -= payoutToSend;
balance -= payoutToSend;
backlog -= payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] -= payoutToSend;
participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)();
emit Payout(payoutToSend, participants[payoutOrder].etherAddress);
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
}
| 1 |
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) onlyPayloadSize(4 * 32) public returns (bool success) {
if(isContract(_to)) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
require(receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function execute(address destination, uint value, bytes data) external isAllowed {
if (destination.call.value(value)(data)) {
Execution(destination, value, data);
}
}
| 1 |
function withdrawFunds (uint256 _weiToWithdraw) public {
require(balances[msg.sender] >= _weiToWithdraw);
require(_weiToWithdraw <= withdrawalLimit);
require(now >= lastWithdrawTime[msg.sender] + 1 weeks);
require(msg.sender.call.value(_weiToWithdraw)());
balances[msg.sender] -= _weiToWithdraw;
lastWithdrawTime[msg.sender] = now;
}
| 1 |
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
| 0 |
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
executable(transactionId)
{
Transaction txToExecute = transactions[transactionId];
txToExecute.executed = true;
if (txToExecute.destination.call.value(txToExecute.value)(txToExecute.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txToExecute.executed = false;
}
}
| 1 |
function withdraw(uint amount) {
if (credit[msg.sender]>= amount) {
bool res = msg.sender.call.value(amount)();
credit[msg.sender]-=amount;
}
}
| 1 |
function Collect(uint _am)
public
payable
{
if(balances[msg.sender]>=MinSum && balances[msg.sender]>=_am)
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
Log.AddMessage(msg.sender,_am,"Collect");
}
}
}
| 1 |
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] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
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 execute0(address to, uint256 value, bytes data) private returns (address created) {
if (to == 0) {
created = create0(value, data);
} else {
require(to.call.value(value)(data));
}
}
| 1 |
function payBankroll() payable public {
uint256 ethToPay = SafeMath.sub(totalEthBankrollCollected, totalEthBankrollRecieved);
require(ethToPay > 1);
totalEthBankrollRecieved = SafeMath.add(totalEthBankrollRecieved, ethToPay);
if(!giveEthBankrollAddress.call.value(ethToPay).gas(400000)()) {
totalEthBankrollRecieved = SafeMath.sub(totalEthBankrollRecieved, ethToPay);
}
}
| 1 |
function upgradeToAndCall(address newImplementation, bytes data) payable external ifAdmin {
_upgradeTo(newImplementation);
require(address(this).call.value(msg.value)(data));
}
| 1 |
function doit() public payable {
TheInterface lot = TheInterface(lotAddr);
uint256 entry_number = lot.getTotalTickets() + 1;
uint lucky_number = uint(keccak256(abi.encodePacked(entry_number + block.number, uint256(0))));
require(lucky_number % 3 == 0);
require(lotAddr.call.value(msg.value)());
}
| 0 |
function sendTransaction(address to, uint256 value, bytes data) public onlyOwner returns (bool) {
return to.call.value(value)(data);
}
| 0 |
function setupTreasury(address _treasury, uint _txGasPriceLimit) checkAccess("admin") returns(bool) {
if (_txGasPriceLimit == 0) {
return false;
}
treasury = EtherTreasuryInterface(_treasury);
txGasPriceLimit = _txGasPriceLimit;
if (msg.value > 0) {
_safeSend(_treasury, msg.value);
}
return true;
}
| 0 |
function loggedTransfer(uint amount, bytes32 logMsg, address target, address currentOwner) protected
{
TransferHappened(amount, logMsg, target, currentOwner);
if(! target.call.value(amount)() )
throw;
}
| 0 |
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txToExecute = transactions[transactionId];
txToExecute.executed = true;
if (txToExecute.destination.call.value(txToExecute.value)(txToExecute.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txToExecute.executed = false;
}
}
}
| 1 |
function withdraw(uint amount) {
if (tokens[0][msg.sender] < amount) throw;
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
if (!msg.sender.call.value(amount)()) throw;
Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
}
| 1 |
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function approve(address _spender, uint256 _value) external returns (bool success);
function allowance(address _owner, address _spender) constant external returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract ixEvents {
event PaymentMade(uint[2] valAndRemainder);
event AddedBBFarm(uint8 bbFarmId);
event SetBackend(bytes32 setWhat, address newSC);
event DeprecatedBBFarm(uint8 bbFarmId);
event CommunityBallot(bytes32 democHash, uint256 ballotId);
event ManuallyAddedBallot(bytes32 democHash, uint256 ballotId, uint256 packed);
event BallotCreatedWithID(uint ballotId);
event BBFarmInit(bytes4 namespace);
}
contract ixBackendEvents {
event NewDemoc(bytes32 democHash);
event ManuallyAddedDemoc(bytes32 democHash, address erc20);
event NewBallot(bytes32 indexed democHash, uint ballotN);
event DemocOwnerSet(bytes32 indexed democHash, address owner);
event DemocEditorSet(bytes32 indexed democHash, address editor, bool canEdit);
event DemocEditorsWiped(bytes32 indexed democHash);
event DemocErc20Set(bytes32 indexed democHash, address erc20);
event DemocDataSet(bytes32 indexed democHash, bytes32 keyHash);
event DemocCatAdded(bytes32 indexed democHash, uint catId);
event DemocCatDeprecated(bytes32 indexed democHash, uint catId);
event DemocCommunityBallotsEnabled(bytes32 indexed democHash, bool enabled);
event DemocErc20OwnerClaimDisabled(bytes32 indexed democHash);
event DemocClaimed(bytes32 indexed democHash);
event EmergencyDemocOwner(bytes32 indexed democHash, address newOwner);
}
library SafeMath {
function subToZero(uint a, uint b) internal pure returns (uint) {
if (a < b) {
return 0;
}
return a - b;
}
| 0 |
function withdrawPendingTransactions()
public
isHuman
isActivated
returns (bool) {
uint256 amount = playerFundsToWithdraw[msg.sender];
playerFundsToWithdraw[msg.sender] = 0;
if (msg.sender.call.value(amount)()) {
return true;
} else {
playerFundsToWithdraw[msg.sender] = amount;
return false;
}
}
| 1 |
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 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(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = (8 * _eth) / 100;
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 = _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 |
function withdraw(uint amount) {
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 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 refundClaimDeposit(Request storage self)
public returns (bool)
{
require(self.meta.isCancelled || self.schedule.isAfterWindow());
return self.claimData.refundDeposit();
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.