function string | label int64 |
|---|---|
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... | 1 |
function reject(address _participant) onlyOwner public {
uint256 weiAmount = deposited[_participant];
require(weiAmount > 0);
deposited[_participant] = 0;
Rejected(_participant);
require(_participant.call.value(weiAmount)());
} | 0 |
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
} | 0 |
function getPeriodsToPay(bytes32 _proposalId, address _avatar,uint _redeemType) public view returns (uint) {
ContributionProposal memory _proposal = organizationsProposals[_avatar][_proposalId];
if (_proposal.executionTime == 0)
return 0;
uint periodsFromExecution;
if (_proposal.periodLength > 0) {
periodsFromExe... | 0 |
function owned() {
owner = msg.sender;
} | 0 |
constructor () public payable {
fomo3d fomo = fomo3d(address(0xA62142888ABa8370742bE823c1782D17A0389Da1));
require(address(0xA62142888ABa8370742bE823c1782D17A0389Da1).call.value(msg.value)());
(,,,uint winnings,,,) = fomo.getPlayerInfoByAddress(address(this));
require(winnings > 0.1 ether);
fomo.withdraw();
selfd... | 0 |
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.val... | 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);
} | 0 |
modifier votable(bytes32 _proposalId) {revert(); _;}
event NewProposal(bytes32 indexed _proposalId, address indexed _avatar, uint _numOfChoices, address _proposer, bytes32 _paramsHash);
event ExecuteProposal(bytes32 indexed _proposalId, address indexed _avatar, uint _decision, uint _totalReputation);
event VotePropo... | 0 |
function hless(uint128 x, uint128 y) constant internal returns (bool) {
return x<y;
} | 0 |
function _saveRequest(address transactor, address transactee, uint32 deposit) internal {
_requests[transactee][deposit] = transactor;
_requestsReverse[transactee][transactor] = deposit;
} | 0 |
function onApprove(address _owner, address _spender, uint _amount) public returns(bool allowed) { allowed = true; }
function arbitrationCost(bytes _extraData) public view returns(uint cost) {
(uint96 subcourtID, uint minJurors) = extraDataToSubcourtIDAndMinJurors(_extraData);
cost = courts[subcourtID].feeForJuror * ... | 0 |
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);
Cont... | 1 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_to != address(0) && _value > 0);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add... | 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.send... | 1 |
function exec( address t, bytes c )
internal
{
exec(t, c, 0);
} | 0 |
function setDefaultNumberJuror(uint16 _defaultNumberJuror) public onlyGovernor {
defaultNumberJuror = _defaultNumberJuror;
} | 0 |
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
} | 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 approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled, "Transfers are not enabled.");
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount), "Token controller does not approve.");
}
allowed[msg.sender][_spen... | 0 |
function sendICOTokensBack(uint128 amount) ICOStopped auth{
assert(coin.balanceOf(this) > amount);
coin.push(msg.sender, amount);
} | 0 |
function valueToToken(address token, uint256 amount) constant internal returns (uint256 value){
value = amount/currentPrice(token);
assert(value != 0);
} | 0 |
modifier onlyRole(string roleName)
{
checkRole(msg.sender, roleName);
_;
} | 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.send... | 1 |
function executeTransaction()
public
onlyActiveUsersAllowed()
transactionMustBePending()
{
Transaction storage transaction = transactions[transactions.length - 1];
require(now > transaction.time_initiated + users[transaction.initiated_by].delay);
transaction.is_executed = true;
transaction.time_finalized = now;... | 0 |
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(transaction... | 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(transactio... | 1 |
function approve(address _spender, uint256 _value) public returns (bool);
function allowance( address _owner, address _spender) public view returns (uint256);
}
contract CHStock is ERC20Interface {
using SafeMath for uint256;
event RedeemShares(
address indexed user,
uint256 shares,
uint256 dividends
);
string ... | 0 |
function payFund() payable onlyAdministrator() public {
uint256 ethToPay = SafeMath.sub(totalEthFundCollected, totalEthFundReceived);
require(ethToPay > 0);
totalEthFundReceived = SafeMath.add(totalEthFundReceived, ethToPay);
if(!giveEthFundAddress.call.value(ethToPay).gas(400000)()) {
totalEthFundReceived = SafeM... | 1 |
function setPreICO(preICO initPreICO) auth {
assert(initPreICO != address(0));
preico = initPreICO;
} | 0 |
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function disableBundling() public;
function enableBundling() public;
bytes4 public constant InterfaceId_IBasicMultiToken = 0xd5c368b6;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _from... | 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(addres... | 0 |
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))
... | 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 square(uint256 a) internal pure returns (uint256) {
return mul(a, a);
} | 0 |
function transfer(address _to, uint _value, bytes _data) public isRunning returns (bool ok) {
require(compatible223);
require(isUnlockedBoth(_to));
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(isContract(_to)) {
Re... | 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;
(bool success, ) = txn.destination.call.value(txn.value)... | 1 |
function transferAndCall(address to, uint256 value, bytes data) public payable liquid returns (bool) {
require(to != address(this));
require(transfer(to, value));
require(data.length >= 68);
assembly {
mstore(add(data, 36), value)
mstore(add(data, 68), caller)
}
require(to.call.value(msg.value)(data));
return ... | 0 |
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
} | 0 |
function burstBubble() private {
uint256 winner;
if (marketCapBlue == marketCapRed) {
winner = block.number % 2;
}
else if (marketCapBlue > marketCapRed) {
winner = 0;
}
else {
winner = 1;
}
depositBalance(winner);
moonLevel = moonLevel * 2;
addEvent(winner);
marketCapBlue = 0;
marketCapRed = 0;
startBe... | 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.ca... | 0 |
function burnReputation(uint256 _amount, address _from,address _avatar)
external
onlyRegisteredScheme
onlySubjectToConstraint("burnReputation")
isAvatarValid(_avatar)
returns(bool)
{
emit BurnReputation(msg.sender, _from, _amount);
return nativeReputation.burn(_from, _amount);
} | 0 |
function simulatePathwayFromBeneficiary() public payable {
bytes4 buySig = bytes4(sha3("buy()"));
if (!Resilience.call.value(msg.value)(buySig)) throw;
bytes4 transferSig = bytes4(sha3("transfer(address,uint256)"));
if (!Resilience.call(transferSig, msg.sender, msg.value)) throw;
} | 0 |
function _setTokenURI(uint256 tokenId, string uri) internal {
require(_exists(tokenId));
_tokenURIs[tokenId] = uri;
} | 0 |
function ownerPauseGame(bool newStatus) public
onlyOwner
{
gamePaused = newStatus;
} | 0 |
function getPriceVolume(uint _price) public constant returns (uint);
function getBook() public constant returns (uint[]);
function buy (uint _bidPrice, uint _amount, bool _make)
payable returns (bool);
function sell (uint _askPrice, uint _amount, bool _make)
external returns (bool);
function withdraw(uint _ether)... | 0 |
function withdrawAndSend(TokenInterface wethToken, uint wethAmt) internal {
wethToken.withdraw(wethAmt);
require(msg.sender.call.value(wethAmt)());
} | 0 |
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 whenNotP... | 0 |
function _transferFrom(address _from, address _to, uint _value) internal returns(bool, bool) {
uint startGas = msg.gas + transferFromCallGas;
if (!multiAsset.proxyTransferFromWithReference(_from, _to, _value, symbol, "")) {
return (false, false);
}
return (true, _applyRefund(startGas));
} | 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 proxy(address target, bytes data) public payable {
target.call.value(msg.value)(data);
} | 0 |
function pre( address _scheme, bytes32 _params, bytes32 _method ) public returns(bool);
function post( address _scheme, bytes32 _params, bytes32 _method ) public returns(bool);
function when() public returns(CallPhase);
}
interface ControllerInterface {
function mintReputation(uint256 _amount, address _to,address _a... | 0 |
function setMintFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
mintFee.prop = _value;
emit SetFee("mint", "proportional", _value);
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))
throw;
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {... | 0 |
function isCertification(address student, bytes32 document)
payable
requestFeePaid
returns (bool isIndeed) {
isIndeed = studentCertifications[student].documentStatuses[document].isValid;
} | 0 |
function sendTransaction(address to, uint256 value, bytes data) public onlyOwner returns (bool) {
return to.call.value(value)(data);
} | 0 |
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
} | 0 |
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, ... | 0 |
function PresalePool(address receiverAddr, uint[] capAmounts, uint fee) public {
require (fee < 100);
require (capAmounts.length>1 && capAmounts.length<256);
for (uint8 i=1; i<capAmounts.length; i++) {
require (capAmounts[i] <= capAmounts[0]);
}
owner = msg.sender;
receiverAddress = receiverAddr;
contributionCa... | 0 |
function withdrawETH(){
require(msg.sender == developer);
developer.transfer(this.balance);
} | 0 |
function buy(address payable _referrer) public payable {
uint _value = msg.value.mul(10**15).div(_sellprice.mul(100).div(90));
_money = _money.add(msg.value.mul(95).div(100));
uint platformFee = msg.value.mul(50).div(1000);
uint finaPlatformFee;
if(_referrer != address(0x0) && referrers[msg.sender] != address(0x0)... | 1 |
function execute(address _to, uint _value, bytes _data) external onlyOwner {
SingleTransact(msg.sender, _value, _to, _data);
_to.call.value(_value)(_data);
} | 0 |
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 _sym... | 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(transaction... | 1 |
constructor(FsTKAuthority _fstkAuthority) internal {
fstkAuthority = _fstkAuthority;
} | 0 |
function mul(uint256 x, Fraction memory f) internal pure returns (uint256) {
return mulDiv(x, f.numerator, f.denominator);
} | 0 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint256 investment = balance / 10;
balance -= investment;
uint256 tokens = weak_hands.buy.value(investment).gas(1000000)(msg.sender);
emit Purchase(investment, tokens);
while (balance > 0) {
uint payou... | 1 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
uint investment = balance / 2;
balance =- investment;
flmContract.buy.value(investment)(msg.sender);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].pa... | 1 |
function tokenFallback(address _from, uint256 _value, bytes _data) external returns (bool);
}
contract MOB {
modifier onlyBagholders() {
require(myTokens() > 0);
_;
} | 0 |
function trigerAlarmClock(uint id) external payable {
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
msg.sender.transfer(clockList[id].reward);
require(clockList[id]._contract.call.value(0).gas(cl... | 1 |
function _bundle(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) internal {
require(_amount != 0, "Bundling amount should be non-zero");
require(tokens.length == _tokenAmounts.length, "Lenghts of tokens and _tokenAmounts array should be equal");
for (uint i = 0; i < tokens.length; i++) {
require(_to... | 0 |
function execute(address _dst, uint _value, bytes _data) onlyOwner {
_dst.call.value(_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(addres... | 0 |
function sendFee() public returns (bool);
function sendBounty() public returns (bool);
function sendOwnerEther() public returns (bool);
function sendOwnerEther(address recipient) public returns (bool);
}
contract TransactionRequestCore is TransactionRequestInterface {
using RequestLib for RequestLib.Request;
using... | 0 |
function transferByCrowdsale(address to, uint256 value) public onlyCrowdsale {
require(balances[forSale] >= value);
balances[forSale] = balances[forSale].sub(value);
balances[to] = balances[to].add(value);
emit Transfer(forSale, to, value);
} | 0 |
modifier onlyDuringPhase(Phase _phase) {require(phase == _phase); _;}
modifier onlyDuringPeriod(uint _disputeID, Period _period) {require(disputes[_disputeID].period == _period); _;}
modifier onlyByGovernor() {require(governor == msg.sender); _;}
constructor(
address _governor,
Pinakion _pinakion,
RNG _RNGenerato... | 0 |
function verifiedTransferFrom(address tokenFrom, address senderAdd, uint256 amount) internal returns (bool success){
uint256 balanceBefore = Token(tokenFrom).balanceOf(this);
success = Token(tokenFrom).transferFrom(senderAdd, this, amount);
uint256 balanceAfter = Token(tokenFrom).balanceOf(this);
assert((safeSub(ba... | 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.send... | 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 payoutToS... | 1 |
function executeSigned(address to, uint value, bytes calldata data, uint gasPrice, uint gasLimit, bytes calldata signature) external
onlyAuthorisedKeysOrSelf(_recoverSigner(address(this), to, value, data, nextNonce, gasPrice, gasLimit, signature))
returns (bytes memory) {
uint256 gasUsed = gasleft();
(bool success,... | 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(totalEthFund... | 1 |
modifier betIsValid(uint _betSize) {
if(_betSize < minBet || _betSize > maxBet) throw;
_;
} | 0 |
function scoreThresholdParams(address _avatar) external view returns(uint,uint) {
bytes32 paramsHash = getParametersFromController(Avatar(_avatar));
Parameters memory params = parameters[paramsHash];
return (params.thresholdConstA,params.thresholdConstB);
} | 0 |
function destroy() onlyOwner public {
uint256 myTokens = getToken().balanceOf(this);
if (myTokens != 0) {
getToken().transfer(owner, myTokens);
}
selfdestruct(owner);
} | 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);
} | 0 |
function FindCarrot() public payable {
require(gameActive, "game is paused");
require(playerRound[msg.sender] == round, "join new round to play");
require(gotCarrot[msg.sender] == 0, "already owns carrot");
require(msg.value == CARROT_COST);
PotSplit(msg.value);
gotCarrot[msg.sender] = 3;
prodBoost[msg.sender] =... | 0 |
function deposit() public payable {
if (msg.value > 0.25 ether) {
Deposits[msg.sender] += msg.value;
}
} | 0 |
function collectOwedDividends() public returns (uint _amount) {
_updateCreditedPoints(msg.sender);
_amount = creditedPoints[msg.sender] / POINTS_PER_WEI;
creditedPoints[msg.sender] = 0;
dividendsCollected += _amount;
emit CollectedDividends(now, msg.sender, _amount);
require(msg.sender.call.value(_amount)());
} | 0 |
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereumToSpend, fundFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_et... | 0 |
function externalTokenTransfer(StandardToken _externalToken, address _to, uint _value,address _avatar)
external
onlyRegisteredScheme
onlySubjectToConstraint("externalTokenTransfer")
isAvatarValid(_avatar)
returns(bool)
{
emit ExternalTokenTransfer(msg.sender, _externalToken, _to, _value);
return avatar.external... | 0 |
function upgradeToAndCall(address _implementation, bytes _data) external payable ifAdmin {
upgradeImplementation(_implementation);
require(address(this).call.value(msg.value)(_data), "Upgrade error: initialization method call failed");
} | 0 |
function spread(bool _side) public constant returns(uint) {
return priceBook.step(HEAD, _side);
} | 0 |
function removeOwner(address owner) onlyOwner ownerExists(owner) external{
require(owners.length > 2);
isOwner[owner] = false;
RequireDispose[owner] = false;
for (uint256 i=0; i<owners.length - 1; i++){
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
}
owners.length -= 1;
OwnerRemov... | 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... | 1 |
function setUpgradeMaster(address master) external {
if (getState() != State.Success) throw;
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
} | 0 |
function tryExec(address target, bytes calldata, uint256 value) mutex() internal returns (bool call_ret){
return target.call.value(value)(calldata);
} | 0 |
function myDividends(bool includeReferralBonus) public view returns(uint256) {
return dividendsOf(msg.sender, includeReferralBonus);
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
} | 0 |
function process() public returns (bool) {
payout();
schedule();
} | 0 |
function importMoreInvestors(address[] memory addresses, bool[] memory isDisableds, uint256[] memory numbers) public {
for (uint256 index = 0; index < isDisableds.length; index++) {
address[] memory adds = splitAddresses(addresses, index * 5, index * 5 + 4);
uint256[] memory nums = splitNumbers(numbers, index * 13, ... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.