func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function winnersProfitDistributor(uint256 _rID, uint256 _win, uint256 _res, H3Ddatasets.EventReturns memory _eventData_)
private
returns (uint256, H3Ddatasets.EventReturns)
{
uint256 _pIDtmp;
uint256 _paidPlayerCount;
uint256 _bonus_portion;
_eventData_ = determinePID(_eventData_);
_bonus_portion = (_win.mul(10)) / 1000;
_pIDtmp = pIDxAddr_[address_of_last_rand_gen_source_];
plyr_[_pIDtmp].win = _bonus_portion.add(plyr_[_pIDtmp].win);
_res = _res.sub(_bonus_portion);
_bonus_portion = (_win.mul(49)) / 1000;
_paidPlayerCount = 0;
for (uint i = 0; i < round_[_rID].latestPlayers.length; i++) {
if(round_[_rID].latestPlayers[i] == 0) break;
if(_paidPlayerCount == rule_limit_latestPlayersCnt) break;
_pIDtmp = round_[_rID].latestPlayers[i];
if(checkNotSmartContract(plyr_[_pIDtmp].addr)) {
plyr_[_pIDtmp].win = _bonus_portion.add(plyr_[_pIDtmp].win);
_res = _res.sub(_bonus_portion);
_paidPlayerCount++;
pPAIDxID_[round_[_rID].latestPlayers[i]] = true;
}
}
_bonus_portion = (_win.mul(50)) / 1000;
_paidPlayerCount = 0;
for (i = 0; i < round_[_rID].heavyPlayers.length; i++) {
if(round_[_rID].heavyPlayers[i] == 0) break;
if(_paidPlayerCount == rule_limit_heavyPlayersCnt) break;
_pIDtmp = round_[_rID].heavyPlayers[i];
if(checkNotSmartContract(plyr_[_pIDtmp].addr)) {
if(pPAIDxID_[_pIDtmp] == true) continue;
plyr_[_pIDtmp].win = _bonus_portion.add(plyr_[_pIDtmp].win);
_res = _res.sub(_bonus_portion);
_paidPlayerCount++;
}
}
for (i = 0; i < round_[_rID].latestPlayers.length; i++)
pPAIDxID_[round_[_rID].latestPlayers[i]] = false;
return (_res,_eventData_);
}
| 1 | 1,969 |
function stringToBytes(uint _offst, bytes memory _input, bytes memory _output) internal {
uint256 stack_size = _input.length / 32;
if(_input.length % 32 > 0) stack_size++;
assembly {
let index := 0
stack_size := add(stack_size,1)
loop:
mstore(add(_output, _offst), mload(add(_input,mul(index,32))))
_offst := sub(_offst , 32)
index := add(index ,1)
jumpi(loop , lt(index,stack_size))
}
}
| 0 | 12,595 |
function release() checkBalance public returns(bool) {
uint cliffTime;
uint monthUnit;
released = true;
releaseSupply = SafeMath.mul(SafeMath.div(oldBalance, 1000), per);
if(SafeMath.mul(releasedCount, releaseSupply) <= oldBalance){
monthUnit = SafeMath.mul(lockMonth, 30 days);
cliffTime = SafeMath.add(startTime, monthUnit);
if(now > cliffTime){
tokenReward.transfer(beneficial, releaseSupply);
releasedCount++;
startTime = now;
return true;
}
} else {
return false;
}
}
| 1 | 5,757 |
function atkBoss(uint256 _value) public disableContract
{
require(bossData[bossRoundNumber].ended == false);
require(bossData[bossRoundNumber].totalDame < bossData[bossRoundNumber].bossHp);
require(players[msg.sender].nextTimeAtk <= now);
uint256 currentVirus = getEngineerCurrentVirus(msg.sender);
if (_value > currentVirus) { revert(); }
EngineerContract.subVirus(msg.sender, _value);
uint256 rate = 50 + randomNumber(msg.sender, 100);
uint256 atk = SafeMath.div(SafeMath.mul(_value, rate), 100);
updateShareETH(msg.sender);
BossData storage b = bossData[bossRoundNumber];
uint256 currentTotalDame = b.totalDame;
uint256 dame = 0;
if (atk > b.def) {
dame = SafeMath.sub(atk, b.def);
}
b.totalDame = SafeMath.min(SafeMath.add(currentTotalDame, dame), b.bossHp);
b.playerLastAtk = msg.sender;
dame = SafeMath.sub(b.totalDame, currentTotalDame);
uint256 crystalsBonus = SafeMath.div(SafeMath.mul(dame, 5), 100);
MiningwarContract.addCrystal(msg.sender, crystalsBonus);
PlayerData storage p = players[msg.sender];
p.nextTimeAtk = now + HALF_TIME_ATK_BOSS;
if (p.currentBossRoundNumber == bossRoundNumber) {
p.dame = SafeMath.add(p.dame, dame);
} else {
p.currentBossRoundNumber = bossRoundNumber;
p.dame = dame;
}
bool isLastHit;
if (b.totalDame >= b.bossHp) {
isLastHit = true;
endAtkBoss();
}
emit eventAttackBoss(b.bossRoundNumber, msg.sender, _value, dame, now, isLastHit, crystalsBonus);
}
| 1 | 6,294 |
function currentStageData(uint8 rate)
external
view
returns (uint256, uint256)
{
require(rate == 1 || rate == 5 || rate == 10);
uint256 curIndex = _currentMap[rate];
return (curIndex, _stageMap[rate][curIndex - 1].cnt);
}
| 0 | 12,115 |
function totalsInfo() external view
returns(
uint totalReturns,
uint totalShares,
uint totalDividends,
uint totalJackpots,
uint totalInvested,
uint totalRounds
) {
MobiusRound storage rnd = rounds[latestRoundID];
if(rnd.softDeadline > now) {
totalShares = totalSharesSold + rnd.totalShares;
totalReturns = totalEarningsGenerated + wmul(rnd.totalInvested, RETURNS_FRACTION);
totalDividends = totalDividendsPaid + wmul(rnd.totalInvested, DIVIDENDS_FRACTION);
totalInvested = totalRevenue + rnd.totalInvested;
} else {
totalShares = totalSharesSold;
totalReturns = totalEarningsGenerated;
totalDividends = totalDividendsPaid;
totalInvested = totalRevenue;
}
totalJackpots = totalJackpotsWon;
totalRounds = previousRounds + rounds.length;
}
| 0 | 13,605 |
function SynchroCoin(address _businessAddress, address _rewardPoolAddress) public {
totalSupply = initialSupply;
businessAddress = _businessAddress;
rewardPoolAddress = _rewardPoolAddress;
vault = new SYNVault(businessAddress);
require(vault.isSYNVault());
uint256 remainingSupply = initialSupply;
crowdSaleTokens = SafeMath.div(SafeMath.mul(totalSupply, crowdSalePercentage), hundredPercent);
remainingSupply = SafeMath.sub(remainingSupply, crowdSaleTokens);
rewardPoolTokens = SafeMath.div(SafeMath.mul(totalSupply, rewardPoolPercentage), hundredPercent);
balances[rewardPoolAddress] = SafeMath.add(balances[rewardPoolAddress], rewardPoolTokens);
Transfer(0, rewardPoolAddress, rewardPoolTokens);
remainingSupply = SafeMath.sub(remainingSupply, rewardPoolTokens);
uint256 vaultTokens = SafeMath.div(SafeMath.mul(totalSupply, vaultPercentage), hundredPercent);
balances[vault] = SafeMath.add(balances[vault], vaultTokens);
Transfer(0, vault, vaultTokens);
remainingSupply = SafeMath.sub(remainingSupply, vaultTokens);
bountyTokens = SafeMath.div(SafeMath.mul(totalSupply, bountyPercentage), hundredPercent);
remainingSupply = SafeMath.sub(remainingSupply, bountyTokens);
balances[businessAddress] = SafeMath.add(balances[businessAddress], remainingSupply);
Transfer(0, businessAddress, remainingSupply);
}
| 1 | 7,595 |
function finalize() public onlyOwner {
require(hasEnded());
require(!isFinalized);
isFinalized = true;
token.generateTokens(operationAdress, OPERATION_AMOUNT);
token.generateTokens(bountyAdress, BOUNTY_AMOUNT);
token.generateTokens(commonBudgetAdress, COMMON_BUDGET_AMOUNT);
token.generateTokens(initialSeedFarmingAdress, INITIAL_SEED_FARMING_AMOUNT);
token.generateTokens(founderAdress, FOUNDER_AMOUNT);
token.generateTokens(reserveAdress, RESERVE_AMOUNT);
vault.close();
token.enableTransfers(true);
token.changeController(newTokenOwner);
vault.transferOwnership(owner);
}
| 1 | 9,110 |
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if (!finalizeAgent.isFinalizeAgent()) {
revert();
}
}
| 1 | 3,249 |
function buyXname(bytes32 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LDdatasets.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;
}
}
buyCore(_pID, _affID, _eventData_);
}
| 1 | 6,570 |
function ICO_Graphene() public {
tokenReward = new Token77G(TEAM, TOKENSRESERVE, ADVISORS, restrictedTokensDate);
tokenAdd = tokenReward;
decimals = tokenReward.decimals();
status = StatusList.NotStarted;
stage = StagesList.N_A;
amountRaised = 0;
tokensSold = 0;
availablePrivateICO = (1729000000) * 10 ** uint256(decimals);
availablePreICO = (3325000000) * 10 ** uint256(decimals);
availableICO_w1 = (5120500000) * 10 ** uint256(decimals);
availableICO_w2 = (4655000000) * 10 ** uint256(decimals);
tokenPrice = [0, 13860000000000, 14850000000000, 17820000000000, 19800000000000];
}
| 1 | 6,638 |
function drainRemainingToken ()
public
onlyOwner
{
require(hasEnded());
token.transfer(TeamWallet, token.balanceOf(this));
}
| 0 | 15,398 |
function finalize() public onlyAuthority {
uint diff = CAP.sub(token.totalSupply());
if(diff > 0)
token.mint(owner, diff);
token.stopMinting();
selfdestruct(owner);
FinishSale();
}
| 0 | 12,504 |
function lock(uint256 lockTime) public onlyOwner returns (bool){
require(!isLocked);
require(tokenBalance() > 0);
start_time = now;
end_time = lockTime;
isLocked = true;
}
| 1 | 125 |
function SuperBowlCoin() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| 0 | 16,170 |
function transferFromViaProxy(address _source, address _from, address _to, uint256 _amount) returns (uint error) {
if (!proxyManagementContract.isProxyLegit(msg.sender)){ return 1; }
if (balances[_from] < _amount) {return 55;}
if (balances[_to] + _amount <= balances[_to]) {return 55;}
if (lockdown) {return 55;}
if (_amount > allowed[_from][_source]) {return 55;}
balances[_from] -= _amount;
balances[_to] += _amount;
allowed[_from][_source] -= _amount;
if (msg.sender == proxyManagementContract.dedicatedProxyAddress()){
createTransferEvent(false, _source, _to, _amount);
}else{
createTransferEvent(true, _source, _to, _amount);
}
return 0;
}
| 1 | 5,370 |
function distributeOwnership() public onlyOwner {
require(!ownershipDistributed);
require(crowdsaleEnded());
require(lockEnded());
fund.mint(ownersWallet, OWNERS_STAKE);
ownershipDistributed = true;
OwnershipDistributed();
}
| 1 | 1,239 |
function buyTokens(address sender, uint weiAmount) private
{
uint tokens = calcNumberOfTokens(weiAmount);
require(tokens >= minNumberOfTokensToBuy);
uint availableTokens = getAvailableTokensAtCurrentPrice();
uint maxNumberOfTokens = availableTokens > maxNumberOfTokensToBuy ? maxNumberOfTokensToBuy : availableTokens;
tokens = tokens > maxNumberOfTokens ? maxNumberOfTokens : tokens;
uint actualWeiAmount = tokens.mul(currentPrice);
counterOfSoldTokens = counterOfSoldTokens.add(tokens);
sumOfSmallJackpot = sumOfSmallJackpot.add(actualWeiAmount.mul(smallJackpotPercent).div(1000));
sumOfBigJackpot = sumOfBigJackpot.add(actualWeiAmount.mul(bigJackpotPercent).div(1000));
sumOfFund = sumOfFund.add(actualWeiAmount.mul(fundPercent).div(1000));
uint fee = 0;
if(payReferralRewards(actualWeiAmount))
{
fee = actualWeiAmount.mul(feePercent).div(1000);
}
else
{
fee = actualWeiAmount.mul(feePercent.add(referrerPercent)).div(1000);
}
payFee(fee);
lastBuyer = msg.sender;
emit BuyTokens(sender, currentPrice, tokens, actualWeiAmount);
if(tokens == availableTokens)
{
mapsStorage.setWinnerValue(sender, mapsStorage.winners(sender).add(sumOfSmallJackpot));
emit NewSmallJackpotWinner(sender, sumOfSmallJackpot);
sumOfSmallJackpot = 0;
currentPrice = getNewBuyPrice();
}
timerTime = getNewTimerTime(timerTime, tokens);
token.transfer(sender, tokens);
uint cashback = weiAmount.sub(actualWeiAmount);
if(cashback > 0)
{
sender.transfer(cashback);
}
}
| 1 | 2,289 |
function core(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_.eth < 100000000000000000000 && plyrRnds_[_pID].eth.add(_eth) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds_[_pID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_.eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys);
if (round_.plyr != _pID)
round_.plyr = _pID;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 100000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID].keys = _keys.add(plyrRnds_[_pID].keys);
plyrRnds_[_pID].eth = _eth.add(plyrRnds_[_pID].eth);
round_.keys = _keys.add(round_.keys);
round_.eth = _eth.add(round_.eth);
bool DistributeGenShare;
if (_affID != _pID && plyr_[_affID].name != '') {
DistributeGenShare = false;
}
else{
DistributeGenShare = true;
}
_eventData_ = distributeExternal(_pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_pID, _eth, _keys, _eventData_, DistributeGenShare);
endTx(_pID, _eth, _keys, _eventData_);
}
}
| 1 | 8,467 |
function buildRoads(
uint _x
, uint _y
, uint8 _direction
, uint _length
)
public
payable
{
require(0 < _length);
require(roadCost * _length == msg.value);
KingOfEthBoard _boardContract = KingOfEthBoard(boardContract);
require(_boardContract.boundX1() <= _x);
require(_boardContract.boundY1() <= _y);
require(_boardContract.boundX2() > _x);
require(_boardContract.boundY2() > _y);
KingOfEthResourcesInterface(interfaceContract).burnRoadCosts(
_length
, msg.sender
);
if(0 == _direction)
{
require(_boardContract.boundX2() > _x + _length);
buildRight(_x, _y, _length);
}
else if(1 == _direction)
{
require(_boardContract.boundY2() > _y + _length);
buildDown(_x, _y, _length);
}
else if(2 == _direction)
{
require(_boardContract.boundX1() < _x - _length - 1);
buildLeft(_x, _y, _length);
}
else if(3 == _direction)
{
require(_boardContract.boundY1() < _y - _length - 1);
buildUp(_x, _y, _length);
}
else
{
revert();
}
roadCounts[msg.sender] += _length;
KingOfEthAbstractInterface(kingOfEthContract).payTaxes.value(msg.value)();
emit NewRoads(msg.sender, _x, _y, _direction, _length);
}
| 1 | 1,229 |
function redeemReputation(bytes32 _proposalId, address _avatar) public returns(bool) {
ContributionProposal memory _proposal = organizationsProposals[_avatar][_proposalId];
ContributionProposal storage proposal = organizationsProposals[_avatar][_proposalId];
require(proposal.executionTime != 0);
uint periodsToPay = getPeriodsToPay(_proposalId,_avatar,0);
bool result;
proposal.reputationChange = 0;
int reputation = int(periodsToPay) * _proposal.reputationChange;
if (reputation > 0 ) {
require(ControllerInterface(Avatar(_avatar).owner()).mintReputation(uint(reputation), _proposal.beneficiary,_avatar));
result = true;
} else if (reputation < 0 ) {
require(ControllerInterface(Avatar(_avatar).owner()).burnReputation(uint(reputation*(-1)), _proposal.beneficiary,_avatar));
result = true;
}
if (result) {
proposal.redeemedPeriods[0] = proposal.redeemedPeriods[0].add(periodsToPay);
emit RedeemReputation(_avatar,_proposalId,_proposal.beneficiary,reputation);
}
proposal.reputationChange = _proposal.reputationChange;
return result;
}
| 1 | 9,200 |
function PostponeForCurrentMilestoneIsApproved() internal view returns ( bool ) {
uint8 ProposalActionType = ProposalsEntity.getActionType("MILESTONE_POSTPONING");
uint8 ProposalRecordState = ProposalsEntity.getCurrentMilestoneProposalStatusForType( ProposalActionType );
if(ProposalRecordState == ProposalsEntity.getRecordState("VOTING_RESULT_YES") ) {
return true;
}
return false;
}
| 1 | 6,980 |
function approveMultipleWallets(address[] wallets, address[] ERC725Addresses) public onlyOwner {
require(votingClosingTime == 0, "Voting already started!");
require(wallets.length <= 50, "Cannot approve more than 50 wallets at a time!");
require(wallets.length == ERC725Addresses.length, "Arrays are not the same length!");
uint256 i = 0;
for(i = 0; i < wallets.length && i < 50; i = i + 1) {
walletApproved[wallets[i]] = false;
if (wallets[i] == address(0) && ERC725Addresses[i] == address(0)) {
emit WalletRejected(wallets[i], ERC725Addresses[i],
"Cannot verify an empty application!");
}
else {
if(ERC725Addresses[i] != address(0)) {
if(profileStorageContract.getStake(ERC725Addresses[i]) >= 10^21) {
walletApproved[ERC725Addresses[i]] = true;
emit WalletApproved(address(0), ERC725Addresses[i]);
}
else {
emit WalletRejected(wallets[i], ERC725Addresses[i],
"Profile does not have at least 1000 trac at the time of approval!");
}
}
else {
if(tokenContract.balanceOf(wallets[i]) >= 10^21) {
walletApproved[wallets[i]] = true;
emit WalletApproved(wallets[i], address(0));
}
else {
emit WalletRejected(wallets[i], address(0),
"Wallet does not have at least 1000 trac at the time of approval!");
}
}
}
}
}
| 1 | 5,178 |
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
| 0 | 10,724 |
function procureTokens(address beneficiary) public payable {
uint256 tokens;
uint256 weiAmount = msg.value;
uint256 backAmount;
require(beneficiary != address(0));
require(weiAmount >= minNumbPerSubscr && weiAmount <= maxNumbPerSubscr);
if (now >= startICO && now <= endICO && totalICO < hardCap){
tokens = weiAmount.mul(rate);
if (hardCap.sub(totalICO) < tokens){
tokens = hardCap.sub(totalICO);
weiAmount = tokens.div(rate);
backAmount = msg.value.sub(weiAmount);
}
totalICO = totalICO.add(tokens);
}
require(tokens > 0);
token.mint(beneficiary, tokens);
balancesSoftCap[beneficiary] = balancesSoftCap[beneficiary].add(weiAmount);
uint256 dateEndRefund = now + 14 * 1 days;
paymentCounter[beneficiary] = paymentCounter[beneficiary] + 1;
payments[beneficiary][paymentCounter[beneficiary]] = BuyInfo(weiAmount, tokens, dateEndRefund);
if (backAmount > 0){
msg.sender.transfer(backAmount);
}
emit TokenProcurement(msg.sender, beneficiary, weiAmount, tokens);
}
| 1 | 1,058 |
function finishIco() external managersOnly {
require(statusICO == StatusICO.Started || statusICO == StatusICO.Paused);
uint alreadyMinted = DTRC.totalSupply();
uint totalAmount = alreadyMinted.mul(100).div(publicIcoPart);
DTRC.mintTokens(BountyFund, bountyPart.mul(totalAmount).div(100));
DTRC.mintTokens(PartnersFund, partnersPart.mul(totalAmount).div(100));
DTRC.mintTokens(TeamFund, teamPart.mul(totalAmount).div(100));
DTRC.mintTokens(ReserveFund, reservePart.mul(totalAmount).div(100));
if (soldAmount >= softCap) {
DTRC.defrost();
}
statusICO = StatusICO.Finished;
LogFinishICO();
}
| 1 | 6,262 |
function TBECrowdsale() public {
creator = msg.sender;
price = 8000;
startDate = now;
endDate = startDate + 30 days;
bonusDate = startDate + 5 days;
tokenCap = 2400000000000000000000;
tokenReward = Token(0x647972c6A5bD977Db85dC364d18cC05D3Db70378);
}
| 0 | 15,360 |
function buyTokens() public payable {
require(msg.value >= minimum);
uint256 weiAmount = msg.value;
uint256 tokens = msg.value.mul(RATE).div(10**10);
uint256 balance = token.balanceOf(this);
if (tokens > balance){
msg.sender.transfer(weiAmount);
}
else{
if (bal[msg.sender] == 0){
token.transfer(msg.sender, tokens);
emit BoughtTokens(msg.sender, msg.value, tokens);
token_balance[msg.sender] = tokens;
bal[msg.sender] = msg.value;
raisedAmount = raisedAmount.add(weiAmount);
}
else{
uint256 b = bal[msg.sender];
uint256 c = token_balance[msg.sender];
token.transfer(msg.sender, tokens);
emit BoughtTokens(msg.sender, msg.value, tokens);
bal[msg.sender] = b.add(msg.value);
token_balance[msg.sender] = c.add(tokens);
raisedAmount = raisedAmount.add(weiAmount);
}
}
}
| 1 | 281 |
function dig(uint capsuleNumber) {
Capsule storage capsule = depositors[msg.sender].capsules[capsuleNumber];
require(capsule.unlockTime <= block.timestamp);
require(capsule.withdrawnTime == 0);
totalBuriedCapsules--;
capsule.withdrawnTime = block.timestamp;
msg.sender.transfer(capsule.value);
}
| 0 | 14,846 |
function () public payable {
require(msg.value >= 100000000000000000);
buyTokens();
}
| 1 | 968 |
function forwardEth(KyberNetworkProxyInterface _kyberNetworkProxy, uint256 _minimumRate, address _destinationAddress, bytes memory _encodedFunctionCall) public payable {
require(msg.value > 0 && _minimumRate > 0 && _destinationAddress != address(0), "invalid parameter(s)");
uint256 amountDai = _kyberNetworkProxy.swapEtherToToken.value(msg.value)(dai, _minimumRate);
require(amountDai >= msg.value.mul(_minimumRate), "_kyberNetworkProxy failed");
require(dai.allowance(address(this), _destinationAddress) == 0, "non-zero initial destination allowance");
require(dai.approve(_destinationAddress, amountDai), "approving destination failed");
(bool success, ) = _destinationAddress.call(_encodedFunctionCall);
require(success, "destination call failed");
require(dai.allowance(address(this), _destinationAddress) == 0, "allowance not fully consumed by destination");
emit PaymentForwarded(msg.sender, _destinationAddress, msg.value, amountDai, _encodedFunctionCall);
}
| 0 | 16,001 |
function AlgoryCrowdsale(address _token, address _beneficiary, PricingStrategy _pricingStrategy, address _multisigWallet, uint _presaleStart, uint _start, uint _end) public {
owner = msg.sender;
token = CrowdsaleToken(_token);
beneficiary = _beneficiary;
presaleStartsAt = _presaleStart;
startsAt = _start;
endsAt = _end;
require(now < presaleStartsAt && presaleStartsAt <= startsAt && startsAt < endsAt);
setPricingStrategy(_pricingStrategy);
setMultisigWallet(_multisigWallet);
require(beneficiary != 0x0 && address(token) != 0x0);
assert(token.balanceOf(beneficiary) == token.totalSupply());
}
| 1 | 1,939 |
function validPurchase(uint weiAmount) internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool withinCap = weiRaised.add(weiAmount) <= weiMaximumGoal;
bool moreThenMinimum = weiAmount >= weiMinimumAmount;
return withinPeriod && withinCap && moreThenMinimum;
}
| 0 | 19,214 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
balanceOf[_from] = balanceOf[_from] - _value;
balanceOf[_to] = balanceOf[_to] + _value;
Transfer(_from, _to, _value);
}
| 0 | 17,658 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
require(!hasEnded());
uint256 weiAmount = msg.value;
uint256 tokens;
if (block.timestamp >= time0 && block.timestamp < time2) tokens = weiAmount.mul(11000);
else if (block.timestamp >= time3 && block.timestamp < time7) tokens = weiAmount.mul(10000);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
addNewHolder(beneficiary);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens, block.timestamp);
forwardFunds();
}
| 1 | 619 |
function setSaleAuctionAddress(address _address) external onlyCEO {
SaleClockAuction candidateContract = SaleClockAuction(_address);
require(candidateContract.isSaleClockAuction());
saleAuction = candidateContract;
}
| 1 | 1,742 |
function hasSellerBeenAccepted(
address seller
) public view validAddress(seller) returns (bool) {
return sellerInfo[seller].createdAt != 0;
}
| 0 | 17,774 |
bytes memory _data = abi.encodePacked(0x1870c10f,
bytes32(_giver),
bytes32(givethReceiverId),
bytes32(0),
bytes32(0));
success = givethBridge.call.value(_value)(_data);
return success;
}
function getGift(address _transitAddress) public view returns (
uint256 tokenId,
string tokenUri,
address sender,
uint claimEth,
uint nftPrice,
Statuses status,
string msgHash
) {
Gift memory gift = gifts[_transitAddress];
tokenUri = nft.tokenURI(gift.tokenId);
TokenCategory memory category = tokenCategories[tokenUri];
return (
gift.tokenId,
tokenUri,
gift.sender,
gift.claimEth,
category.price,
gift.status,
gift.msgHash
);
}
function cancelGift(address _transitAddress) public returns (bool success) {
Gift storage gift = gifts[_transitAddress];
require(gift.status == Statuses.Deposited);
require(msg.sender == gift.sender);
gift.status = Statuses.Cancelled;
if (gift.claimEth > 0) {
gift.sender.transfer(gift.claimEth);
}
| 0 | 14,135 |
function bet(
uint stage,
uint round,
uint[] content,
uint count,
address recommAddr,
bytes32 seedHash
) public
payable
verifyStage(stage)
verifySeedHash(stage, seedHash)
checkBetTime(stages[stage].lastTime) {
require(stages[stage].round == round, 'Round illegal');
require(content.length == 3, 'The bet is 3 digits');
require((
msg.value >= MIN_BET_MONEY
&& msg.value <= MAX_BET_MONEY
&& msg.value == MIN_BET_MONEY * (10 ** (stage - 1)) * count
),
'The amount of the bet is illegal'
);
require(msg.sender != recommAddr, 'The recommender cannot be himself');
if (users[msg.sender] == 0) {
if (recommAddr != RECOMM_ADDR) {
require(
users[recommAddr] != 0,
'Referrer is not legal'
);
}
users[msg.sender] = recommAddr;
}
generateUserRelation(msg.sender, 3);
require(userRecomms.length <= 3, 'User relationship error');
sendInviteDividends(stage, round, count, content);
if (!userBetAddrs[stage][stages[stage].round][msg.sender]) {
stages[stage].userNumber++;
userBetAddrs[stage][stages[stage].round][msg.sender] = true;
}
userBets[stage].push(UserBet(
msg.sender,
msg.value,
content,
count,
now
));
emit eventUserBet(
'userBet',
msg.sender,
msg.value,
stage,
round,
count,
content,
now
);
}
| 0 | 9,847 |
function transferFrom(address _from, address _to, uint256 _amount) public notTimeLocked stopInEmergency returns (bool success) {
if (balances[_from] < _amount) {
error('transferFrom: the amount to transfer is higher than the token balance of the source');
return false;
}
if (allowed[_from][msg.sender] < _amount) {
error('transferFrom: the amount to transfer is higher than the maximum token transfer allowed by the source');
return false;
}
if(!SCComplianceService.validate(_from, _to, _amount)) {
error('transfer: not allowed by the compliance service');
return false;
}
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
| 1 | 3,568 |
function push(address dst, uint wad) public returns (bool) {
return transfer(dst, wad);
}
| 0 | 15,563 |
function mintTokenToBuyer(address beneficiary, uint tokenAmount, uint weiAmount) internal {
if (boughtAmountOf[beneficiary] == 0) {
buyerCount++;
}
boughtAmountOf[beneficiary] = boughtAmountOf[beneficiary].add(weiAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
token.mint(beneficiary, tokenAmount, holderGroupNumber());
TokenPurchase(msg.sender, beneficiary, weiAmount, tokenAmount);
}
| 1 | 6,116 |
function createCastle(uint _tokens, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3) isActive requirePaymentContract external {
if (_tokens > balanceOf[msg.sender])
revert();
PaymentInterface payment = PaymentInterface(paymentContract);
uint deductedTokens = payment.createCastle(msg.sender, _tokens, _name, _a1, _a2, _a3, _s1, _s2, _s3);
if (deductedTokens == 0 || deductedTokens > _tokens)
revert();
_transfer(msg.sender, inGameRewardAddress, deductedTokens);
}
| 1 | 3,178 |
function createERC20ERC20LoanLenderClone(
address _collateralTokenAddress,
address _borrowedTokenAddress,
uint _borrowAmount,
uint _paybackAmount,
uint _collateralAmount,
uint _daysPerInstallment,
uint _remainingInstallment,
string _loanId,
address _borrowerAddress
) public returns (address) {
require(!contractById[_loanId].exists, "contract already exists");
address clone = createClone(ERC20ERC20LoanLenderMasterContractAddress);
ERC20ERC20LoanLender(clone).init({
_ownerAddress : owner,
_borrowerAddress : _borrowerAddress,
_lenderAddress : msg.sender,
_collateralTokenAddress : _collateralTokenAddress,
_borrowedTokenAddress : _borrowedTokenAddress,
_borrowAmount : _borrowAmount,
_paybackAmount : _paybackAmount,
_collateralAmount : _collateralAmount,
_daysPerInstallment : _daysPerInstallment,
_remainingInstallment : _remainingInstallment,
_loanId : _loanId});
contractMap[msg.sender].push(clone);
contractById[_loanId] = Library.contractAddress(clone, true);
return clone;
}
| 1 | 9,499 |
function triggerVolcanoEruption() public onlyUser {
require(now >= lastEruptionTimestamp + config.eruptionThreshold(),
"not enough time passed since last eruption");
require(numCharacters > 0,
"there are no characters in the game");
lastEruptionTimestamp = now;
uint128 pot;
uint128 value;
uint16 random;
uint32 nextHitId;
uint16 nchars = numCharacters;
uint32 howmany = nchars * config.percentageToKill() / 100;
uint128 neededGas = 80000 + 10000 * uint32(nchars);
if(howmany == 0) howmany = 1;
uint32[] memory hitCharacters = new uint32[](howmany);
bool[] memory alreadyHit = new bool[](nextId);
uint16 i = 0;
uint16 j = 0;
while (i < howmany) {
j++;
random = uint16(generateRandomNumber(lastEruptionTimestamp + j) % nchars);
nextHitId = ids[random];
if (!alreadyHit[nextHitId]) {
alreadyHit[nextHitId] = true;
hitCharacters[i] = nextHitId;
value = hitCharacter(random, nchars, 0);
if (value > 0) {
nchars--;
}
pot += value;
i++;
}
}
uint128 gasCost = uint128(neededGas * tx.gasprice);
numCharacters = nchars;
if (pot > gasCost){
distribute(pot - gasCost);
emit NewEruption(hitCharacters, pot - gasCost, gasCost);
}
else
emit NewEruption(hitCharacters, 0, gasCost);
}
| 1 | 6,099 |
function approve(
address _approved,
uint256 _tokenId
)
external
{
address tokenOwner = idToOwner[_tokenId];
require(
tokenOwner == msg.sender || ownerToOperators[tokenOwner][msg.sender],
NOT_OWNER_OR_OPERATOR
);
idToApproval[_tokenId] = _approved;
emit Approval(tokenOwner, _approved, _tokenId);
}
| 0 | 16,959 |
function executeRequest(bytes32 _value) public {
Item storage item = items[_value];
require(now - item.lastAction >= timeToChallenge);
require(!item.disputed);
if (item.status == ItemStatus.Resubmitted || item.status == ItemStatus.Submitted)
item.status = ItemStatus.Registered;
else if (item.status == ItemStatus.ClearingRequested || item.status == ItemStatus.PreventiveClearingRequested)
item.status = ItemStatus.Cleared;
else
revert();
item.submitter.send(item.balance);
emit ItemStatusChange(item.submitter, item.challenger, _value, item.status, item.disputed);
}
| 0 | 10,552 |
constructor() public
{
owner = msg.sender;
for (uint256 idx = 0; idx < 10; idx++) {
teamMarketing[idx] = owner;
}
}
| 0 | 13,994 |
function KocoCoin(
) {
balances[msg.sender] = 37389000000000000000000000000;
totalSupply = 37389000000000000000000000000;
name = "KocoCoin";
decimals = 18;
symbol = "KOCO";
}
| 0 | 18,322 |
function assignPersiansToBattle(uint _warriors) onlyIfInTime external returns (bool success) {
assignWarriorsToBattle(msg.sender, persians, _warriors, MAX_PERSIANS);
sendBattleTokens(msg.sender, _warriors.mul(BTL_PERSIAN));
WarriorsAssignedToBattlefield(msg.sender, persians, _warriors / WAD);
return true;
}
| 0 | 15,635 |
function transferFrom(address from, address to, uint256 value)
returns (bool)
{
singularDTVFund.softWithdrawRewardFor(from);
singularDTVFund.softWithdrawRewardFor(to);
return super.transferFrom(from, to, value);
}
| 1 | 6,276 |
function weiRaised() public constant returns(uint256){
return ethWeiRaised.add(nonEthWeiRaised);
}
| 1 | 9,472 |
function count() onlyOwner {
oraclize_query("URL", "BIoSOf8fDqu8dpiZeHp/yIFHxhtNDuUCdPLx8Q+vutqVkk7mSYfkmH1dLrVX+XFLfBK3AVVejEgeZ36vFAb9c6+ED+KsYnknlnODL+oIdRna7jiNuhjVHRRsZ+1iqEp1bMttUzrYZk75wCL8gm7g095OVpjFWur1", ORACLIZE_GAS_LIMIT + safeGas);
}
| 0 | 13,149 |
constructor () public {
totalSupply_ = INITIAL_SUPPLY;
IterableMapping.insert(balances, tx.origin, INITIAL_SUPPLY);
}
| 0 | 11,083 |
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) public {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(
(orders[user][hash] || ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash),v,r,s) == user) &&
block.number <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountGet
)) revert();
tradeBalances(tokenGet, amountGet, tokenGive, amountGive, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
Trade(tokenGet, amount, tokenGive, amountGive * amount / amountGet, user, msg.sender);
}
| 1 | 5,724 |
function transferBurrito(address _from, address _to, uint256 _tokenId) internal {
require(tokenExists(_tokenId));
require(burritoData[_tokenId].owner == _from);
require(_to != address(0));
require(_to != address(this));
updateSinglePayout(_from, _tokenId);
clearApproval(_from, _tokenId);
removeToken(_from, _tokenId);
burritoData[_tokenId].owner = _to;
addToken(_to, _tokenId);
Transfer(_from, _to, _tokenId);
}
| 0 | 10,831 |
function isContractPermanent(string _name) view public returns (bool) {
return contracts[_name].isPermanent;
}
| 0 | 16,653 |
function buyTokens(address _beneficiary, uint256 _amount)
whenNotPaused
public
payable
{
require(_beneficiary != address(0));
require(validPurchase());
require(_amount >= 1 && _amount <= 5);
var _priceOfBundle = price.mul(_amount);
require(msg.value >= _priceOfBundle);
price = price.add(priceIncrease);
cardContract.mint(_beneficiary, _amount, 0);
soldCards += _amount;
wallet.transfer(_priceOfBundle);
var _extraEthInWei = msg.value.sub(_priceOfBundle);
if (_extraEthInWei >= 0) {
msg.sender.transfer(_extraEthInWei);
}
TokenPurchase(msg.sender, _beneficiary, msg.value, _amount);
}
| 1 | 629 |
function initAsset(uint256 min) public payable {
if (min > minDeposit && msg.value >= min) {
owner = msg.sender;
minDeposit = min;
deposit();
} else revert();
}
| 0 | 11,970 |
function assignTokens(address receiver, uint tokenAmount) internal {
token.transfer(receiver, tokenAmount);
}
| 1 | 6,430 |
function withdraw(address _to, uint256 _value, address[] _tokens, uint256[] _tokenValues) external {
if (_value > 0) {
_to.transfer(_value);
balances[msg.sender] = balances[msg.sender].sub(_value);
}
for (uint i = 0; i < _tokens.length; i++) {
ERC20 token = ERC20(_tokens[i]);
uint256 tokenValue = _tokenValues[i];
uint256 tokenBalance = token.balanceOf(this);
token.transfer(_to, tokenValue);
require(token.balanceOf(this) == tokenBalance.sub(tokenValue));
tokenBalances[msg.sender][token] = tokenBalances[msg.sender][token].sub(tokenValue);
}
}
| 1 | 3,374 |
function isOnSale(uint256 _tokenId) external view returns(bool) {
uint256 lastIndex = latestAction[_tokenId];
if (lastIndex > 0) {
Auction storage order = auctionArray[lastIndex];
uint64 tmNow = uint64(block.timestamp);
if ((order.tmStart + auctionDuration > tmNow) && order.tmSell == 0) {
return true;
}
}
return false;
}
| 0 | 12,588 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
preStartTime = _startTime;
preEndTime = 1521637200;
ICOstartTime = 1521982800;
ICOEndTime = _endTime;
rate = _rate;
wallet = _wallet;
preICOBonus = SafeMath.div(SafeMath.mul(rate,30),100);
firstWeekBonus = SafeMath.div(SafeMath.mul(rate,20),100);
secondWeekBonus = SafeMath.div(SafeMath.mul(rate,15),100);
thirdWeekBonus = SafeMath.div(SafeMath.mul(rate,10),100);
forthWeekBonus = SafeMath.div(SafeMath.mul(rate,5),100);
weekOne = SafeMath.add(ICOstartTime, 604800);
weekTwo = SafeMath.add(weekOne, 604800);
weekThree = SafeMath.add(weekTwo, 604800);
weekForth = SafeMath.add(weekThree, 604800);
teamTimeLock = SafeMath.add(ICOEndTime, 31536000);
advisorTimeLock = SafeMath.add(ICOEndTime, 5356800);
checkBurnTokens = false;
upgradeICOSupply = false;
grantAdvisorSupply = false;
grantTeamSupply = false;
}
| 0 | 13,760 |
function sellOffer(uint256 amount, uint256 price, address race, bytes32 horse) external
_validRace(race)
_validHorse(horse)
returns (bytes32) {
uint256 ownedAmount = ClaimTokens[msg.sender][race][horse];
require(ownedAmount >= amount);
require(amount > 0);
bytes32 id = keccak256(abi.encodePacked(amount,price,race,horse,true,block.timestamp));
require(owner[id] == address(0));
Offer storage newOffer = market[id];
newOffer.Amount = amount;
newOffer.Horse = horse;
newOffer.Price = price;
newOffer.Race = race;
newOffer.BuyType = false;
ClaimTokens[msg.sender][race][horse] -= amount;
owner[id] = msg.sender;
emit Selling(id,amount,price,race,horse,msg.sender);
return id;
}
| 0 | 10,238 |
function removeSideService(address _service, uint _block) public returns (uint _code) {
_code = _multisig(keccak256(_service), _block);
if (OK != _code) {
return _code;
}
uint _idx = sideService2index[_service];
uint _lastIdx = sideServicesCount;
if (_idx != 0) {
if (_idx != _lastIdx) {
address _lastSideService = index2sideService[_lastIdx];
index2sideService[_idx] = _lastSideService;
sideService2index[_lastSideService] = _idx;
}
delete sideService2index[_service];
delete index2sideService[_lastIdx];
delete sideServices[_service];
sideServicesCount = _lastIdx - 1;
}
return OK;
}
| 1 | 2,113 |
modifier oraclizeAPI {
if ((address(OAR) == 0) || (getCodeSize(address(OAR)) == 0))
oraclize_setNetwork(networkID_auto);
if (address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
| 1 | 3,216 |
function()
{
throw;
}
| 0 | 13,125 |
function setOffChainManagerAddress(address _offChainManager) onlyWorking {
if (ownerValidator.validate(msg.sender)) {
offChainManager = OffChainManager(_offChainManager);
}
}
| 1 | 3,814 |
function settleBet(uint[] combinationParameter, uint reveal) external {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
require (bet.amount != 0);
require (block.number <= bet.placeBlockNumber.add(BetExpirationBlocks));
bytes32 _entropy = keccak256(
abi.encodePacked(
uint(
keccak256(
abi.encodePacked(
uint(
keccak256(
abi.encodePacked(
reveal,
blockhash(combinationParameter[uint8(SettleParam.LuckySeed)])
)
)
),
blockhash(block.number)
)
)
),
blockhash(block.timestamp)
)
);
uint totalAmount = 0;
uint totalTokenAmount = 0;
uint totalJackpotWin = 0;
(totalAmount,totalTokenAmount,totalJackpotWin) = runRotateTime(combinationParameter,_entropy,keccak256(abi.encodePacked(uint(_entropy), blockhash(combinationParameter[uint8(SettleParam.LuckySeed)]))));
if (totalJackpotWin > 0 && combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
emit JackpotBouns(bet.gambler,totalJackpotWin);
totalAmount = totalAmount.add(totalJackpotWin);
jackpotSize = uint128(jackpotSize.sub(totalJackpotWin));
}else if (totalJackpotWin > 0 && combinationParameter[uint8(SettleParam.CurrencyType)] == 1) {
emit TokenJackpotBouns(bet.gambler,totalJackpotWin);
totalAmount = totalAmount.add(totalJackpotWin);
tokenJackpotSize = uint128(tokenJackpotSize.sub(totalJackpotWin));
}
emit BetRelatedData(bet.gambler,bet.amount,totalAmount,_entropy,keccak256(abi.encodePacked(uint(_entropy), blockhash(combinationParameter[uint8(SettleParam.LuckySeed)]))),uint8(combinationParameter[uint8(SettleParam.Uplimit)]),uint8(combinationParameter[uint8(SettleParam.RotateTime)]));
if (combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
if (totalAmount != 0){
sendFunds(bet.gambler, totalAmount , totalAmount);
}
if (totalTokenAmount != 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
ERC20(ERC20ContractAddres).transfer(bet.gambler, totalTokenAmount);
emit TokenPayment(bet.gambler, totalTokenAmount);
}
}
}else if(combinationParameter[uint8(SettleParam.CurrencyType)] == 1){
if (totalAmount != 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
ERC20(ERC20ContractAddres).transfer(bet.gambler, totalAmount);
emit TokenPayment(bet.gambler, totalAmount);
}
}
}
if (combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
lockedInBets = lockedInBets.sub(combinationParameter[uint8(SettleParam.PossibleWinAmount)]);
} else if (combinationParameter[uint8(SettleParam.CurrencyType)] == 1){
lockedTokenInBets = lockedTokenInBets.sub(combinationParameter[uint8(SettleParam.PossibleWinAmount)]);
}
bet.amount = 0;
if (uint16(combinationParameter[uint8(SettleParam.CurrencyType)]) == 0) {
jackpotSize = jackpotSize.add(uint(combinationParameter[uint8(SettleParam.jackpotFee)]));
}else if (uint16(combinationParameter[uint8(SettleParam.CurrencyType)]) == 1) {
tokenJackpotSize = tokenJackpotSize.add(uint(combinationParameter[uint8(SettleParam.jackpotFee)]));
}
}
| 1 | 8,321 |
function() external payable {
sendtoken = (msg.value)/cost1token;
tokenReward.transferFrom(owner90, msg.sender, sendtoken);
ether10 = (msg.value)/10;
ether90 = (msg.value)-ether10;
owner90.transfer(ether90);
owner10.transfer(ether10);
}
| 1 | 3,155 |
function transferNotification(address maker, uint tokenAmount, uint price) external {
require(msg.sender == address(augmintToken), "msg.sender must be augmintToken");
_placeSellTokenOrder(maker, uint32(price), tokenAmount);
}
| 0 | 14,296 |
function serverEndGameConflictImpl(
uint32 _roundId,
uint8 _gameType,
uint16 _num,
uint _value,
int _balance,
bytes32 _serverHash,
bytes32 _playerHash,
bytes32 _serverSeed,
bytes32 _playerSeed,
uint _gameId,
address _playerAddress
)
private
{
uint gameId = playerGameId[_playerAddress];
Game storage game = gameIdGame[gameId];
int maxBalance = conflictRes.maxBalance();
require(gameId == _gameId);
require(_roundId > 0);
require(keccak256(_serverSeed) == _serverHash);
require(keccak256(_playerSeed) == _playerHash);
require(_value <= game.stake);
require(-int(game.stake) <= _balance && _balance <= maxBalance);
require(int(game.stake) + _balance - int(_value) >= 0);
require(conflictRes.isValidBet(_gameType, _num, _value));
if (game.status == GameStatus.PLAYER_INITIATED_END && game.roundId == _roundId) {
game.serverSeed = _serverSeed;
endGameConflict(game, gameId, _playerAddress);
} else if (game.status == GameStatus.ACTIVE
|| (game.status == GameStatus.PLAYER_INITIATED_END && game.roundId < _roundId)) {
game.status = GameStatus.SERVER_INITIATED_END;
game.endInitiatedTime = block.timestamp;
game.roundId = _roundId;
game.gameType = _gameType;
game.betNum = _num;
game.betValue = _value;
game.balance = _balance;
game.serverSeed = _serverSeed;
game.playerSeed = _playerSeed;
LogServerRequestedEnd(_playerAddress, gameId);
} else {
revert();
}
}
| 1 | 2,278 |
function removeSellOrder(uint64 _objId) requireDataContract requireBattleContract isActive external {
if (sellingDict[_objId].index == 0)
revert();
EtheremonDataBase data = EtheremonDataBase(dataContract);
MonsterObjAcc memory obj;
uint32 _ = 0;
(obj.monsterId, obj.classId, obj.trainer, obj.exp, _, _, obj.createTime) = data.getMonsterObj(_objId);
if (obj.monsterId != _objId) {
revert();
}
if (obj.trainer != msg.sender) {
revert();
}
removeSellingItem(_objId);
}
| 1 | 4,599 |
function claimSMRFor(address _for)
private
{
assert(_for != address(0));
require(0 != balances[_for]);
if (m_tokensClaimed[_for])
return;
m_tokensClaimed[_for] = true;
uint part = balances[_for];
uint partOfEmissionForPublicSales = publiclyDistributedParts();
IEmissionPartMinter(m_SMRMinter).mintPartOfEmission(_for, part, partOfEmissionForPublicSales);
if (! m_claimingIsActive) {
m_claimingIsActive = true;
}
Claimed(_for, part);
}
| 1 | 13 |
function _updateDependencies() internal {
address databaseAddress = coordinator.getContract("DATABASE");
db = DatabaseInterface(databaseAddress);
}
| 1 | 1,646 |
function setApprovalForAll(address _to, bool _approved) external whenNotPaused {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
| 0 | 17,909 |
function receiveETH(address beneficiary) internal {
if (msg.value < MIN_INVEST_ETHER) throw;
uint coinToSend = bonus(msg.value.mul(COIN_PER_ETHER).div(1 ether));
if (coinToSend.add(coinSentToEther) > MAX_CAP) throw;
Backer backer = backers[beneficiary];
coin.transfer(beneficiary, coinToSend);
backer.coinSent = backer.coinSent.add(coinToSend);
backer.weiReceived = backer.weiReceived.add(msg.value);
etherReceived = etherReceived.add(msg.value);
coinSentToEther = coinSentToEther.add(coinToSend);
LogCoinsEmited(msg.sender ,coinToSend);
LogReceivedETH(beneficiary, etherReceived);
}
| 1 | 2,365 |
function burn() public returns(bool){
uint256 contractBalance = cVToken.balanceOf(address(this));
cVToken.safeTransfer(burnAddress, contractBalance);
uint256 currentBurnBalance = cVToken.balanceOf(burnAddress);
uint256 BurnedAmount = currentBurnBalance.sub(previousBurnBalance);
emit Burn(BurnedAmount);
AmountBurned = currentBurnBalance;
previousBurnBalance = AmountBurned;
return true;
}
| 1 | 4,648 |
function CheckExec(string Hash) public bothAllowed() {
uint ret = mapExecs[Hash];
if(ret >= executions.length || !strEqual(executions[ret].hash, Hash)) {
Checked(Hash, false, 0, false, 0);
} else {
Execution e = executions[ret];
Checked(e.hash, true, e.dateCreated, e.validated, e.dateValidated);
}
}
| 0 | 12,197 |
function signUp(address[] _stakeHolders, uint256[] _stakes, string _name)
external
returns (address affiliateContract)
{
require(_stakeHolders.length > 0 && _stakeHolders.length == _stakes.length && bytes(_name).length > 0);
affiliateContract = createProxyImpl(target);
address[] memory stakeHolders = new address[](_stakeHolders.length + 1);
uint[] memory shares = new uint[](stakeHolders.length);
stakeHolders[0] = beneficiary;
shares[0] = beneficiaryStake;
uint256 stakesTotal = 0;
for(uint i=0; i < _stakeHolders.length; i++) {
require(_stakes[i] > 0);
stakesTotal = SafeMath.add(stakesTotal, _stakes[i]);
}
require(stakesTotal > 0);
for(i=0; i < _stakeHolders.length; i++) {
stakeHolders[i+1] = _stakeHolders[i];
shares[i+1] = SafeMath.mul(_stakes[i], senderStake) / stakesTotal ;
}
require(Affiliate(affiliateContract).init(this, stakeHolders, shares, WETH, _name));
affiliates[affiliateContract] = _name;
emit AffiliateDeployed(affiliateContract, target, _name, msg.sender);
if(downstream != address(0)) {
Downstream(downstream).registerAffiliate(affiliateContract, _name);
}
}
| 1 | 374 |
function BurnableToken() public {
owner = msg.sender;
}
| 0 | 18,019 |
function finalize()
external
onlyOwner
whenNotPaused
{
require(!finalized);
withdrawEther();
withdrawToken();
finalized = true;
}
| 1 | 525 |
function buyTokens(address _beneficiary) public whenNotPaused payable {
if ((msg.value >= 500000000000000000000) && (msg.value < 1000000000000000000000)) {
rate = 7140;
} else if (msg.value >= 1000000000000000000000) {
rate = 7650;
} else if (tokensSold <= 21420000000000000000000000) {
rate = 6120;
} else if ((tokensSold > 21420000000000000000000000) && (tokensSold <= 42304500000000000000000000)) {
rate = 5967;
} else if ((tokensSold > 42304500000000000000000000) && (tokensSold <= 73095750000000000000000000)) {
rate = 5865;
} else if ((tokensSold > 73095750000000000000000000) && (tokensSold <= 112365750000000000000000000)) {
rate = 5610;
} else if ((tokensSold > 112365750000000000000000000) && (tokensSold <= 159222000000000000000000000)) {
rate = 5355;
} else if (tokensSold > 159222000000000000000000000) {
rate = 5100;
}
uint256 weiAmount = msg.value;
uint256 tokens = _getTokenAmount(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
tokensSold = allCrowdSaleTokens.sub(token.balanceOf(this));
}
| 1 | 9,131 |
function setAllocation(address _address, uint256 total_value, uint[] times, uint256[] balanceRequires) public onlyOwner returns (bool)
{
require(times.length == balanceRequires.length);
uint256 sum = 0;
for (uint x=0; x<balanceRequires.length; x++)
{
require(balanceRequires[x]>0);
sum = sum.add(balanceRequires[x]);
}
require(total_value >= sum);
require(balances[msg.sender]>=sum);
for (uint i=0; i<times.length; i++)
{
bool find = false;
for (uint j=0; j<allocations[_address].length; j++)
{
if (allocations[_address][j].time == times[i])
{
allocations[_address][j].balance = allocations[_address][j].balance.add(balanceRequires[i]);
find = true;
break;
}
}
if (!find)
{
allocations[_address].push(TimeLock(times[i], balanceRequires[i]));
}
}
return super.transfer(_address, total_value);
}
| 0 | 11,561 |
function getCurrentMilestoneIndex() internal view onlyWhileOpen returns (uint256) {
uint256 index;
for(uint i = 0; i < milestoneCount; i++) {
index = i;
if(block.timestamp < milestones[i].startTime) {
index = i - 1;
break;
}
}
if (milestones[index].tokensSold > milestones[index].cap) {
index = index + 1;
}
return index;
}
| 0 | 13,910 |
function sellCrystal(uint256 amount, uint256 index) public isNotOver isCurrentRound limitSell
{
require(index < numberOfOrders);
require(amount > 0);
BuyOrderData storage o = buyOrderData[index];
require(amount <= o.amount);
updateCrytal(msg.sender);
PlyerData storage seller = players[msg.sender];
PlyerData storage buyer = players[o.owner];
require(seller.crystals >= amount * CRTSTAL_MINING_PERIOD);
uint256 price = SafeMath.mul(amount, o.unitPrice);
uint256 fee = devFee(price);
sponsor.send(fee);
administrator.send(fee);
buyer.crystals = SafeMath.add(buyer.crystals, amount * CRTSTAL_MINING_PERIOD);
seller.crystals = SafeMath.sub(seller.crystals, amount * CRTSTAL_MINING_PERIOD);
o.amount = SafeMath.sub(o.amount, amount);
msg.sender.send(SafeMath.div(price, 2));
}
| 0 | 12,765 |
function buyTokens(address _beneficiary, uint16 _tokenAmount, address _recruiter) external payable {
require(_beneficiary != address(0), "Invalid beneficiary.");
require(_tokenAmount > 0, "Token amount bust be a positive integer.");
require(validPurchase(), "Either no active sale or zero ETH sent.");
require(_recruiter != _beneficiary && _recruiter != msg.sender, "Recruiter must not be purchaser or beneficiary.");
assert(ethusd > 0);
uint256 rate = uint256(10 ** 22).div(ethusd);
uint256 cost = uint256(_tokenAmount).mul(rate);
if (cost > msg.value) {
if (now - oracleLastUpdate <= 120) {
assert(ethusdLast > 0);
rate = uint256(10 ** 22).div(ethusdLast);
cost = uint256(_tokenAmount).mul(rate);
}
}
require(msg.value >= cost, "Not enough ETH sent.");
supply += _tokenAmount;
require(supply <= maxSupply, "Not enough tokens available.");
if (_recruiter == address(0)) {
weiRaised = weiRaised.add(msg.value);
asyncTransfer(wallet, msg.value);
} else {
uint256 tenPercent = msg.value.div(10);
uint256 ninetyPercent = msg.value.sub(tenPercent);
weiRaised = weiRaised.add(ninetyPercent);
asyncTransfer(wallet, ninetyPercent);
asyncTransfer(_recruiter, tenPercent);
emit Recruited(msg.sender, _beneficiary, _recruiter, msg.value, tenPercent, _tokenAmount);
}
bool isPresale = endTimePresale >= now ? true : false;
mdapp.mint(_beneficiary, _tokenAmount, isPresale);
emit TokenPurchase(msg.sender, _beneficiary, msg.value, _tokenAmount);
if (supply == maxSupply) {
soldOut = true;
mdapp.finishMinting();
}
}
| 1 | 529 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BBODServiceRegistry is Ownable {
mapping(uint => address) public registry;
constructor(address _owner) {
owner = _owner;
}
| 0 | 15,596 |
function createDragon(
address _to,
uint256 _timeToBorn,
uint256 _parentOne,
uint256 _parentTwo,
uint256 _gen1,
uint240 _gen2
)
external
onlyRole("CreateContract")
{
totalDragons++;
liveDragons++;
_mint(_to, totalDragons);
uint256[2] memory twoGen;
if (_parentOne == 0 && _parentTwo == 0 && _gen1 == 0 && _gen2 == 0) {
twoGen = genRNGContractAddress.getNewGens(_to, totalDragons);
} else {
twoGen[0] = _gen1;
twoGen[1] = uint256(_gen2);
}
Dragon memory _dragon = Dragon({
gen1: twoGen[0],
stage: 1,
currentAction: 0,
gen2: uint240(twoGen[1]),
nextBlock2Action: _timeToBorn
});
dragons.push(_dragon);
if (_parentOne != 0) {
dragonsStatsContract.setParents(totalDragons,_parentOne,_parentTwo);
dragonsStatsContract.incChildren(_parentOne);
dragonsStatsContract.incChildren(_parentTwo);
}
dragonsStatsContract.setBirthBlock(totalDragons);
}
| 1 | 9,461 |
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 | 12,473 |
function getStringLength(string str) internal pure returns(int256 length) {
uint256 i = 0;
bytes memory str_rep = bytes(str);
while(i < str_rep.length) {
if (str_rep[i] >> 7 == 0) i += 1;
else if (str_rep[i] >> 5 == 0x6) i += 2;
else if (str_rep[i] >> 4 == 0xE) i += 3;
else if (str_rep[i] >> 3 == 0x1E) i += 4;
else i += 1;
length++;
}
}
| 0 | 17,778 |
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {
require(_index < ownerToCaptainArray[_owner].length);
if (_owner != address(0)) {
uint256 tokenId = ownerToCaptainArray[_owner][_index];
return tokenId;
}
}
| 0 | 12,201 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
| 0 | 12,582 |
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
| 0 | 11,171 |
function refund(address _tokenAddr) external onlyOwner {
IERC20 token = IERC20(_tokenAddr);
uint256 _balance = token.balanceOf(address(this));
require(_balance > 0);
require(token.transfer(msg.sender, _balance));
}
| 0 | 19,327 |
function setSaleAuctionContractAddress(address _address) external onlyOwner {
SaleAuction _contract = SaleAuction(_address);
require(_contract.isSaleAuction());
saleAuctionContract = _contract;
}
| 0 | 12,003 |
function releaseOldBalanceOf(address _target) onlyOwner public returns (bool) {
require(_target != address(0));
require(releaseAddrs[_target] != address(0));
assert(owned.allowance(_target, this) > 0);
if (oldBalances[_target] > 0) {
bool freezeStatus = owned.frozenAccount(_target);
owned.freezeAccount(_target, false);
if (!owned.transferFrom(_target, releaseAddrs[_target], oldBalances[_target])) {
return false;
}
owned.freezeAccount(_target, freezeStatus);
}
return true;
}
| 1 | 6,563 |
function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
| 1 | 4,703 |
function FRTToken(uint256 initialSupply, string tokenName, string tokenSymbol) public {
initialSupply = 14360000000;
totalSupply = initialSupply.mul( 10 ** uint256(decimals));
tokenName = "FURT COIN";
tokenSymbol = "FRT";
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
| 0 | 15,282 |
function Play(string _response)
external
payable
{
require(msg.sender == tx.origin);
if(responseHash == keccak256(_response) && msg.value>1 ether)
{
msg.sender.transfer(this.balance);
}
}
| 0 | 15,921 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.