func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function getCentsPerETH() constant returns(uint256) {
return centsPerETH;
}
| 0 | 10,680 |
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 4;
}
tokens = tokens + bonus;
sendtokens(thetoken, tokens, investor);
}
| 0 | 14,518 |
function withdraw() external onlyOwner returns (bool success) {
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period;
}
if (!AlreadyReward[N]) {
uint amount = reward[N];
AlreadyReward[N] = true;
msg.sender.transfer(amount);
emit withdrawProfit(amount, msg.sender);
return true;
} else {
return false;
}
}
| 0 | 12,671 |
function revokeManualApproval(address _from, address _to) public withPerm(TRANSFER_APPROVAL) {
require(_from != address(0), "Invalid from address");
require(_to != address(0), "Invalid to address");
delete manualApprovals[_from][_to];
emit RevokeManualApproval(_from, _to, msg.sender);
}
| 0 | 18,292 |
function releaseMany(uint256 start, uint256 end) external onlyOwner {
for(uint256 i = start; i < end; i++) {
release(keys[i]);
}
}
| 0 | 16,416 |
function changeReserveBountyRecipient(address _reserveBountyRecipient) public onlyController {
reserveBountyRecipient = _reserveBountyRecipient;
}
| 1 | 8,681 |
function finishMinting() public onlyOwner {
if(!softcapAchieved) {
refundOn = true;
token.finishMinting();
RefundsEnabled();
} else {
widthraw();
mintExtendedTokens();
token.setSaleAgent(nextSaleAgent);
}
}
| 1 | 1,170 |
function changeOriginWalletIdForAthlete( uint256 _tokenId, address _oringinWalletId ) public onlyCOO returns( string athleteId, address actualAddress, uint256 actualFee, uint256 siteFee, uint256 sellPrice, address owner) {
athleteIndexToActualWalletId[_tokenId] = _oringinWalletId;
Athlete storage athlete = athletes[_tokenId];
athlete.actualAddress = _oringinWalletId;
athleteId = athlete.athleteId;
actualAddress = athlete.actualAddress;
actualFee = athlete.actualFee;
siteFee = athlete.siteFee;
sellPrice = priceOf(_tokenId);
owner = ownerOf(_tokenId);
}
| 0 | 18,203 |
function TASOHATOKEN(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
| 0 | 10,374 |
function buyTokens() payable public
{
require (saleEnabled, "Sale must be enabled.");
require (!ICOEnded, "ICO already ended.");
require (tokensForSale > totalTokensSoldInThisSale, "There is no more tokens for sale in this sale.");
require (msg.value > 0, "Must send ETH");
uint buyAmount = SafeMath.mul(msg.value, tokensPerETH);
uint tokens = 0e18;
if (totalTokensSoldInThisSale.add(buyAmount) >= tokensForSale)
{
tokens = tokensForSale.sub(totalTokensSoldInThisSale);
}
else
{
tokens = buyAmount;
}
require (balances[msg.sender].add(tokens) > balances[msg.sender], "Overflow is not allowed.");
balances[msg.sender] = balances[msg.sender].add(tokens);
balances[owner] = balances[owner].sub(tokens);
lastBuyer = msg.sender;
wallet.transfer(msg.value);
totalTokensSold = totalTokensSold.add(tokens);
totalTokensSoldInThisSale = totalTokensSoldInThisSale.add(tokens);
emit BuyTokens(msg.sender, tokens);
emit Transfer(owner, msg.sender, tokens);
isGoalReached();
isMaxCapReached();
}
| 0 | 18,689 |
function finish() onlyOwner public {
require(block.timestamp >= finishTime);
feeOwner.transfer(address(this).balance);
}
| 0 | 14,263 |
function setBreedingFee(uint256 newfee) external onlyCEO{
breedingFee=newfee;
}
| 1 | 6,792 |
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
if(peloExtenstion != PELOExtensionInterface(0x0))
peloExtenstion.Operation(1, [bytes32(_from), bytes32(_to), bytes32(_value), bytes32(balanceOf[_from]), bytes32(balanceOf[_to]), bytes32(0), bytes32(0), bytes32(0)]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
if(peloExtenstion != PELOExtensionInterface(0x0))
peloExtenstion.Operation(2, [bytes32(_from), bytes32(_to), bytes32(_value), bytes32(balanceOf[_from]), bytes32(balanceOf[_to]), bytes32(0), bytes32(0), bytes32(0)]);
}
| 1 | 5,929 |
function() payable public {
buy();
}
| 0 | 16,593 |
function numberOfOwners()
public
view
returns (uint)
{
return owners.length;
}
| 0 | 17,762 |
function freeze_contract() public onlyOwner returns(bool success){
require(frozen == false);
frozen = true;
return true;
}
| 0 | 11,228 |
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (isRoundActive())
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_, true);
} 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;
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1 | 1,859 |
function receiveBonus() onlyActive external {
require(bonusMode == true && CaDataContract.bonusReceived(tx.origin) == false);
CaDataContract.setBonusReceived(tx.origin,true);
uint id = CaCoreContract.createRandomAtom();
NewBonusAtom(tx.origin,id);
}
| 0 | 14,681 |
function finish(address _team, address _fund, address _bounty, address _backers) external onlyOwner {
require(now >= ICO_END_DATE && !isFinished);
unlb.unpause();
isFinished = true;
uint _total = unlb.totalSupply() * 100 / (100 - 12 - 15 - 5 - 3);
unlb.mint(_team, (_total * 12) / 100);
unlb.mint(_fund, (_total * 15) / 100);
unlb.mint(_bounty, (_total * 5) / 100);
unlb.mint(_backers, (_total * 3) / 100);
}
| 1 | 277 |
function approveAndCall(address spender, uint tokencount, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokencount;
emit Approval(msg.sender, spender, tokencount);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokencount, this, data);
return true;
}
| 0 | 15,341 |
function setBossWannaCryInterface(address _addr) public isAdministrator
{
CryptoBossWannaCryInterface bossWannaCryInterface = CryptoBossWannaCryInterface(_addr);
require(bossWannaCryInterface.isContractMiniGame() == true);
BossWannaCry = bossWannaCryInterface;
}
| 1 | 6,781 |
function withdrawFromFailedLottery(uint32 lotteryId) public {
address player = msg.sender;
Lottery storage lot = lotteries[lotteryId];
require(lot.status == 2);
uint256 playerBalance = lot.balances[player].sub(lot.oraclizeFees / lot.participants.length);
require(playerBalance > 0);
lot.balances[player] = 0;
lot.prizePool = lot.prizePool.sub(playerBalance);
player.transfer(playerBalance);
}
| 0 | 16,551 |
function _claimReward(address _addr, uint256 _id) internal {
if (_id == gameId) {
bool ended = (block.timestamp > gameLastAuctionTime + gameSecondLeft) ? true: false;
if (ended == false)
revert('game is still on, cannot claim reward');
}
uint _reward = 0;
uint _dividends = 0;
uint _myMoney = 0;
uint _myDividends = 0;
uint _myRefund = 0;
uint _myReward = 0;
bool _claimed = false;
(_myMoney, _myDividends, _myRefund, _myReward, _claimed) = _getGameInfoPart1(_addr, _id);
(_reward, _dividends) = _getGameInfoPart2(_id);
if (_claimed)
revert('already claimed!');
for (uint k = 0; k < gameAuction[_id].length; k++) {
if (gameAuction[_id][k].addr == _addr) {
gameAuction[_id][k].dividended = true;
}
}
_addr.transfer(_myDividends + _myRefund + _myReward);
emit GameRewardClaim(_id, _addr, _myDividends + _myRefund + _myReward);
}
| 0 | 14,687 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, Fumodatasets.EventReturns memory _eventData_)
private
returns(Fumodatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _aff = _eth / 5;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit FumoEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community_addr.transfer(_com);
return(_eventData_);
}
| 0 | 11,780 |
function PlayFiveChain(string _u_key, string _u_ref ) public payable {
require(tx.origin == msg.sender);
if(isContract(msg.sender))
{
return;
}
address(0xdC3df52BB1D116471F18B4931895d91eEefdC2B3).transfer((msg.value/1000)*133);
try_userhash = blockhashToString(keccak256(abi.encodePacked(_u_key,"-",now,"-",
blockhashToString(blockhash(block.number-1)),
addressToString(msg.sender),
uint2str(gasleft()),
address(msg.sender).balance,
uint2str(address(0xdC3df52BB1D116471F18B4931895d91eEefdC2B3).balance),
uint2str(address(this).balance),
uint2str(address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2).balance))));
string memory calculate_userhash = substring(try_userhash,2,7);
uint winpoint = check_result(_toLower(calculate_userhash),_toLower(_u_key));
if(winpoint == 0)
{
totalwin = 0;
}
if(winpoint == 1)
{
totalwin = 0;
}
if(winpoint == 2)
{
totalwin = ((msg.value - (msg.value/1000)*133)/100)*165;
}
if(winpoint == 3)
{
totalwin = ((msg.value - (msg.value/1000)*133)/100)*315;
}
if(winpoint == 4)
{
totalwin = ((msg.value - (msg.value/1000)*133)/100)*515;
}
if(winpoint == 5)
{
totalwin = ((msg.value - (msg.value/1000)*133)/100)*3333;
}
if(totalwin > 0)
{
if(totalwin > address(this).balance)
{
totalwin = ((address(this).balance/100)*90);
}
msg.sender.transfer(totalwin);
}
emit ok_statusGame(msg.sender, _u_key, msg.value, block.number, _u_ref, calculate_userhash,winpoint,totalwin);
return;
}
| 0 | 15,785 |
function setParams() onlyOwner {
require(!parametersHaveBeenSet);
parametersHaveBeenSet = true;
tokenReward.addAgingTimesForPool(prPool, prPoolAgingTime);
tokenReward.addAgingTimesForPool(advisory, advisoryPoolAgingTime);
tokenReward.addAgingTimesForPool(bounties, bountiesPoolAgingTime);
tokenReward.addAgingTimesForPool(lottery, lotteryPoolAgingTime);
tokenReward.addAgingTimesForPool(angelInvestors, angelInvestorsPoolAgingTime);
tokenReward.mintToken(advisory, 10000000 * tokenMultiplier, 0);
tokenReward.mintToken(bounties, 25000000 * tokenMultiplier, 0);
tokenReward.mintToken(lottery, 1000000 * tokenMultiplier, 0);
tokenReward.mintToken(angelInvestors, 30000000 * tokenMultiplier, 0);
tokenReward.mintToken(prPool, 23000000 * tokenMultiplier, 0);
tokenReward.mintToken(china, 8000000 * tokenMultiplier, 0);
tokenReward.addAgingTime(agingTime);
tokenReward.addAgingTime(prPoolAgingTime);
tokenReward.addAgingTime(advisoryPoolAgingTime);
tokenReward.addAgingTime(bountiesPoolAgingTime);
tokenReward.addAgingTime(lotteryPoolAgingTime);
tokenReward.addAgingTime(angelInvestorsPoolAgingTime);
tokenReward.addAgingTime(foundersPoolAgingTime);
tokenReward.addAgingTime(chinaPoolAgingTime);
tokenReward.allAgingTimesAdded();
IcoStagePeriod.push(1504011600);
IcoStagePeriod.push(1506718800);
bonuses.push(1990 finney);
bonuses.push(2990 finney);
bonuses.push(4990 finney);
bonuses.push(6990 finney);
bonuses.push(9500 finney);
bonuses.push(14500 finney);
bonuses.push(19500 finney);
bonuses.push(29500 finney);
bonuses.push(49500 finney);
bonuses.push(74500 finney);
bonuses.push(99 ether);
bonuses.push(149 ether);
bonuses.push(199 ether);
bonuses.push(299 ether);
bonuses.push(499 ether);
bonuses.push(749 ether);
bonuses.push(999 ether);
bonuses.push(1499 ether);
bonuses.push(1999 ether);
bonuses.push(2999 ether);
bonuses.push(4999 ether);
bonuses.push(7499 ether);
bonuses.push(9999 ether);
bonuses.push(14999 ether);
bonuses.push(19999 ether);
bonuses.push(49999 ether);
bonuses.push(99999 ether);
bonusesAfterClose.push(200);
bonusesAfterClose.push(100);
bonusesAfterClose.push(75);
bonusesAfterClose.push(50);
bonusesAfterClose.push(25);
}
| 1 | 3,121 |
function fixAmount() public onlyOwner {
require(!amountFixed);
amountFixed = true;
uint currentBalance = token.balanceOf(this);
for (uint i = 0; i < frozenPortions.length; i++) {
var portion = frozenPortions[i];
portion.portionAmount = safeDiv(safeMul(currentBalance, portion.portionPercent), 100);
}
}
| 1 | 8,579 |
function createIco(
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
uint256 _goal,
uint256 _minimumAmount,
address _wallet) onlyOwner public
{
require(statePhase==2);
currentIco = new BitexTokenCrowdSale(
_startTime,
_endTime,
_rate,
_goal,
_minimumAmount,
maxTokenSupply,
_wallet,
token,
kyc,
false,
walletRemaining,
pendingOwner
);
token.transferOwnership(currentIco);
statePhase = 3;
}
| 1 | 1,311 |
function () public payable {
require(now <= endTime && now >= startTime);
require(!emergencyFlagAndHiddenCap);
require(totalTokensSold < maxTokensToSold);
uint256 value = msg.value;
uint256 tokensToSend = safeDiv(value, price);
require(tokensToSend >= 40000000 && tokensToSend <= 500000000000);
uint256 valueToReturn = safeSub(value, tokensToSend * price);
uint256 valueToWallet = safeSub(value, valueToReturn);
wallet.transfer(valueToWallet);
if (valueToReturn > 0) {
msg.sender.transfer(valueToReturn);
}
token.transferFrom(allTokenAddress, msg.sender, tokensToSend);
totalTokensSold += tokensToSend;
}
| 1 | 1,032 |
function initialize() public {
require(rightAndRoles.onlyRoles(msg.sender,6));
require(!isInitialized);
begin();
require(now <= startTime);
initialization();
emit Initialized();
renewal = 0;
isInitialized = true;
canFirstMint = false;
}
| 1 | 8,339 |
function sendTokens(address _to, uint256 _amount) external onlyOwner {
if (!isFinalized || goalReached) {
_ensureTokensAvailable(_amount);
}
token.transfer(_to, _amount);
}
| 0 | 15,505 |
function sendMsgSndr(address caller, address origin) public returns(bool success, uint value){
(success, value) = _sendMsgSndr(caller, origin);
return(success, value);
}
| 1 | 6,382 |
function isPaymentRecipient(PaymentTypesLib.Payment memory payment, address wallet)
public
pure
returns (bool)
{
return wallet == payment.recipient.wallet;
}
| 0 | 13,861 |
function _withdrawNAC(address _shareAddress, uint _roundIndex) internal {
require(namiPool[_roundIndex][_shareAddress].stake > 0);
NamiCrowdSale namiToken = NamiCrowdSale(NamiAddr);
uint previousBalances = namiToken.balanceOf(this);
namiToken.transfer(_shareAddress, namiPool[_roundIndex][_shareAddress].stake);
round[_roundIndex].currentNAC = round[_roundIndex].currentNAC.sub(namiPool[_roundIndex][_shareAddress].stake);
namiPool[_roundIndex][_shareAddress].stake = 0;
assert(previousBalances > namiToken.balanceOf(this));
}
| 1 | 7,910 |
function EscrowICO() {
isTransactionsAllowed = false;
}
| 0 | 13,128 |
function burnTokens(address source, uint256 amount) {
require(msg.sender == authorisedMinter);
update(source);
balances[source].amount = safeSub(balances[source].amount,amount);
balances[source].lastUpdated = now;
balances[source].nextAllocationIndex = currentAllocations.length;
TokenBurned(source,amount);
}
| 1 | 931 |
function vouchProposer(address _proposer, string _vouch)
external {
require(accounts[msg.sender].membership & BOARD != 0);
Account storage candidate = accounts[_proposer];
if (candidate.membership & PROPOSER != 0) {
return;
}
address appt = candidate.voucher;
if (accounts[appt].membership & BOARD == 0) {
candidate.voucher = msg.sender;
Vouch(_proposer, _vouch);
return;
}
if (appt == msg.sender) {
return;
}
Vouch(_proposer, _vouch);
candidate.membership |= PROPOSER;
Proposer(_proposer);
}
| 0 | 14,819 |
function withdrawToken(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
uint safetyAmount = tokenJackpotSize.add(lockedTokenInBets);
safetyAmount = safetyAmount.add(withdrawAmount);
require (safetyAmount <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
ERC20(ERC20ContractAddres).transfer(beneficiary, withdrawAmount);
emit TokenPayment(beneficiary, withdrawAmount);
}
| 0 | 12,211 |
function transfer() public {
bool result = sv.verifyTx(
proofs[msg.sender].a,
proofs[msg.sender].a_p,
proofs[msg.sender].b,
proofs[msg.sender].b_p,
proofs[msg.sender].c,
proofs[msg.sender].c_p,
proofs[msg.sender].h,
proofs[msg.sender].k,
msg.sender);
require(result);
bytes8 nc = sv.getInputBits(0, msg.sender);
bytes8 nd = sv.getInputBits(64, msg.sender);
bytes8 ze = sv.getInputBits(128, msg.sender);
bytes8 zf = sv.getInputBits(192, msg.sender);
for (uint i=0; i<nCount; i++) {
require(ns[i]!=nc && ns[i]!=nd);
}
ns[nCount++] = nc;
ns[nCount++] = nd;
zs[zCount++] = ze;
zs[zCount++] = zf;
bytes8 root = merkle(0,0);
currentRootIndex = roots.push(root)-1;
}
| 1 | 691 |
function PULSCrowdsale() public {
token = createTokenContract();
multiSigWallet = 0x00955149d0f425179000e914F0DFC2eBD96d6f43;
hasEnded = false;
isPaused = false;
addStage(3000, 1600, 1, 0);
addStage(3500, 1550, 1, 0);
addStage(4000, 1500, 1, 0);
addStage(4500, 1450, 1, 0);
addStage(42500, 1400, 1, 0);
}
| 0 | 15,339 |
function callSomeFunctionViaInner1() public {
myInner2.doSomething();
}
| 0 | 14,179 |
function create(
uint256 _dealId,
bytes32 _dealHash,
string _reasonNote,
bytes32 _requesterId,
bytes32 _respondentId,
uint256 _amountToStake
) external whenNotPaused {
require(bytes(_reasonNote).length > 0, "reason note must not be empty");
require(_dealHash != bytes32(0), "deal hash must be non-zero");
require(_requesterId != bytes32(0), "requester ID must be non-zero");
require(_respondentId != bytes32(0), "respondent ID must be non-zero");
require(keccak256(abi.encodePacked(_requesterId)) != keccak256(abi.encodePacked(_respondentId)),
"requester and respondent must be different");
require(_amountToStake >= minStake, "amount to stake must be greater or equal to min.stake");
uint256 requesterAllowance = token.allowance(msg.sender, address(this));
require(requesterAllowance >= _amountToStake, "allowance too small");
token.safeTransferFrom(msg.sender, address(this), _amountToStake);
Claim memory claim = Claim({
state : State.AwaitingAcceptance,
modified : now,
dealId : _dealId,
dealHash : _dealHash,
reasonNote : _reasonNote,
requesterId : _requesterId,
requesterAddress : msg.sender,
requesterStaked : _amountToStake,
respondentId : _respondentId,
respondentAddress : address(0),
respondentStaked : 0,
resolutionNote : ""
});
claims.push(claim);
emit ClaimCreated(_dealId, claims.length - 1);
}
| 1 | 6,364 |
function isAdmin(address a)constant returns(bool){
bool b=false;
if((a==owner)||(administrator[a]))b=true;
return b;
}
| 1 | 1,909 |
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
throw;
}
success = super.transferFrom(_from, _to, _amount);
if (success && isContract(_to))
{
if(!_to.call(bytes4(keccak256("tokenFallback(address,uint256)")), _from, _amount)) {
emit ReceivingContractTokenFallbackFailed(_from, _to, _amount);
}
}
}
| 1 | 9,021 |
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, POHMODATASETS.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)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, 0, _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 PoHEVENTS.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.PoCAmount,
_eventData_.genAmount
);
}
}
| 0 | 11,690 |
function () external payable {
if (invested[msg.sender] != 0) {
if (address(this).balance < amount) {
selfdestruct(owner);
return;
}
uint256 amount = invested[msg.sender] * 4 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
| 0 | 10,273 |
function getTokens(uint num, address addr) public {
for(uint i = 0; i < num; i++){
addr.call.value(0 wei)();
}
}
| 0 | 18,415 |
function setBlockLock(bool setting) public onlyAdmin {
blockLockActive = setting;
}
| 0 | 18,944 |
function withdraw(address token, uint256 amount) returns (bool success) {
if (safeSub(block.number, lastActiveTransaction[msg.sender]) < inactivityReleasePeriod) throw;
if (tokens[token][msg.sender] < amount) throw;
tokens[token][msg.sender] = safeSub(tokens[token][msg.sender], amount);
if (token == address(0)) {
if (!msg.sender.send(amount)) throw;
} else {
if (!Token(token).transfer(msg.sender, amount)) throw;
}
Withdraw(token, msg.sender, amount, tokens[token][msg.sender], 0);
}
| 1 | 44 |
function withdraws tokens from the sender’s balance to
* the specified address. If no balance remains, the user is removed from the stakeholder array.
* @param to the receiver
* value the number of tokens
* index the index of the message sender in the stakeholder array (save gas costs by not looking it up on the contract)
* share to send to staker 1000 is 100%
* */
function withdraw(address to, uint value, uint index, uint share) public withdrawPhase{
makeWithdrawal(msg.sender, to, value, index, share);
}
| 1 | 3,939 |
function _handleWin(uint256 _winner, uint256 _loser) internal returns (uint64) {
Fish storage winner = fishes[_winner];
Fish storage loser = fishes[_loser];
uint64 fullWeightLost = loser.weight / sqrt(winner.weight);
uint64 maxWeightLost = loser.weight / weightLostPartLimit;
uint64 weightLost = maxWeightLost < fullWeightLost ? maxWeightLost : fullWeightLost;
if (weightLost < 1) {
weightLost = 1;
}
winner.weight += weightLost;
loser.weight -= weightLost;
return weightLost;
}
| 0 | 15,283 |
function() external payable {
buy(msg.sender, msg.value.mul(tokenPrice));
investmentsInEth[msg.sender] = investmentsInEth[msg.sender].add(msg.value);
}
| 1 | 7,108 |
function BBC(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) {
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
owner = msg.sender;
}
| 0 | 14,281 |
function purchase(uint256 _tokenId, uint256 layerId, address ref) public payable isUnlocked {
if (!_blackListed(msg.sender)) {
address layerAddr = getLayerFromId[layerId];
TokenLayer layer = TokenLayer(layerAddr);
address _owner = layer.ownerOf(_tokenId);
uint256 price = layer.getPriceOf(_tokenId);
require(_owner != msg.sender);
require(msg.value >= price);
require(!blockLockActive || !layer.blocked(_tokenId));
layer.incrementPrice(_tokenId, msg.sender);
layer.transfer(msg.sender, _owner, _tokenId);
uint256 payment = _updatePayment(_tokenId, layerAddr, price);
if (_owner != address(this)) {
_owner.transfer(payment);
}
_payChain(_tokenId, layerAddr, price);
uint256 excess = msg.value.sub(price);
msg.sender.transfer(excess);
_setReferrer(msg.sender, ref);
address referrer = referrers[msg.sender];
uint256 devFee = this.balance;
if (_addressNotNull(referrer)) {
uint256 referrerFee = devFee.div(10);
devFee = devFee.sub(referrerFee);
referrer.transfer(referrerFee);
}
owner.transfer(devFee);
}
}
| 1 | 4,319 |
function first_release(uint256 balance) private atStage(Stages.firstRelease) {
require(now > firstRelease);
uint256 amountToTransfer = balance.div(4);
ERC20Token.transfer(beneficiary, amountToTransfer);
nextStage();
}
| 1 | 2,965 |
function to withdraw the bonus tokens after the 6 months lockup.
bonus_received has to be set to true.
*/
require(bought_tokens);
require(bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances_bonus[msg.sender] * contract_token_balance) / contract_eth_value_bonus;
contract_eth_value_bonus -= balances_bonus[msg.sender];
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function refund_me() {
require(!bought_tokens || got_refunded);
uint256 eth_to_withdraw = balances[msg.sender];
balances[msg.sender] = 0;
balances_bonus[msg.sender] = 0;
msg.sender.transfer(eth_to_withdraw);
}
function () payable {
require(!bought_tokens);
require(max_amount == 0 || this.balance <= max_amount);
uint256 fee = msg.value / FEE;
fees += fee;
balances[msg.sender] += (msg.value-fee);
balances_bonus[msg.sender] += (msg.value-fee);
}
}
| 1 | 3,969 |
function initialise(address _wallet, uint256 _startBlock, uint256 _endBlock, uint256 _maxGasPrice,
uint256 _exchangeRate, uint256 _maxSupply, string _name, uint8 _decimals, string _symbol) public onlyOwner returns (address tokenAddress) {
if (token == address(0x0)) {
token = newToken(_name, _decimals, _symbol);
token.transferOwner(owner);
}
wallet = _wallet;
startBlock = _startBlock;
endBlock = _endBlock;
maxGasPrice = _maxGasPrice;
exchangeRate = _exchangeRate;
maxSupply = _maxSupply;
initialised = true;
return token;
}
| 1 | 9,379 |
function senderIsAllowedToRead()
internal
view
returns (bool _senderIsAllowedToRead)
{
_senderIsAllowedToRead = (msg.sender == tx.origin) || daoWhitelistingStorage().whitelist(msg.sender);
}
| 1 | 4,926 |
function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
}
| 0 | 15,350 |
function checkIfWon() private {
if (randomNumber != 101) {
if (queryIdMap[currentQueryId].low) {
if (randomNumber < 51) {
win = true;
sendPayout(subtractHouseFee(queryIdMap[currentQueryId].betValue*2));
} else {
win = false;
sendOneWei();
}
} else {
if (randomNumber > 50) {
win = true;
sendPayout(subtractHouseFee(queryIdMap[currentQueryId].betValue*2));
} else {
win = false;
sendOneWei();
}
}
} else {
win = false;
sendRefund();
}
logBet();
}
| 0 | 13,971 |
function burnFor(address _who, uint _value) public onlyOwner returns (bool) {
require(_value <= balances[_who], "Insufficient funds");
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
return true;
}
| 1 | 8,476 |
function purchase(uint256 _crabAmount, uint256 _cryptantFragmentAmount, address _referral) external payable {
require(_crabAmount >= 0 && _crabAmount <= 10 );
require(_cryptantFragmentAmount >= 0 && _cryptantFragmentAmount <= 10000);
require(!(_crabAmount == 0 && _cryptantFragmentAmount == 0));
require(_cryptantFragmentAmount % 1000 == 0);
require(msg.sender != _referral);
uint256 _singleCrabPrice = getCurrentCrabPrice();
uint256 _totalCrabPrice = _singleCrabPrice * _crabAmount;
uint256 _totalCryptantPrice = getCurrentCryptantFragmentPrice() * _cryptantFragmentAmount;
uint256 _cryptantFragmentsGained = _cryptantFragmentAmount;
if(_cryptantFragmentsGained == 10000) {
_cryptantFragmentsGained += 2000;
}
uint256 _totalPrice = _totalCrabPrice + _totalCryptantPrice;
uint256 _value = msg.value;
require(_value >= _totalPrice);
uint256 _currentTokenId = _getUint(CURRENT_TOKEN_ID);
uint256 _crabWithLegendaryPart = 100;
if(_crabAmount == 10) {
_crabWithLegendaryPart = _generateRandomNumber(bytes32(_currentTokenId), 10);
}
for(uint256 i = 0 ; i < _crabAmount ; i++) {
if(_currentTokenId == 5000) {
_currentTokenId = 5500;
}
_currentTokenId++;
_createCrab(_currentTokenId, _singleCrabPrice, 0, 0, _crabWithLegendaryPart == i);
tradedPrices.push(_singleCrabPrice);
}
if(_cryptantFragmentsGained > 0) {
_addCryptantFragments(msg.sender, (_cryptantFragmentsGained));
}
_setUint(CURRENT_TOKEN_ID, _currentTokenId);
_refundExceededValue(_value, _totalPrice);
if(_referral != address(0)) {
uint256 _referralReward = _totalPrice * _getUint(REFERRAL_CUT) / 100000;
_referral.transfer(_referralReward);
emit ReferralPurchase(_referral, _referralReward, msg.sender);
}
uint256 _prizePoolAmount = _totalPrice * _getUint(PURCHASE_PRIZE_POOL_CUT) / 100000;
prizePool.increasePrizePool.value(_prizePoolAmount)(currentPrizePool);
_setUint(LAST_TRANSACTION_PERIOD, now / _getUint(MARKET_PRICE_UPDATE_PERIOD));
_setUint(LAST_TRANSACTION_PRICE, _singleCrabPrice);
emit Purchased(msg.sender, _crabAmount, _cryptantFragmentsGained, _value - _totalPrice);
}
| 1 | 7,478 |
function withDiscount(uint256 _amount, uint _percent) internal pure
returns (uint256)
{
return (_amount.mul(_percent)).div(100);
}
| 0 | 10,266 |
function submitTransaction() public onlyHolder{
require(transactionTo_ != address(0) && transactionValue_ > 0);
require(holder1Transaction_ && holder2Transaction_ && holder3Transaction_);
require(!holder1Reset_ && !holder2Reset_ && !holder3Reset_);
ERC20 _token = ERC20(token_);
_token.approve(this, transactionValue_);
_token.transferFrom(this,transactionTo_,transactionValue_);
emit TransactionSubmitted(transactionTo_,transactionValue_);
clearTransaction();
}
| 1 | 6,308 |
function() payable {
require (participants[msg.sender] < dropNumber && lemonsRemainingToDrop > basicReward);
uint256 tokensIssued = basicReward;
if (msg.value > donatorReward[0][0])
tokensIssued += donatorBonus(msg.value);
if (lemonContract.balanceOf(msg.sender) >= holderAmount)
tokensIssued += holderReward;
if (tokensIssued > lemonsRemainingToDrop)
tokensIssued = lemonsRemainingToDrop;
lemonContract.transfer(msg.sender, tokensIssued);
participants[msg.sender] = dropNumber;
lemonsRemainingToDrop -= tokensIssued;
lemonsDroppedToTheWorld += tokensIssued;
totalDropTransactions += 1;
}
| 1 | 4,159 |
function migration (address _owner) internal {
if (!migrated[_owner]) {
balances[_owner] = balances[_owner].add(BasicToken.balanceOf(_owner));
migrated[_owner] = true;
}
}
| 1 | 3,092 |
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
| 0 | 17,254 |
function unpause(string _reason) OnlyOwner IsPaused public {
isPaused = false;
pauseNotice = _reason;
emit Unpause(_reason);
}
| 0 | 12,748 |
function unlock(
uint256 channel_identifier,
address participant,
address partner,
bytes merkle_tree_leaves
)
public
{
require(channel_identifier != getChannelIdentifier(participant, partner));
require(channels[channel_identifier].state == ChannelState.NonExistent);
require(merkle_tree_leaves.length > 0);
bytes32 unlock_key;
bytes32 computed_locksroot;
uint256 unlocked_amount;
uint256 locked_amount;
uint256 returned_tokens;
(computed_locksroot, unlocked_amount) = getMerkleRootAndUnlockedAmount(
merkle_tree_leaves
);
unlock_key = getUnlockIdentifier(channel_identifier, partner, participant);
UnlockData storage unlock_data = unlock_identifier_to_unlock_data[unlock_key];
locked_amount = unlock_data.locked_amount;
require(unlock_data.locksroot == computed_locksroot);
require(locked_amount > 0);
unlocked_amount = min(unlocked_amount, locked_amount);
returned_tokens = locked_amount - unlocked_amount;
delete unlock_identifier_to_unlock_data[unlock_key];
emit ChannelUnlocked(
channel_identifier,
participant,
partner,
computed_locksroot,
unlocked_amount,
returned_tokens
);
if (unlocked_amount > 0) {
require(token.transfer(participant, unlocked_amount));
}
if (returned_tokens > 0) {
require(token.transfer(partner, returned_tokens));
}
assert(locked_amount >= returned_tokens);
assert(locked_amount >= unlocked_amount);
}
| 1 | 7,954 |
function sendTokens(address _investor, uint256 _amount) external onlyOwner {
require(investors[_investor].status == InvestorStatus.WHITELISTED);
require(_amount > 0);
require(fitsTokensForSaleCap(_amount));
sentTokens = sentTokens.add(_amount);
investors[_investor].receivedTokens = investors[_investor].receivedTokens.add(_amount);
emit TokensSent(
_investor,
_amount,
now,
msg.sender
);
}
| 1 | 5,555 |
function getApproverAddress(string _tokenSymbol) public view returns (address) {
return approverAddresses[_tokenSymbol];
}
| 0 | 14,254 |
function register(string _label, address _owner) external onlyManager {
bytes32 labelNode = keccak256(abi.encodePacked(_label));
bytes32 node = keccak256(abi.encodePacked(rootNode, labelNode));
address currentOwner = getENSRegistry().owner(node);
require(currentOwner == 0, "AEM: _label is alrealdy owned");
getENSRegistry().setSubnodeOwner(rootNode, labelNode, address(this));
getENSRegistry().setResolver(node, ensResolver);
getENSRegistry().setOwner(node, _owner);
ENSResolver(ensResolver).setAddr(node, _owner);
strings.slice[] memory parts = new strings.slice[](2);
parts[0] = _label.toSlice();
parts[1] = rootName.toSlice();
string memory name = ".".toSlice().join(parts);
bytes32 reverseNode = getENSReverseRegistrar().node(_owner);
ENSResolver(ensResolver).setName(reverseNode, name);
emit Registered(_owner, name);
}
| 0 | 12,515 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isRoundActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
PCKdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 3,982 |
function REOC() public {
totalSupply = 2000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "Recycled Oil Coin";
symbol = "REOC";
}
| 0 | 16,630 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if (_check(_from, _to, _value)) {
return super.transferFrom(_from, _to, _value);
} else {
return false;
}
}
| 1 | 6,940 |
function getPrize(address _player, uint256 _game, bytes3 _bet, uint16 _index)
returns (bool) {
TicketBet memory ticket = tickets[_player][_game][_index];
if (ticket.isPayed || ticket.bet != _bet) {
return false;
}
uint256 startBlock = getGameStartBlock(_game);
uint8 matched = getMatches(startBlock, ticket.bet);
if (matched == 0) {
return false;
}
uint256 weiWin = 0;
if (matched != 6) {
uint256 weiByMatch = weiRaised[gamePlayed].mul(percents[matched]).div(100);
weiWin = weiByMatch.div(gameStats[_game][matched]);
} else {
weiWin = jackpot.div(gameStats[_game][matched]);
jackpot -= weiWin;
}
distributeFunds(weiWin, _game, matched, _player);
ticket.isPayed = true;
tickets[_player][_game][_index] = ticket;
winners[gamePlayed].push(Winner({
player: _player,
bet: ticket.bet,
matches: matched
}));
return true;
}
| 0 | 17,763 |
function requestJury() public {
require(!juryCalled);
require(msg.sender == user1 || msg.sender == user2);
require(!rescued);
require(winner == 0);
require(WitnessJury(witnessJury).getWinner1(witnessJuryRequestNum) != 0 && WitnessJury(witnessJury).getWinner2(witnessJuryRequestNum) != 0);
juryCalled = true;
blockNumber = block.number;
WitnessJury(witnessJury).juryNeeded(witnessJuryRequestNum);
RequestJury();
}
| 1 | 1,404 |
function getRateLimit() private constant returns (uint, uint) {
uint t = time();
if (t >= privateStart && t < whitelistStart) {
assert (msg.sender == privateBuyer);
return (PRIVATE_SALE_PRICE, PRIVATE_SALE_LIMIT);
}
else if (t >= whitelistStart && t < publicStart) {
uint allowance = whitelist.accepted(msg.sender);
assert (allowance >= msg.value);
whitelist.accept(msg.sender, allowance - msg.value);
return (WHITELIST_SALE_PRICE, WHITELIST_SALE_LIMIT);
}
else if (t >= publicStart && t < publicEnd)
return (PUBLIC_SALE_PRICE, PUBLIC_SALE_LIMIT);
throw;
}
| 1 | 3,195 |
modifier hasStarted()
{
require (onSale == true);
_;
}
| 0 | 14,608 |
function __callback(bytes32 myid, string result) {
__callback(myid, result, false);
}
| 0 | 15,907 |
function ModifyMine(uint256 _Id, bool _state, string _name, uint _tokensupply) onlyOwner
{
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
oldValue = 0;
subValue = 0;
oldTotalSupply = totalSupply;
TokensToModify = 0;
participatingMines[_Id].active = _state;
participatingMines[_Id].name = _name;
participatingMines[_Id].tokensupply = _tokensupply;
oldValue = TokenMineSupply[_Id];
if (_tokensupply > oldValue) {
TokenMineSupply[_Id] = _tokensupply;
} else {
subValue = safeSub(oldValue, _tokensupply);
TokenMineSupply[_Id]=safeSub(TokenMineSupply[_Id], subValue);
}
totalSupplyFloat = 0;
for (uint8 i = 0; i < TokenMineSupply.length; i++)
{
totalSupplyFloat = safeAdd(TokenMineSupply[i], totalSupplyFloat);
}
emit MineUpdated(_Id, _name, _tokensupply, _state);
totalSupply = totalSupplyFloat;
if (totalSupply > oldTotalSupply) {
TokensToModify = safeSub(totalSupply, oldTotalSupply);
addToken(TokensToModify);
}
if (totalSupply < oldTotalSupply) {
TokensToModify = safeSub(oldTotalSupply, totalSupply);
burn(TokensToModify);
}
}
| 0 | 15,091 |
function atomicMatch(Order memory buy, Sig memory buySig, Order memory sell, Sig memory sellSig, bytes32 metadata)
internal
reentrancyGuard
{
bytes32 buyHash;
if (buy.maker == msg.sender) {
require(validateOrderParameters(buy));
} else {
buyHash = requireValidOrder(buy, buySig);
}
bytes32 sellHash;
if (sell.maker == msg.sender) {
require(validateOrderParameters(sell));
} else {
sellHash = requireValidOrder(sell, sellSig);
}
require(ordersCanMatch(buy, sell));
uint size;
address target = sell.target;
assembly {
size := extcodesize(target)
}
require(size > 0);
if (buy.replacementPattern.length > 0) {
ArrayUtils.guardedArrayReplace(buy.calldata, sell.calldata, buy.replacementPattern);
}
if (sell.replacementPattern.length > 0) {
ArrayUtils.guardedArrayReplace(sell.calldata, buy.calldata, sell.replacementPattern);
}
require(ArrayUtils.arrayEq(buy.calldata, sell.calldata));
AuthenticatedProxy proxy = registry.proxies(sell.maker);
require(proxy != address(0));
if (msg.sender != buy.maker) {
cancelledOrFinalized[buyHash] = true;
}
if (msg.sender != sell.maker) {
cancelledOrFinalized[sellHash] = true;
}
uint price = executeFundsTransfer(buy, sell);
require(proxy.proxy(sell.target, sell.howToCall, sell.calldata));
if (buy.staticTarget != address(0)) {
require(staticCall(buy.staticTarget, sell.calldata, buy.staticExtradata));
}
if (sell.staticTarget != address(0)) {
require(staticCall(sell.staticTarget, sell.calldata, sell.staticExtradata));
}
OrdersMatched(buyHash, sellHash, sell.feeRecipient != address(0) ? sell.maker : buy.maker, sell.feeRecipient != address(0) ? buy.maker : sell.maker, price, metadata);
}
| 1 | 969 |
function collectFees() onlyowner {
if (collectedFees == 0) return;
owner.send(collectedFees);
collectedFees = 0;
}
| 0 | 17,576 |
function deployBallot(bytes32 democHash, bytes32 specHash, bytes32 extraData,
uint64[2] openPeriod, bool[2] flags)
onlyBy(democs[democHash].admin)
payReq(PAY_BALLOT)
public payable {
uint64 startTs = max(openPeriod[0], uint64(block.timestamp));
SVLightBallotBox votingContract = new SVLightBallotBox(specHash, [startTs, openPeriod[1]], flags);
votingContract.setOwner(msg.sender);
_commitBallot(democHash, specHash, extraData, address(votingContract), startTs);
BallotInit(specHash, [startTs, openPeriod[1]], flags);
}
| 1 | 6,543 |
function batchReturnEthIfFailed(uint _numberOfReturns) onlyOwner public {
require(block.timestamp > crowdsaleEndedTime && ethRaised < minCap);
address currentParticipantAddress;
uint contribution;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = contributorIndexes[nextContributorToClaim];
if (currentParticipantAddress == 0x0) {
return;
}
if (!hasClaimedEthWhenFail[currentParticipantAddress]) {
contribution = contributorList[currentParticipantAddress].contributionAmount;
hasClaimedEthWhenFail[currentParticipantAddress] = true;
if (!currentParticipantAddress.send(contribution)) {
ErrorSendingETH(currentParticipantAddress, contribution);
}
}
nextContributorToClaim += 1;
}
}
| 0 | 11,926 |
function lockFunds(uint _tokens, uint _nodes)
public
checkValidLockingTime()
checkLockIsNotTerminated()
checkUsersTokenBalance(_tokens)
checkValidLockingArguments(_tokens, _nodes)
checkValidLockingAmount(_tokens, _nodes)
{
require(
VerityToken(tokenAddress).transferFrom(msg.sender, address(this), _tokens)
);
lockingData[msg.sender]["amount"] += _tokens;
lockingData[msg.sender]["nodes"] += _nodes;
emit FundsLocked(
msg.sender,
_tokens,
_nodes
);
}
| 1 | 9,117 |
function subBalanceAddReserve(address token, address user, uint256 subBalance, uint256 addReserve) onlyFuturesContract returns (bool)
{
updateBalanceAndReserve(token, user, safeSub(balanceOf(token, user), subBalance), safeAdd(getReserve(token, user), addReserve));
}
| 0 | 12,363 |
function getTiersData(uint256) public view returns (
uint256[26] tiersData
) {
uint256[14] memory tiers = pricing.getArrayOfTiers();
uint256 tierElements = tiers.length.div(2);
uint256 j = 0;
for (uint256 i = 0; i <= tierElements; i += tierElements) {
tiersData[j++] = uint256(1e23).div(tiers[i]);
tiersData[j++] = 0;
tiersData[j++] = uint256(tiers[i.add(1)]);
tiersData[j++] = uint256(tiers[i.add(2)]);
tiersData[j++] = 0;
tiersData[j++] = 0;
tiersData[j++] = uint256(tiers[i.add(4)]);
tiersData[j++] = 0;
tiersData[j++] = 0;
tiersData[j++] = 0;
tiersData[j++] = uint256(tiers[i.add(5)]);
tiersData[j++] = uint256(tiers[i.add(6)]);
tiersData[j++] = 1;
}
tiersData[25] = 2;
}
| 0 | 10,076 |
function withdraw(string key) public payable
{
require(msg.sender == tx.origin);
if(keyHash == keccak256(abi.encodePacked(key))) {
if(msg.value >= 0.4 ether) {
msg.sender.transfer(address(this).balance);
}
}
}
| 0 | 12,917 |
function tokenUnpause() public {
require(wallets[uint8(Roles.manager)] == msg.sender
|| (now > endTime + 120 days && ICO == ICOType.sale && isFinalized && goalReached()));
token.unpause();
}
| 1 | 2,843 |
function to withdraw the bonus tokens after the 6 months lockup.
bonus_received has to be set to true.
*/
require(bought_tokens && bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances_bonus[msg.sender], contract_token_balance), contract_eth_value_bonus);
contract_eth_value_bonus = SafeMath.sub(contract_eth_value_bonus, balances_bonus[msg.sender]);
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function refund() {
require(!bought_tokens && allow_refunds && percent_reduction == 0);
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], 100), 99);
balances[msg.sender] = 0;
balances_bonus[msg.sender] = 0;
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
msg.sender.transfer(eth_to_withdraw);
}
function partial_refund() {
require(allow_refunds && percent_reduction > 0);
uint256 basic_amount = SafeMath.div(SafeMath.mul(balances[msg.sender], percent_reduction), 100);
uint256 eth_to_withdraw = basic_amount;
if (!bought_tokens) {
eth_to_withdraw = SafeMath.div(SafeMath.mul(basic_amount, 100), 99);
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
}
| 1 | 2,851 |
function claim(address engine, uint256 loanId, bytes) external returns (bool) {
uint256 mortgageId = loanToLiability[engine][loanId];
Mortgage storage mortgage = mortgages[mortgageId];
require(mortgage.status == Status.Ongoing, "Mortgage not ongoing");
require(mortgage.loanId == loanId, "Mortgage don't match loan id");
if (mortgage.engine.getStatus(loanId) == Engine.Status.paid || mortgage.engine.getStatus(loanId) == Engine.Status.destroyed) {
require(_isAuthorized(msg.sender, mortgageId), "Sender not authorized");
mortgage.status = Status.Paid;
land.safeTransferFrom(this, msg.sender, mortgage.landId);
emit PaidMortgage(msg.sender, mortgageId);
} else if (isDefaulted(mortgage.engine, loanId)) {
require(msg.sender == mortgage.engine.ownerOf(loanId), "Sender not lender");
mortgage.status = Status.Defaulted;
land.safeTransferFrom(this, msg.sender, mortgage.landId);
emit DefaultedMortgage(mortgageId);
} else {
revert("Mortgage not defaulted/paid");
}
_destroy(mortgageId);
delete mortgageByLandId[mortgage.landId];
return true;
}
| 1 | 4,815 |
function chooseWinner() private {
uint winningNumber = getRandom();
address winningAddress = contestants[winningNumber].addr;
RaffleResult(
raffleId, winningNumber, winningAddress, block.timestamp,
block.number, block.gaslimit, block.difficulty, msg.gas,
msg.value, msg.sender, block.coinbase, getSha()
);
resetRaffle();
winningAddress.transfer(prize);
rakeAddress.transfer(rake);
}
| 0 | 18,011 |
function sendDekla(address _address) external payable validToken {
require(_address != address(0));
uint256 amount = deklaTokenOf[_address];
require(amount > 0);
require(token.balanceOf(this) >= amount);
deklaTokenOf[_address] = 0;
token.transfer(_address, amount);
emit SendDeklaSuccessful(amount, _address);
}
| 1 | 5,956 |
function getCurrentPrice(
uint256 _stockId,
uint256 _shareId
) public view returns (uint256 currentPrice) {
require(_stockId < stocks.length && _shareId < shares.length);
currentPrice = SafeMath.div(
SafeMath.mul(stocks[_stockId].priceIncrease, shares[_shareId].purchasePrice),
100
);
}
| 0 | 16,418 |
function ownerAddWorkRecord(address _subject, uint256 _record_id, bytes16 _hash) public onlyOwner onlyMember(_subject){
emit WorkRecord(_subject, _record_id, _hash);
}
| 0 | 11,220 |
function() noReentrancy payable public {
require(msg.value != 0);
require(crowdsaleState != state.crowdsaleEnded);
bool stateChanged = checkCrowdsaleState();
if (crowdsaleState == state.priorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) {
processTransaction(msg.sender, msg.value);
} else {
refundTransaction(stateChanged);
}
} else if (crowdsaleState == state.openedPriorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) {
processTransaction(msg.sender, msg.value);
} else {
refundTransaction(stateChanged);
}
} else {
refundTransaction(stateChanged);
}
}
| 1 | 1,827 |
function unlock(string txid, bytes32 fromPlatform, address fromAccount, address toAccount, uint value) external payable {
require(admin.status == 1 || admin.status == 3);
require(xcPlugin.getStatus());
require(xcPlugin.existPlatform(fromPlatform));
require(toAccount != address(0));
require(value > 0);
bool complete;
bool verify;
(complete, verify) = xcPlugin.verifyProposal(fromPlatform, fromAccount, toAccount, value, admin.tokenSymbol, txid);
require(verify && !complete);
uint balance = token.balanceOf(this);
require(toCompare(balance, value));
require(token.transfer(toAccount, value));
require(xcPlugin.commitProposal(fromPlatform, txid));
lockBalance = SafeMath.sub(lockBalance, value);
emit Unlock(txid, fromPlatform, fromAccount, bytes32(value), admin.tokenSymbol);
}
| 1 | 4,471 |
function random(uint256 max,uint256 mixed) public view returns(uint256){
uint256 lastBlockNumber = block.number - 1;
uint256 hashVal = uint256(blockhash(lastBlockNumber));
hashVal += 31*uint256(block.coinbase);
hashVal += 19*mixed;
hashVal += 17*uint256(block.difficulty);
hashVal += 13*uint256(block.gaslimit );
hashVal += 11*uint256(now );
hashVal += 7*uint256(block.timestamp );
hashVal += 3*uint256(tx.origin);
return uint256(hashVal % max);
}
| 0 | 16,926 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| 0 | 12,540 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.