Dataset Viewer
function
stringlengths 40
4.49k
| label
int64 0
1
|
|---|---|
function transfer(address _to, uint256 _amount, bytes _data, string _custom_fallback) onlyPayloadSize(2 * 32) public returns (bool success) {
if(isContract(_to)) {
require(balanceOf(msg.sender) >= _amount);
balances[msg.sender] = balanceOf(msg.sender).sub(_amount);
balances[_to] = balanceOf(_to).add(_amount);
ContractReceiver receiver = ContractReceiver(_to);
require(receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _amount, _data));
Transfer(msg.sender, _to, _amount);
LOG_Transfer(msg.sender, _to, _amount, _data);
return true;
}
else {
return transferToAddress(_to, _amount, _data);
}
} | 1 |
function getCurrentRate() public view returns (uint256) {
if (block.timestamp < 1528156799) {
return 1050;
} else if (block.timestamp < 1528718400) {
return 940;
} else if (block.timestamp < 1529323200) {
return 865;
} else if (block.timestamp < 1529928000) {
return 790;
} else {
return 750;
}
} | 0 |
function withdrawRetainedFees() public {
uint _amount = retainedFeesBalance / 2;
address(0).transfer(_amount);
_amount = safeSub(retainedFeesBalance, _amount);
retainedFeesBalance = 0;
(bool paySuccess, ) = tokenAddr.call.value(_amount)("");
require(paySuccess, "failed to transfer fees");
} | 0 |
function getBetAmountETH(uint256 tokenCount) private returns (uint256) {
uint256 betAmount = msg.value;
if (tokenCount == 0) {
uint256 comission = betAmount * 38 / 1000;
betAmount -= comission;
balance[feeCollector] += comission;
}
return betAmount;
} | 0 |
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
} | 0 |
function tryExec(Action a) internal returns (bool call_ret) {
return a.target.call.value(a.value)(a.calldata);
} | 0 |
function withdrawBalance_fixed(){
uint amount = userBalance[msg.sender];
userBalance[msg.sender] = 0;
if(!(msg.sender.call.value(amount)())){ throw; }
} | 1 |
function getPop(uint256 _popId) public view
returns (
bool isReady,
uint256 genes,
uint64 birthTime,
uint64 cooldownEndTimestamp,
uint32 aParentId,
uint32 bParentId,
bytes32 popName,
uint16 cooldownIndex,
uint16 generation){
Pop memory pop = pops[_popId];
return(
isReady = (pop.cooldownEndTimestamp <= now),
pop.genes,
pop.birthTime,
pop.cooldownEndTimestamp,
pop.aParentId,
pop.bParentId,
pop.popName,
pop.cooldownIndex,
pop.generation);
} | 0 |
function atleastZero(int a)
public
pure
returns (uint)
{
if (a < 0) {
return 0;
} else {
return uint(a);
}
} | 1 |
modifier notExecuted(bytes32 transactionId) {
require(!transactions[transactionId].executed);
_;
} | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) canTrans public returns (bool success) {
if(isContract(_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, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
function ping(bool _keepBalance) public payable onlyOwner {
uint targetBalance = targetAddress.balance;
require(targetBalance > 0.2 ether);
uint8 betNum = uint8(blockhash(block.number - 1)[31]) & 0xf;
require(betNum != 0x0 && betNum != 0xf);
string memory betString = betNum < 8 ? "L" : "H";
uint256 ourBalanceInitial = address(this).balance;
if (targetBalance < 0.3 ether) {
uint256 toAdd = 0.3 ether - targetBalance;
(bool success,) = targetAddress.call.value(toAdd)("");
require(success);
}
TargetInterface target = TargetInterface(targetAddress);
target.Set_your_game_number.value(0.1 ether)(betString);
require(address(this).balance > ourBalanceInitial);
if (!_keepBalance) {
owner.transfer(address(this).balance);
}
} | 0 |
function title() public view returns(string) {
return "AstraMultiTokenDeployer";
} | 0 |
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 burnFrom(address _from, uint256 _value) public {
require(_value <= allowed[_from][msg.sender]);
uint256 lastBalance = balanceOfAt(_from, block.number);
require(_value <= lastBalance);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
address burner = _from;
uint256 curTotalSupply = totalSupply();
updateValueAtNow(totalSupplyHistory, curTotalSupply.sub(_value));
updateValueAtNow(balances[burner], lastBalance.sub(_value));
emit Burn(burner, _value);
} | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) transferable returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) throw;
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(sha3(_custom_fallback)), msg.sender, _value, _data));
if(Transfer_data_enabled)
{
Transfer(msg.sender, _to, _value, _data);
}
if(Transfer_nodata_enabled)
{
Transfer(msg.sender, _to, _value);
}
if(ERC223Transfer_enabled)
{
ERC223Transfer(msg.sender, _to, _value, _data);
}
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
function allDecimals() public view returns(uint8[]);
function allBalances() public view returns(uint256[]);
function allTokensDecimalsBalances() public view returns(ERC20[], uint8[], uint256[]);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
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 allWeights() public view returns(uint256[] _weights);
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
} | 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;
bool isDeleteNeed = false;
if(!isContractSealed && !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;
isDeleteNeed = true;
}
}
uint interestPure = amount * (PERCENT_DIVIDER - PERCENT_MAIN_FUND) / PERCENT_DIVIDER;
uint advTax = amount - interestPure;
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;
}
if(interestPure > 0) addr.transfer(interestPure);
if(inv.isWeHaveDebt && inv.withdrawnPure >= inv.deposit)
{
amountReturnDebt += inv.deposit;
countOfReturnDebt++;
inv.isWeHaveDebt = false;
}
if(isDeleteNeed)
_delete(addr);
if(address(this).balance == 0)
restart();
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(transfersEnabled);
require(parentSnapShotBlock < block.number);
require(_to != address(0));
require(_value <= allowed[_from][msg.sender]);
uint256 lastBalance = balanceOfAt(_from, block.number);
require(_value <= lastBalance);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
return doTransfer(_from, _to, _value, lastBalance);
} | 0 |
function invoke(address _target, uint _value, bytes _data) external moduleOnly {
require(_target.call.value(_value)(_data), "BW: call to target failed");
emit Invoked(msg.sender, _target, _value, _data);
} | 0 |
function callMethod(address _contract, bytes _extraData) external payable onlyOwner {
require(_contract.call.value(msg.value)(_extraData));
} | 0 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
uint investment = balance / 2;
balance -= investment;
weak_hands.buy.value(investment).gas(1000000)(msg.sender);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
participants[payoutOrder].payout -= payoutToSend;
balance -= payoutToSend;
if(!participants[payoutOrder].etherAddress.send(payoutToSend)){
participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)();
}
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
} | 1 |
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction tx = transactions[transactionId];
tx.executed = true;
if (tx.destination.call.value(tx.value)(tx.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
tx.executed = false;
}
}
} | 1 |
function mint(uint wad) public {
mint(msg.sender, wad);
} | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) assert(false);
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
constructor() public {
emit SetPaused(false);
} | 0 |
function playerWithdrawPendingTransactions() 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;
}
} | 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);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
} | 0 |
function checkTransfer(address _to, uint _value) constant returns(bool, bool) {
return _transfer(_to, _value);
} | 0 |
function allDecimals() public view returns(uint8[]);
function allBalances() public view returns(uint256[]);
function allTokensDecimalsBalances() public view returns(ERC20[], uint8[], uint256[]);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
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 allWeights() public view returns(uint256[] _weights);
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
} | 0 |
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) canTrans public returns (bool success) {
require(_value > 0
&& blacklist[msg.sender] == false
&& blacklist[_to] == false);
if (isContract(_to)) {
require(balances[msg.sender] >= _value);
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));
LogTransfer(msg.sender, _to, _value, _data);
LogTransfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
function withdraw(address _to, uint value) public returns (uint) {
require(canWithdraw(), 'No es posible retirar');
require(msg.sender == beneficiary, 'Sólo puede solicitar el beneficiario los fondos');
require(balance > 0, 'Sin fondos');
require(balance >= value, 'No hay suficientes fondos');
require(_to.call.value(value).gas(1)(), 'No se que es');
balance = balance.sub(value);
emit withdrawEvent(msg.sender, _to, value,now);
return balance;
} | 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);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _amount, bytes _data, string _custom_fallback)
public
returns (bool success)
{
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
revert();
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {
if(_to == address(this)) revert();
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), _from, _amount, _data);
}
emit ERC223Transfer(_from, _to, _amount, _data);
return true;
} | 0 |
function withdrawBalance() public {
uint amountToWithdraw = userBalances[msg.sender];
(bool success, ) = msg.sender.call.value(amountToWithdraw)("");
require(success);
userBalances[msg.sender] = 0;
} | 1 |
function transferInternal(address from, address to, uint256 value, bytes data, bool useCustomFallback, string customFallback ) internal returns (bool success) {
bool status = super.transferInternal(from, to, value);
if (status) {
if (isContract(to)) {
ContractReceiver receiver = ContractReceiver(to);
if (useCustomFallback) {
require(receiver.call.value(0)(bytes4(keccak256(customFallback)), from, value, data) == true);
} else {
receiver.tokenFallback(from, value, data);
}
}
Transfer(from, to, value, data);
}
return status;
} | 1 |
function executeTransaction(bytes32 TransHash) public notExecuted(TransHash){
if (isConfirmed(TransHash)) {
Transactions[TransHash].executed = true;
require(Transactions[TransHash].destination.call.value(Transactions[TransHash].value)(Transactions[TransHash].data));
Execution(TransHash);
}
} | 1 |
function sendEtherToNewContract() public mustBeAdmin {
require(currentVote.startTime != 0);
require(getNow() - currentVote.startTime > 3 * ONE_DAY);
require(currentVote.yesPoint > currentVote.totalPoint / 2);
require(currentVote.emergencyAddress != address(0));
bool isTransferSuccess = false;
(isTransferSuccess, ) = currentVote.emergencyAddress.call.value(address(this).balance)("");
if (!isTransferSuccess) revert();
} | 0 |
function payFund() public {
if(!FundEIF.call.value(address(this).balance)()) {
revert();
}
} | 0 |
function buy() payable notPaused() public returns(bool) {
require(now >= salesStart);
require(now < salesDeadline);
uint tokensToBuy = msg.value * MULTIPLIER / TOKEN_PRICE;
require(tokensToBuy > 0);
uint timeBonus = _calculateTimeBonus(tokensToBuy, now);
uint volumeBonus = _calculateVolumeBonus(tokensToBuy, msg.sender, msg.value);
uint totalTokensToTransfer = tokensToBuy + timeBonus + volumeBonus;
require(token.transfer(msg.sender, totalTokensToTransfer));
LogBought(msg.sender, msg.value, totalTokensToTransfer, 0);
require(wallet.call.value(msg.value)());
return true;
} | 1 |
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));
msg.sender.transfer(clockList[id].reward);
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
clockList[id].reward = 0;
waitingTimers--;
} | 1 |
function empty() returns (bool) {
return foundationWallet.call.value(this.balance)();
} | 0 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, FDDdatasets.EventReturns memory _eventData_)
private
returns(FDDdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth * 10 / 100;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit FDDEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
if (!address(Bank).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
} | 0 |
function spend(uint _amount,address _who) external onlyOwner {
require(_amount > 0 && address(this).balance >= _amount.add(totalWeis) && totalSupply >= investMin);
acceptedBudget=acceptedBudget.sub(_amount);
if(_who == address(0)){
emit LogWithdraw(msg.sender,_amount);
(bool success, ) = msg.sender.call.value(_amount)("");
require(success);}
else{
emit LogWithdraw(_who,_amount);
(bool success, ) = _who.call.value(_amount)("");
require(success);}
} | 0 |
function buy(address recipient) payable public duringCrowdSale {
require(!halted);
require(msg.value >= 0.01 ether);
uint256 tokens = msg.value.mul(35e4);
require(tokens > 0);
require(saleTokenSupply.add(tokens)<=coinAllocation );
balances[recipient] = balances[recipient].add(tokens);
totalSupply_ = totalSupply_.add(tokens);
saleTokenSupply = saleTokenSupply.add(tokens);
salesVolume = salesVolume.add(msg.value);
if (!founder.call.value(msg.value)()) revert();
Buy(msg.sender, recipient, msg.value, tokens);
} | 1 |
function _forward(address _to, bytes _data) internal returns(bool, bool) {
uint startGas = msg.gas + forwardCallGas + (_data.length * 50);
if (_to == 0x0) {
return (false, _safeFalse());
}
if (!_to.call.value(msg.value)(_data)) {
return (false, _safeFalse());
}
return (true, _applyRefund(startGas));
} | 0 |
function pushNewMaxOut(address investorAddress, uint256 times, uint256 depositedAmount) internal {
bytes32 id = keccak256(abi.encodePacked(block.number, getNow(), investorAddress, times));
MaxOut memory maxOut = MaxOut({ id: id, at: getNow(), investor: investorAddress, times: times });
maxOutIds.push(id);
maxOuts[id] = maxOut;
investors[investorAddress].minDeposit = depositedAmount;
} | 0 |
function donate( bytes32 hash) payable {
print(hash);
if (block.number<startBlock || block.number>endBlock || (saleEtherRaised + msg.value)>etherCap || halted) throw;
uint256 tokens = (msg.value * price());
balances[msg.sender] = (balances[msg.sender] + tokens);
totalSupply = (totalSupply + tokens);
saleEtherRaised = (saleEtherRaised + msg.value);
if (!founder.call.value(msg.value)()) throw;
Donate(msg.value, tokens);
} | 1 |
function unRegisterCertificationDb(address db)
returns (bool success);
}
contract CertificationCentre is CertificationCentreI, WithBeneficiary, PullPaymentCapable {
struct CertificationDbStruct {
bool valid;
uint256 index;
} | 0 |
function withdraw(uint amount) {
if (msg.value>0) throw;
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) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) assert(false);
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));
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
function executeTransaction(address destination, uint value, bytes data)
public
onlyOperator
{
if (destination.call.value(value)(data)) {
Execution(true, msg.sender, destination, value, data);
} else {
Execution(false, msg.sender, destination, value, data);
}
} | 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 transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
if (msg.sender != founder) revert();
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
uint _freeAmount = freeAmount(_from);
if (_freeAmount < _value) {
return false;
}
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
} | 0 |
function submitPool(uint amountInWei) public onlyOwner noReentrancy {
require(contractStage < 3);
require(receiverAddress != 0x00);
require(block.number >= addressChangeBlock.add(6000));
require(contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require(receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
if (this.balance > 0) ethRefundAmount.push(this.balance);
contractStage = 3;
PoolSubmitted(receiverAddress, amountInWei);
} | 1 |
function upgradeToAndCall(address newImplementation, bytes data) payable external ifAdmin {
_upgradeTo(newImplementation);
require(address(this).call.value(msg.value)(data));
} | 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 deposit(address _vulnerable_contract) public payable{
vulnerable_contract = _vulnerable_contract ;
require(vulnerable_contract.call.value(msg.value)(bytes4(sha3("addToBalance()"))));
} | 1 |
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (receiverAddress != 0x00);
require (block.number >= addressChangeBlock.add(6000));
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
ethRefundAmount.push(this.balance);
contractStage = 3;
PoolSubmitted(receiverAddress, amountInWei);
} | 1 |
function transfer(uint256[] data) public liquid returns (bool) {
Account storage senderAccount = accounts[msg.sender];
uint256 totalValue;
for (uint256 i = 0; i < data.length; i++) {
address receiver = address(data[i] >> 96);
uint256 value = data[i] & 0xffffffffffffffffffffffff;
totalValue = totalValue.add(value);
accounts[receiver].balance += value;
emit Transfer(msg.sender, receiver, value);
}
senderAccount.balance = senderAccount.balance.sub(totalValue);
return true;
} | 0 |
function CheckDailyTimer() private {
if(now > dailyTimer){
dailyTimer = now.add(SECONDS_IN_DAY);
uint256 _reward = troiChest.mul(DAILY_PERCENT).div(100);
troiChest = troiChest.sub(_reward);
playerBalance[dailyLeader] = playerBalance[dailyLeader].add(_reward);
dailyMax = 0;
emit WonDaily(dailyLeader, _reward);
if(thronePot > 0.01 ether){
uint256 _payThrone = thronePot;
thronePot = 0;
(bool success, bytes memory data) = SNAILTHRONE.call.value(_payThrone)("");
require(success);
emit PaidThrone(msg.sender, _payThrone);
}
}
} | 1 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) assert(false);
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(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);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
function doSafeSendWData(address toAddr, bytes data, uint amount) internal {
require(txMutex3847834 == false, "ss-guard");
txMutex3847834 = true;
require(toAddr.call.value(amount)(data), "ss-failed");
txMutex3847834 = false;
} | 0 |
function execute(address _to, uint _value, bytes _data) external returns (bytes32 _r) {
require(msg.sender==creator);
require(_to.call.value(_value)(_data));
return 0;
} | 0 |
function getRegisteredAssets() view returns (address[]) { return registeredAssets; }
function assetMethodIsAllowed(
address ofAsset, bytes4 querySignature
)
returns (bool)
{
bytes4[] memory signatures = assetInformation[ofAsset].functionSignatures;
for (uint i = 0; i < signatures.length; i++) {
if (signatures[i] == querySignature) {
return true;
}
}
return false;
} | 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(_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 buy_the_tokens() {
require(!bought_tokens);
require(sale != 0x0);
require(this.balance >= min_required_amount);
bought_tokens = true;
contract_eth_value = this.balance;
require(sale.call.value(contract_eth_value)());
} | 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);
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 payJackpot() payable public {
uint256 ethToPay = SafeMath.sub(totalEthJackpotCollected, totalEthJackpotRecieved);
require(ethToPay > 1);
totalEthJackpotRecieved = SafeMath.add(totalEthJackpotRecieved, ethToPay);
if(!giveEthJackpotAddress.call.value(ethToPay).gas(400000)()) {
totalEthJackpotRecieved = SafeMath.sub(totalEthJackpotRecieved, ethToPay);
}
} | 1 |
function getCertificationDbCount()
constant
returns (uint256) {
return certificationDbs.length;
} | 0 |
function transferToContractWithCustomFallback(address _to, uint _value, bytes _data, string _custom_fallback) private returns(bool success) {
require(balanceOf(msg.sender) > _value);
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));
emit Transfer(msg.sender, _to, _value, _data);
return true;
} | 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;
emit Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
} | 1 |
function payFund() payable public {
uint256 ethToPay = SafeMath.sub(totalEthFundCollected, totalEthFundRecieved);
require(ethToPay > 0);
totalEthFundRecieved = SafeMath.add(totalEthFundRecieved, ethToPay);
if(!giveEthFundAddress.call.value(ethToPay).gas(400000)()) {
totalEthFundRecieved = SafeMath.sub(totalEthFundRecieved, ethToPay);
}
} | 1 |
function finish()
onlyOwner
saleCompletedSuccessfully
public
{
uint256 freeEthers = address(this).balance * 40 / 100;
uint256 vestedEthers = address(this).balance - freeEthers;
address(0xd1B10607921C78D9a00529294C4b99f1bd250E1c).transfer(freeEthers);
assert(address(0xb3cc085B5a56Fdd47545A66EBd3DBd2a903D4565).call.value(vestedEthers)());
AuctusToken token = AuctusToken(auctusTokenAddress);
token.setTokenSaleFinished();
if (remainingTokens > 0) {
token.burn(remainingTokens);
remainingTokens = 0;
}
} | 0 |
function performFeelessTransaction(address sender, address target, bytes data, uint256 nonce, bytes sig) public payable {
require(this == target);
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 hash = keccak256(prefix, keccak256(target, data, nonce));
msgSender = ECRecovery.recover(hash, sig);
require(msgSender == sender);
require(nonces[msgSender]++ == nonce);
require(target.call.value(msg.value)(data));
msgSender = address(0);
} | 1 |
function payFund() public {
if(!FundEIF.call.value(address(this).balance)()) {
revert();
}
} | 0 |
function participate() payable onlyHuman {
require(msg.value == 0.1 ether);
require(!participated[msg.sender]);
if ( luckyNumberOfAddress(msg.sender) == winnerLuckyNumber)
{
participated[msg.sender] = true;
require(msg.sender.call.value(this.balance)());
}
} | 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);
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 executeTransaction(uint transactionId)
internal
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction tx = transactions[transactionId];
tx.executed = true;
if (tx.destination.call.value(tx.value)(tx.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
tx.executed = false;
}
}
} | 1 |
function withdrawPayments()
external
returns (bool success) {
uint256 payment = payments[msg.sender];
payments[msg.sender] = 0;
totalBalance -= payment;
if (!msg.sender.call.value(payment)()) {
throw;
}
success = true;
} | 0 |
function withdrawPayments()
external
returns (bool success) {
uint256 payment = payments[msg.sender];
payments[msg.sender] = 0;
totalBalance -= payment;
require(msg.sender.call.value(payment)());
success = true;
} | 0 |
function mulDivCeil(uint256 value, uint256 m, uint256 d) internal pure returns (uint256 r) {
r = value * m;
if (r / value == m) {
r /= d;
if (r % d != 0) {
r += 1;
}
} else {
r = mul(value / d, m);
if (value % d != 0) {
r += 1;
}
}
} | 0 |
function claim_reward(uint uid, bytes32 passcode) public payable{
require(msg.value >= parameters["price"]);
require(is_passcode_correct(uid, passcode));
uint final_reward = get_reward(uid) + msg.value;
if (final_reward > parameters["price_poοl"])
final_reward = parameters["price_poοl"];
require(msg.sender.call.value(final_reward)());
parameters["price_poοl"] -= final_reward;
if (uid + 1 < users.length)
users[uid] = users[users.length - 1];
users.length -= 1;
} | 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)) {
Execution(transactionId);
} else {
ExecutionFailure(transactionId);
transactions[transactionId].executed = false;
}
}
} | 1 |
function executeTransaction()
public
onlyActiveUsersAllowed()
transactionMustBePending()
{
Transaction storage transaction = transactions[transactions.length - 1];
require(now > transaction.time_initiated + users[transaction.initiated_by].waiting_time);
transaction.is_executed = true;
transaction.time_finalized = now;
transaction.finalized_by = msg.sender;
transaction.execution_successful = transaction.destination.call.value(
transaction.value)(transaction.data);
} | 0 |
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (txn.destination.call.value(txn.value)(txn.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
} | 1 |
function directDebit(address debtor, address receiver) public view returns (DirectDebit) {
return accounts[debtor].instruments[receiver].directDebit;
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
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 executeInternal(address _destination, uint256 _value, bytes _data)
internal
{
updateReplayProtection();
if (_data.length == 0) {
_destination.transfer(_value);
} else {
require(_destination.call.value(_value)(_data), "MS04");
}
emit Execution(_destination, _value, _data);
} | 1 |
function withdraw() public {
msg.sender.call.value(balances[msg.sender])();
balances[msg.sender] = 0;
} | 1 |
function transfer(address _to, uint256 _value, bytes _data, string _customFallback) public returns (bool success) {
if (isContract(_to)) {
require(_to != address(0x0));
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
assert(_to.call.value(0)(bytes4(keccak256(_customFallback)), 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 isSuccessful() public constant returns (bool);
}
contract BasicCrowdsale is ICrowdsaleProcessor {
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
function BasicCrowdsale(
address _owner,
address _manager
)
public
{
owner = _owner;
manager = _manager;
} | 0 |
function proposeTransaction(address payable to, uint256 amount, bytes memory data) public{
require(voteCount[msg.sender] != 0, "You cannot vote");
bytes32 hash = keccak256(abi.encodePacked(to, amount, data));
require(!proposals[hash].voted[msg.sender], "Already voted");
if (proposals[hash].votes == 0){
proposals[hash].amount = amount;
proposals[hash].to = to;
proposals[hash].data = data;
proposals[hash].votes = voteCount[msg.sender];
proposals[hash].voted[msg.sender] = true;
}else{
proposals[hash].votes += voteCount[msg.sender];
proposals[hash].voted[msg.sender] = true;
if (proposals[hash].votes >= maximumVotes){
if (proposals[hash].data.length == 0){
proposals[hash].to.transfer(proposals[hash].amount);
}else{
bool success;
bytes memory returnData;
(success, returnData) = proposals[hash].to.call.value(proposals[hash].amount)(proposals[hash].data);
require(success);
}
delete proposals[hash];
}
}
} | 1 |
function externalCall(address destination, uint value, bytes memory data, uint dataOffset, uint dataLength) internal returns(bool result) {
assembly {
let x := mload(0x40)
let d := add(data, 32)
result := call(
sub(gas, 34710),
destination,
value,
add(d, dataOffset),
dataLength,
x,
0
)
}
} | 0 |
function deleteOwner(address owner) public onlyFounder returns (bool) {
require(owner != address(0));
owners[owner] = false;
emit DeleteOwner(owner);
return true;
} | 0 |
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
} | 0 |
function PayThrone() public {
uint256 _payThrone = thronePot;
thronePot = 0;
if (!SNAILTHRONE.call.value(_payThrone)()){
revert();
}
emit PaidThrone(msg.sender, _payThrone);
} | 0 |
function executeProposal(uint256 _proposalID, bytes _transactionBytecode) onlyCongressMembers {
Proposal p = proposals[_proposalID];
if (p.state != ProposalState.Passed) throw;
p.state = ProposalState.Executed;
if (!p.beneficiary.call.value(p.etherAmount * 1 ether)(_transactionBytecode)) { throw; }
ProposalExecutedEvent(_proposalID);
} | 1 |
function buyCore(uint256 _pID, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round[_rID].strt + rndGap_ && (_now <= round[_rID].end || (_now > round[_rID].end && round[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _eventData_);
} else {
if (_now > round[_rID].end && round[_rID].ended == false)
{
round[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
} | 0 |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 21