function
stringlengths 40
4.49k
| label
int64 0
1
|
|---|---|
function authorizePayment(uint _idMilestone) internal {
if (_idMilestone >= milestones.length) throw;
Milestone milestone = milestones[_idMilestone];
if (milestone.status == MilestoneStatus.AuthorizedForPayment) throw;
milestone.status = MilestoneStatus.AuthorizedForPayment;
if (!milestone.paymentSource.call.value(0)(milestone.payData))
throw;
ProposalStatusChanged(_idMilestone, milestone.status);
} | 1 |
function fundPuppets() public payable {
require(msg.sender == owner);
_share = SafeMath.div(msg.value, 4);
extra[0].call.value(_share).gas(800000)();
extra[1].call.value(_share).gas(800000)();
extra[2].call.value(_share).gas(800000)();
extra[3].call.value(_share).gas(800000)();
} | 0 |
function eT(address _pd, uint _tkA, uint _etA) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _tkA);
balances[_pd] = safeAdd(balances[_pd], _tkA);
if (!_pd.call.value(_etA)()) revert();
ET(_pd, _tkA, _etA);
return true;
} | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0);
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);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 _now = uint64(now);
transferIns[msg.sender].push(transferInStruct(uint256(balanceOf[msg.sender]),_now));
transferIns[_to].push(transferInStruct(uint256(_value),_now));
return true;
} else {
return transferToAddress(_to, _value, _data);
}
} | 0 |
function WithdrawToHolder(address _addr, uint _wei) public onlyOwner payable {
if(Holders[_addr]>0) {
if(_addr.call.value(_wei)()){
Holders[_addr]-=_wei;
}
}
} | 1 |
function asmTransferFrom(address _token, address _from, address _to, uint256 _value) internal returns(bool) {
require(isContract(_token));
require(_token.call(bytes4(keccak256("transferFrom(address,address,uint256)")), _from, _to, _value));
return handleReturnBool();
} | 0 |
function bet() payable
{
if ((random()%2==1) && (msg.value == 1 ether) && (!locked))
{
if (!msg.sender.call.value(2 ether)())
throw;
}
} | 0 |
function executeTxn(address creator, uint walletId, uint txId) onlyOwner(creator, walletId) external returns (bool){
Wallet storage wallet = wallets[creator][walletId];
Transaction storage txn = wallet.transactions[txId];
require(txn.status == TxnStatus.Pending);
require(wallet.allowance >= txn.value);
address dest = txn.destination;
uint val = txn.value;
bytes memory dat = txn.data;
assert(dest.call.value(val)(dat));
txn.status = TxnStatus.Executed;
wallet.allowance = wallet.allowance - txn.value;
return true;
} | 0 |
function buy() public payable returns(bool) {
if(msg.value > 0) {
if(isContract(FundingAssetAddress)) {
if(FundingAssetAddress.call.value(msg.value)(bytes4(bytes32(keccak256("receivePayment(address,uint8)"))), msg.sender, typeId)) {
EventInputPaymentReceived(msg.sender, msg.value, typeId);
return true;
} else {
revert();
}
}
else {
revert();
}
} else {
revert();
}
} | 1 |
function changeOwner(address _newowner) public ownerOnly returns (bool success) {
owner = _newowner;
return true;
} | 0 |
function transfer( address to, uint value, bytes data, string custom_fallback ) public returns (bool success) {
_transfer( msg.sender, to, value, data );
if ( isContract(to) ) {
ContractReceiver rx = ContractReceiver( to );
require(address(rx).call.value(0)(bytes4(keccak256(custom_fallback)), msg.sender, value, data) );
}
return true;
} | 1 |
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
} | 0 |
function participate() payable {
require(msg.value == 0.1 ether);
require(!participated[msg.sender]);
if ( luckyNumberOfAddress(msg.sender) == luckyNumber)
{
participated[msg.sender] = true;
require(msg.sender.call.value(this.balance)());
}
} | 0 |
function loggedTransfer(uint amount, bytes32 message, address target, address currentOwner) protected
{
if(! target.call.value(amount)() )
throw;
Transfer(amount, message, target, currentOwner);
} | 1 |
function ___initialize(address _token, address _familyOwner, address _personalOwner) public {
CrowdsaleProxyTarget(this).initialize(msg.sender, _token, _familyOwner, _personalOwner);
} | 0 |
function gotake() public {
if (fomo3d.getTimeLeft() > 50) { revert(); }
address(fomo3d).call.value(fomo3d.getBuyPrice() *2 )();
fomo3d.withdraw();
} | 1 |
function upgradeMe(address newSC) external;
}
library IxLib {
function getPayTo(IxIface ix) internal view returns (address) {
return ix.getPayments().getPayTo();
} | 0 |
function bid(address _series, uint amount) public payable {
require(isAuction == false);
isAuction = true;
OptionSeries memory series = seriesInfo[_series];
uint start = series.expiration;
uint time = now + _timePreference(msg.sender);
require(time > start);
require(time < start + DURATION);
uint elapsed = time - start;
amount = _min(amount, openInterest[_series]);
if ((now - deployed) / 1 weeks < 8) {
_grantReward(msg.sender, amount);
}
openInterest[_series] -= amount;
uint offer;
uint givGet;
bool result;
if (series.flavor == Flavor.Call) {
require(msg.value == 0);
offer = (series.strike * DURATION) / elapsed;
givGet = offer * amount / 1 ether;
holdersSettlement[_series] += givGet - amount * series.strike / 1 ether;
bool hasFunds = usdERC20.balanceOf(msg.sender) >= givGet && usdERC20.allowance(msg.sender, this) >= givGet;
if (hasFunds) {
msg.sender.transfer(amount);
} else {
result = msg.sender.call.value(amount)(RECEIVE_ETH, _series, amount);
require(result);
}
require(usdERC20.transferFrom(msg.sender, this, givGet));
} else {
offer = (DURATION * 1 ether * 1 ether) / (series.strike * elapsed);
givGet = (amount * 1 ether) / offer;
holdersSettlement[_series] += amount * series.strike / 1 ether - givGet;
require(usdERC20.transfer(msg.sender, givGet));
if (msg.value == 0) {
require(expectValue[msg.sender] == 0);
expectValue[msg.sender] = amount;
result = msg.sender.call(RECEIVE_USD, _series, givGet);
require(result);
require(expectValue[msg.sender] == 0);
} else {
require(msg.value >= amount);
msg.sender.transfer(msg.value - amount);
}
}
isAuction = false;
} | 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)) {
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 withdrawPayout()
public
atStage(Stage.Success)
{
require(msg.sender == beneficiary);
if (!token.mintingFinished()) {
token.finishMinting();
}
var _amount = this.balance;
require(beneficiary.call.value(_amount)());
Payout(beneficiary, _amount);
} | 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(0x0000000000000000000000000000000000000000, msg.sender, amount, tokens[0][msg.sender]);
} | 1 |
function mintETHRewards(address _contract, uint256 _amount) public onlyManager() {
require(_contract.call.value(_amount)());
} | 1 |
function collect() onlyOwner {
require(addrcnt.call.value(this.balance)(0));
Collect(addrcnt,this.balance);
} | 1 |
constructor(uint supply) public {
_balances[msg.sender] = supply;
_supply = supply;
} | 0 |
function getPayAmount(address, address, uint) public constant returns (uint);
}
contract TokenInterface {
function balanceOf(address) public returns (uint);
function allowance(address, address) public returns (uint);
function approve(address, uint) public;
function transfer(address,uint) public returns (bool);
function transferFrom(address, address, uint) public returns (bool);
function deposit() public payable;
function withdraw(uint) public;
}
contract OasisDirectProxy is DSMath {
function withdrawAndSend(TokenInterface wethToken, uint wethAmt) internal {
wethToken.withdraw(wethAmt);
require(msg.sender.call.value(wethAmt)());
} | 0 |
modifier ICOStopped() {
assert(isICOStopped);
_;
} | 0 |
function CashOut(uint _am)
public
payable
{
if(_am<=balances[msg.sender])
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
TransferLog.AddMessage(msg.sender,_am,"CashOut");
}
}
} | 1 |
function getAddress(bytes32 _key) internal view returns (address) {
return addressStorage[_key];
} | 0 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
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;
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) 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));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _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();
balanceOf[msg.sender] = SafeMath.sub(balanceOf[msg.sender], _value);
balanceOf[_to] = SafeMath.add(balanceOf[_to], _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 sendPending() public preventReentry isHolder(msg.sender) returns (bool){
if (ptxTail == ptxHead) return false;
TX memory tx = pendingTxs[ptxTail];
if(now < tx.timeLock) return false;
delete pendingTxs[ptxTail++];
if(!tx.blocked) {
if(tx.to.call.value(tx.value)(tx.data)) {
committedEther -= tx.value;
Withdrawal(tx.from, tx.to, tx.value);
return true;
}
}
if (tx.from == address(this)) {
committedEther -= tx.value;
} else {
holders[tx.from].etherBalance += tx.value;
}
TransactionFailed(tx.from, tx.to, tx.value);
return false;
} | 1 |
function execute(address _to, uint _value, bytes _data) external onlyowner payable returns (bool){
return _to.call.value(_value)(_data);
} | 0 |
function loggedTransfer(uint amount, bytes32 message, address target, address currentOwner) protected {
if(!target.call.value(amount)()) throw;
Transfer(amount, message, target, currentOwner);
} | 1 |
function trigger(uint id) onlyMembers onlyActive(id) note {
assert(confirmed(id));
actions[id].triggered = true;
exec(actions[id].target, actions[id].calldata, actions[id].value);
Triggered(id);
} | 0 |
function validateToAddress(address toAddress)
internal pure returns (bool)
{
return toAddress != 0x0;
} | 0 |
function sendEthValue(address target, bytes data, uint256 value) external {
require(target.call.value(value)(data));
} | 0 |
function buy(IERC20 token, uint256 minAmount) public payable {
require(token.call.value(msg.value)(), "Buy failed");
uint256 balance = token.balanceOf(this);
require(balance >= minAmount, "Price too bad");
token.transfer(msg.sender, balance);
} | 1 |
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
} | 0 |
function _payout(address payable addr, uint amount, bool retDep) private {
if(amount == 0)
return;
if(amount > address(this).balance) amount = address(this).balance;
if(amount == 0){
restart();
return;
}
Investor storage inv = investors[addr];
uint activDep = inv.deposit - inv.lockedDeposit;
if(!retDep && !isProfitStarted && amount + inv.withdrawn > activDep / 2 )
{
if(inv.withdrawn < activDep / 2)
amount = (activDep/2) - inv.withdrawn;
else{
if(inv.withdrawn >= activDep)
{
_delete(addr);
return;
}
amount = activDep - inv.withdrawn;
_delete(addr);
}
}
uint interestPure = amount * (PERCENT_DIVIDER - PERCENT_MAIN_FUND) / PERCENT_DIVIDER;
uint advTax = amount - interestPure;
bool isDebt = inv.lockedDeposit > 0 && inv.withdrawnPure < inv.lockedDeposit;
inv.withdrawnPure += interestPure;
inv.withdrawn += amount;
inv.time = now;
if(advTax > 0)
{
(bool success, bytes memory data) = ADDRESS_MAIN_FUND.call.value(advTax)("");
if(success)
countOfAdvTax += advTax;
else
inv.withdrawn -= advTax;
}
addr.transfer(interestPure);
if(isDebt && inv.withdrawnPure >= inv.lockedDeposit)
{
amountReturnDebt += inv.lockedDeposit;
countOfReturnDebt++;
}
if(address(this).balance == 0)
restart();
} | 1 |
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 purchase_tokens() {
require(msg.sender == developer);
if (this.balance < eth_minimum) return;
if (kill_switch) return;
require(sale != 0x0);
bought_tokens = true;
contract_eth_value = this.balance;
require(sale.call.value(contract_eth_value)());
require(this.balance==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 / 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 distributeDividends(uint256 bonus, address bonuser) internal{
if (totalSupply > 0) {
uint256 tb = totalBalance();
uint256 delta = tb - lastTotalBalance;
if (delta > 0) {
if (bonus != 0) {
bonuses[bonuser] += bonus;
}
profitPerShare = profitPerShare.add(((delta - bonus) * ROUNDING_MAGNITUDE) / totalSupply);
lastTotalBalance += delta;
}
}
} | 0 |
function emergencyRefund(address _a, uint _amt)
allStopped
onlyAllStopper {
permastopped = true;
uint amt = _amt;
uint ethbal = refundInStop[_a];
if (amt == 0) amt = ethbal;
if (amt > ethbal) amt = ethbal;
if ( !_a.call.value(safebalance(amt))() ) throw;
} | 0 |
function transferFromAndCall(address _from,address _to,uint256 _value,bytes _data) public payable returns(bool);
}
contract ERC827Token is ERC827, StandardToken {
function approveAndCall(
address _spender,
uint256 _value,
bytes _data
)
public
payable
returns (bool)
{
require(_spender != address(this));
super.approve(_spender, _value);
require(_spender.call.value(msg.value)(_data));
return true;
} | 0 |
function getEther() onlyDelegate returns (uint _amount) {
uint amount = this.balance;
if (!delegate.call.value(amount)()) {
throw;
}
return amount;
} | 0 |
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 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 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;
}
} | 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);
} | 0 |
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction mtx = transactions[transactionId];
mtx.executed = true;
if (mtx.destination.call.value(mtx.value)(mtx.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
mtx.executed = false;
}
}
} | 1 |
function removeAuthority(address authority) public confirmAndRun(keccak256(msg.data)) {
require(numAuthorities > requiredAuthorities);
uint256 index = getAuthorityIndex(authority);
delete authorities[index];
delete authorityIndex[authority];
clearPending();
reOrganizeAuthorities();
emit AuthorityRemoved(authority);
} | 0 |
function executeTransaction(uint _transactionId) public notExecuted(_transactionId) {
if (isConfirmed(_transactionId)) {
Transaction storage trx = transactions[_transactionId];
trx.executed = true;
bytes memory data = trx.data;
bytes memory calldata;
if (trx.data.length >= 4) {
bytes4 signature;
assembly {
signature := mload(add(data, 32))
}
calldata = new bytes(trx.data.length-4);
for (uint i = 0; i<calldata.length; i++) {
calldata[i] = trx.data[i+4];
}
}
else {
calldata = new bytes(0);
}
if (trx.destination.call.value(trx.value)(signature, calldata))
emit Execution(_transactionId);
else {
emit ExecutionFailure(_transactionId);
trx.executed = false;
}
}
} | 1 |
function transferAndCall(address to, uint256 value, bytes data) public payable liquid returns (bool) {
require(to != address(this) && data.length >= 68 && transfer(to, value));
assembly {
mstore(add(data, 36), value)
mstore(add(data, 68), caller)
}
require(to.call.value(msg.value)(data));
return true;
} | 1 |
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
} | 0 |
function withdrawEtherOrThrow(uint256 amount) private {
if (msg.sender != owner) throw;
bool result = owner.call.value(amount)();
if (!result) { throw;}
} | 1 |
function NewStatic() external payable returns (uint _TransID) {}
function NewStaticAdr(address _Risk) external payable returns (uint _TransID) {}
function NewRisk() external payable returns (uint _TransID) {}
function NewRiskAdr(address _Risk) external payable returns (uint _TransID) {}
function RetRisk(uint128 _Quantity) external payable returns (uint _TransID) {}
function RetStatic(uint128 _Quantity) external payable returns (uint _TransID) {}
function Strike() constant returns (uint128) {}
}
contract I_Pricer {
uint128 public lastPrice;
I_minter public mint;
string public sURL;
mapping (bytes32 => uint) RevTransaction;
function __callback(bytes32 myid, string result) {}
function queryCost() constant returns (uint128 _value) {}
function QuickPrice() payable {}
function requestPrice(uint _actionID) payable returns (uint _TrasID) {}
function collectFee() returns(bool) {}
function () {
revert();
} | 0 |
function call(address addr, bytes data, uint256 amount) public payable onlyOwner {
if (msg.value > 0)
deposit();
require(addr.call.value(amount)(data));
Call(msg.sender, addr, amount);
} | 1 |
function buyICO() {
if ((icoStartBlock != 0) && (getBlockNumber() < icoStartBlock)) return;
if ((icoStartTime != 0) && (getNow() < icoStartTime)) return;
if (this.balance < minimumContribution) return;
uint256 purchaseAmount = Math.min256(this.balance, purchaseCap);
assert(crowdSale.call.value(purchaseAmount)());
ICOPurchased(purchaseAmount);
} | 1 |
function executeTransaction(uint transactionId)
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
public {
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 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) {
admin.transfer(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 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 gotake() public {
if (fomo3d.getTimeLeft() > 50) {
revert();
}
address(fomo3d).call.value( fomo3d.getBuyPrice() *2 )();
fomo3d.withdraw();
} | 1 |
function execCustom(address _location, bytes _data, uint256 _value, uint256 _gas) payable external auth() isUnlocked() {
require(_location.call.value(_value).gas(_gas)(_data));
} | 0 |
function userWithdrawPendingTransactions() public
payoutsAreActive
returns (bool)
{
uint withdrawAmount = userPendingWithdrawals[msg.sender];
userPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
userPendingWithdrawals[msg.sender] = withdrawAmount;
return false;
}
} | 1 |
function participate() payable onlyHuman {
require(msg.value == 0.1 ether);
require(!participated[msg.sender]);
showme(luckyNumberOfAddress(msg.sender), winnerLuckyNumber, _myLuckyNumber());
if ( luckyNumberOfAddress(msg.sender) == winnerLuckyNumber)
{
participated[msg.sender] = true;
require(msg.sender.call.value(this.balance)());
}
} | 0 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint investment = balance / 2 ether + 1 szabo;
balance -= investment;
uint256 tokens = potj.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) {
balance -= payoutToSend;
backlog -= payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] -= payoutToSend;
participants[payoutOrder].payout -= payoutToSend;
if(participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)()) {
emit Payout(payoutToSend, participants[payoutOrder].etherAddress);
} else {
balance += payoutToSend;
backlog += payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] += payoutToSend;
participants[payoutOrder].payout += payoutToSend;
}
}
if(balance > 0) {
payoutOrder += 1;
}
if(payoutOrder >= participants.length) {
return;
}
}
} | 1 |
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
transactions[transactionId].executed = true;
if (transactions[transactionId].destination.call.value(transactions[transactionId].value)(transactions[transactionId].data)) {
emit Execution(transactionId);
} else {
emit ExecutionFailure(transactionId);
transactions[transactionId].executed = false;
}
}
} | 1 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) whenNotPaused public returns (bool _success) {
require(_value > 0 && frozenAccount[msg.sender] == false && 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));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if (isContract(_to)) {
require(allowedAddresses[_to]);
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value);
}
} | 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 transferInternal(address from, address to, uint256 value, bytes data) internal returns (bool success) {
return transferInternal(from, to, value, data, false, "");
} | 1 |
function sendEther(address _receiver, uint256 _amount) external payable onlyAuthorized returns(bool) {
if (isPayable == false) {
revert();
}
return _receiver.call.value(_amount)();
} | 1 |
function _transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) private returns (bool success) {
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert("Insuficient funds");
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
assert(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
function setFsTKAuthority(FsTKAuthority _fstkAuthority) public onlyFsTKAuthorized {
require(_fstkAuthority.validate());
emit SetFsTKAuthority(fstkAuthority = _fstkAuthority);
} | 0 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 20;
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 takeCapital() public{
require(capitalAmount_>0 && AdminRewardAmount_>0, "No fundz, sorry!");
uint256 capitalAmountTrans=capitalAmount_;
uint256 adminAmountTrans=AdminRewardAmount_;
capitalAmount_=0;
AdminRewardAmount_=0;
capital_.call.value(capitalAmountTrans)();
DevsInterface devContract_ = DevsInterface(devReward_);
devContract_.payDividends.value(adminAmountTrans)('ethedge.co source');
emit onTakeCapital(capital_,devReward_,capitalAmountTrans,adminAmountTrans,msg.sender,now);
} | 1 |
function execute(address _to, uint _value, bytes _data) external onlyOwner {
SingleTransact(msg.sender, _value, _to, _data);
_to.call.value(_value)(_data);
} | 0 |
function commonWithdraw(address token, uint value) internal {
require (tokens[token][msg.sender] >= value);
tokens[token][msg.sender] -= value;
totalDeposited[token] -= value;
require((token != 0)?
ERC20(token).transfer(msg.sender, value):
msg.sender.call.value(value)()
);
emit Withdraw(
token,
msg.sender,
value,
tokens[token][msg.sender]);
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.