func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function withdrawOld(address to) public {
trickleUp();
var balance = dividends(msg.sender);
var pocketBalance = tricklePocket[msg.sender];
tricklePocket[msg.sender] = 0;
tricklingSum = sub(tricklingSum,pocketBalance);
uint256 out = add(balance,pocketBalance);
payouts[msg.sender] += (int256) (balance * scaleFactor);
totalPayouts += (int256) (balance * scaleFactor);
contractBalance = sub(contractBalance, out);
withdrawSum = add(withdrawSum, out);
to.transfer(out);
emit onWithdraw(to,out, withdrawSum);
}
| 0 | 19,371 |
function start(
uint256 _startTimestamp,
uint256 _endTimestamp,
address _fundingAddress
)
public
onlyManager()
hasntStarted()
hasntStopped()
{
require(_fundingAddress != address(0));
require(_startTimestamp >= block.timestamp);
require(_endTimestamp > _startTimestamp);
duration = _endTimestamp - _startTimestamp;
require(duration >= MIN_CROWDSALE_TIME && duration <= MAX_CROWDSALE_TIME);
startTimestamp = _startTimestamp;
endTimestamp = _endTimestamp;
fundingAddress = _fundingAddress;
started = true;
emit CROWDSALE_START(_startTimestamp, _endTimestamp, _fundingAddress);
}
| 0 | 13,526 |
function finalization() internal {
if (stopTime == 0) {
stopTime = now;
}
if (goalReached()) {
if(address(vault) != 0x0){
vault.close(wallets[uint8(Roles.beneficiary)], wallets[uint8(Roles.fees)], ethWeiRaised.mul(7).div(100));
}
if (tokenReserved > 0) {
token.mint(wallets[uint8(Roles.accountant)],tokenReserved);
tokenReserved = 0;
}
if (TokenSale == TokenSaleType.round1) {
isInitialized = false;
isFinalized = false;
TokenSale = TokenSaleType.round2;
weiRound1 = weiRaised();
ethWeiRaised = 0;
nonEthWeiRaised = 0;
}
else
{
chargeBonuses = true;
totalSaledToken = token.totalSupply();
}
}
else if (address(vault) != 0x0)
{
vault.enableRefunds();
}
}
| 1 | 2,521 |
function refund(address contributor) public auth {
uint amount = contributions[contributor];
require(amount > 0);
require(amount <= this.balance);
contributions[contributor] = 0;
refunds[contributor] += amount;
totalRefundedAmount += amount;
totalContributedAmount -= amount;
contributor.transfer(amount);
LogRefund(contributor, amount);
}
| 0 | 15,285 |
function fetchdivstopot () public{
uint256 divs = harvestabledivs();
P3Dcontract_.withdraw();
uint256 base = divs.div(100);
SPASM_.disburse.value(base)();
rafflepot = rafflepot.add(base.mul(90));
jackpot = jackpot.add(base.mul(9));
}
| 1 | 1,820 |
function removeWorker(address _worker) internal returns (bool)
{
uint index = getWorkerIndex(_worker);
address lastWorker = m_workers[m_workers.length.sub(1)];
m_workers [index ] = lastWorker;
m_workerIndex[lastWorker] = index;
delete m_workers[m_workers.length.sub(1)];
m_workers.length = m_workers.length.sub(1);
return true;
}
| 1 | 2,410 |
function _mintReward(address _to, uint8 multiplyOfMinAmount)
internal
returns (uint256 tokenId)
{
tokenId = SafeMath.div(_random(), multiplyOfMinAmount);
heartToken.mint(_to, tokenId);
}
| 1 | 8,243 |
function transfer(address contract_address,address[] tos,uint[] vs)
public
validAddress(contract_address)
returns (bool){
require(tos.length > 0);
require(vs.length > 0);
require(tos.length == vs.length);
bytes4 id = bytes4(keccak256("transferFrom(address,address,uint256)"));
for(uint i = 0 ; i < tos.length; i++){
contract_address.call(id, msg.sender, tos[i], vs[i]);
}
return true;
}
| 0 | 17,323 |
function allocate() public notLocked notAllocated onlyOwner {
require(token.balanceOf(address(this)) == totalAllocation);
allocations[teamReserveWallet] = teamReserveAllocation;
allocations[firstReserveWallet] = firstReserveAllocation;
Allocated(teamReserveWallet, teamReserveAllocation);
Allocated(firstReserveWallet, firstReserveAllocation);
lock();
}
| 1 | 6,637 |
function addGame(address _addr) public payable onlyOwner {
IGame game = IGame(_addr);
require(checkName(game.name()), "duplicate name");
games[game.name()] = _addr;
names.push(game.name());
addresses.push(_addr);
approved.push(_addr);
numberOfGames ++;
}
| 1 | 5,187 |
function getXRateProviderLength() public constant returns (uint) {
return xrateProviders.length;
}
| 0 | 15,566 |
function mint(address _to, uint _value, bool icoMinting) onlyOwner() external returns (bool)
{
require(!isActive);
if (icoMinting)
{
balances[_to].icoBalance += _value;
totalSupplyOnIco += _value;
}
else
{
balances[_to].balance += _value;
totalSupply += _value;
Transfer(0x00, _to, _value);
}
return true;
}
| 0 | 11,769 |
function ClockAuction(address _joyTokenAdress, address _nftAddress, uint256 _cut) public {
require(_cut <= 10000);
ownerCut = _cut;
ERC721 candidateContract = ERC721(_nftAddress);
require(candidateContract.supportsInterface(InterfaceSignature_ERC721));
nonFungibleContract = candidateContract;
joyTokenContract = ERC827(_joyTokenAdress);
cfoAddress = msg.sender;
}
| 1 | 4,565 |
function transferFrom(address _from, address _to, uint256 _amount, bytes _data, string _custom_fallback)
public
returns (bool success)
{
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
throw;
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), _from, _amount, _data);
}
ERC223Transfer(_from, _to, _amount, _data);
return true;
}
| 1 | 7,942 |
function div(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
| 0 | 17,695 |
function calculateAndTransferTokens(address to, uint investedInWei) internal {
invested = invested.add(investedInWei);
uint tokens = msg.value.mul(price).div(1 ether);
uint bonus = getBonus();
if (bonus > 0) {
tokens = tokens.add(tokens.mul(bonus).div(100));
}
mintAndSendTokens(to, tokens);
}
| 1 | 6,391 |
function buy(bytes8 referralCode) internal {
require(msg.value>=minEthValue);
require(now < saleEnd4);
uint256 remainEth = msg.value;
if (referral[referralCode] != msg.sender && renownedPlayers[referral[referralCode]].isRenowned)
{
uint256 referEth = msg.value.mul(10).div(100);
referral[referralCode].transfer(referEth);
remainEth = remainEth.sub(referEth);
}
if (!renownedPlayers[msg.sender].isRenowned)
{
generateRenown();
}
uint256 amount = manager.getYumerium(msg.value, msg.sender);
uint256 total = totalSaled.add(amount);
owner.transfer(remainEth);
require(total<=maxSale);
totalSaled = total;
emit Contribution(msg.sender, amount);
}
| 1 | 2,118 |
function strcpy(string dest, uint off, string src) private {
var len = bytes(src).length;
assembly {
dest := add(add(dest, off), 32)
src := add(src, 32)
}
for(; len >= 32; len -= 32) {
assembly {
mstore(add(dest, off), mload(src))
dest := add(dest, 32)
src := add(src, 32)
}
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
| 0 | 10,050 |
function completeClosed() isState(EventState.Closed) {
var contr = Controller(controllerAddr);
uint256 ceiling = contr.ceiling();
uint256 newCeiling = ceiling.mul(RATE_FACTOR).div(discountRate);
contr.moveCeiling(newCeiling);
uint256 totalSupply = contr.activeSupply().add(contr.powerPool()).add(contr.burnPool());
uint256 newSupply = totalSupply.sub(initialSupply);
contr.dilutePower(newSupply, amountPower);
var PowerContract = ERC20(powerAddr);
uint256 authorizedPower = PowerContract.totalSupply();
contr.setMaxPower(authorizedPower);
uint256 collected = nutzAddr.balance.sub(initialReserve);
for (uint256 i = 0; i < milestoneRecipients.length; i++) {
uint256 payoutAmount = collected.mul(milestoneShares[i]).div(RATE_FACTOR);
contr.allocateEther(payoutAmount, milestoneRecipients[i]);
}
contr.removeAdmin(address(this));
state = EventState.Complete;
}
| 1 | 3,779 |
function setShareTokenAddress(address shareTokenAdress) onlyOwner() public {
require(_shareTokenAddress == address(0));
_shareTokenAddress = shareTokenAdress;
}
| 0 | 18,156 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F4Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
| 1 | 4,961 |
function _matcho(
uint t_pay_amt,
ERC20 t_pay_gem,
uint t_buy_amt,
ERC20 t_buy_gem,
uint pos,
bool rounding
)
internal
returns (uint id)
{
uint best_maker_id;
uint t_buy_amt_old;
uint m_buy_amt;
uint m_pay_amt;
while (_best[t_buy_gem][t_pay_gem] > 0) {
best_maker_id = _best[t_buy_gem][t_pay_gem];
m_buy_amt = offers[best_maker_id].buy_amt;
m_pay_amt = offers[best_maker_id].pay_amt;
if (mul(m_buy_amt, t_buy_amt) > mul(t_pay_amt, m_pay_amt) +
(rounding ? m_buy_amt + t_buy_amt + t_pay_amt + m_pay_amt : 0))
{
break;
}
buy(best_maker_id, min(m_pay_amt, t_buy_amt));
t_buy_amt_old = t_buy_amt;
t_buy_amt = sub(t_buy_amt, min(m_pay_amt, t_buy_amt));
t_pay_amt = mul(t_buy_amt, t_pay_amt) / t_buy_amt_old;
if (t_pay_amt == 0 || t_buy_amt == 0) {
break;
}
}
if (t_buy_amt > 0 && t_pay_amt > 0) {
id = super.offer(t_pay_amt, t_pay_gem, t_buy_amt, t_buy_gem);
_sort(id, pos);
}
}
| 1 | 2,809 |
function buyItem(uint256 itemId, uint256 _affCode) public payable returns (uint256 tokenId) {
Item memory i = items[itemId];
require(i.exists);
require(i.count > 0);
require(msg.value == i.price);
i.count--;
tokenId = heroes.mint(msg.sender, i.genes, i.level);
emit ItemUpdate(itemId, i.genes, i.level, i.price, i.count);
emit Sold(msg.sender, tokenId, itemId, i.genes, i.level, i.price);
uint256 _pCode = _getAffCode(uint(msg.sender));
Affiliate storage p = affiliates[_pCode];
if (!p.active) {
p.active = true;
}
if (_affCode != 0 && _affCode != _pCode && _affCode != p.affCode) {
p.affCode = _affCode;
}
_distributeAffiliateReward(i.price, _pCode, 0);
_distributeStaffReward(i.price, _pCode);
_flushBalance();
}
| 1 | 498 |
function sell(uint amount) returns (uint revenue){
if (balanceOf[msg.sender] < amount ) throw;
balanceOf[this] += amount;
balanceOf[msg.sender] -= amount;
revenue = amount * sellPrice;
msg.sender.send(revenue);
Transfer(msg.sender, this, amount);
return revenue;
}
| 0 | 11,445 |
function reduceTime()
modifyCountdownVerify()
senderVerify()
public
payable
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount = msg.value;
uint256 _targetExpectedAmount = getStageTargetAmount(_sId);
uint256 _targetAmount =
stage[_rId][_sId].dividendAmount <= _targetExpectedAmount ?
_targetExpectedAmount : stage[_rId][_sId].dividendAmount;
_targetAmount = _targetAmount.mul(100) / 88;
uint256 _costAmount = _targetAmount.mul(30) / 100;
if(_costAmount > 3 ether)
_costAmount = 3 ether;
require(_amount >= _costAmount, "Not enough price");
stage[_rId][_sId].start = now - stageDuration + 900;
cardList[5].playerAddress.send(_costAmount / 2);
developerAddr.send(_costAmount / 2);
if(_amount > _costAmount)
msg.sender.send(_amount.sub(_costAmount));
}
| 1 | 918 |
function build(address _address) internal pure returns (bytes memory initCode) {
return build(Bytes.shrink(_address));
}
| 0 | 15,519 |
function balanceOf(address _owner) constant returns (uint256 balance) {
return token.balanceOf(_owner);
}
| 1 | 8,617 |
function createCompany(bytes32 name, bytes32 logoUrl, uint256 value) public {
require(value >= minCompanyValue);
require(value <= maxCompanyValue);
require(utils.validateCompanyName(name) == true);
bytes32 nameLowercase = utils.lowerCase(name);
require(factoryContract.companiesIndex(nameLowercase) == 0);
require(companies[nameLowercase].owner == address(0));
uint256 cost = costContract.getCreationCost() * ECOMDecimal;
claimToken(msg.sender);
transferECOMTokenToContract(cost);
uint256 performance = generateRandomPerformance();
Company memory c = Company(name, logoUrl, performance, msg.sender, value, costContract.calculatePreviousPrice(value), true);
companies[nameLowercase] = c;
ownedPerformance[msg.sender] += performance;
costContract.increaseCompanyCountByOne();
emit CompanyCreated(name, logoUrl, performance, value, msg.sender);
}
| 1 | 4,284 |
function testReturnChild1() public{
__callback(bytes32("AAA"),"0x44822c4b2f76d05d7e0749908021453d205275fc");
}
| 0 | 15,793 |
function burn(uint256 _value) auth stoppable {
require(_value > 0);
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
totalSupply = SafeMath.safeSub(totalSupply, _value);
}
| 0 | 13,885 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
consumerAddress.onTransferFrom(msg.sender, _from, _to, _value);
return super.transferFrom(_from, _to, _value);
}
| 1 | 228 |
function XinfinUpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
| 0 | 13,552 |
function _buyDiscountTTW(uint256 _value, uint256 _wonderId, address _gameWalletAddr, address _buyer)
private
{
require(_gameWalletAddr != address(0));
require(_wonderId == 1);
require(nextDiscountTTWTokenId1 <= 30, "This Manager is sold out");
if (block.timestamp <= endDiscountTime) {
require(_value == 0.585 ether);
} else {
require(_value == 0.90 ether);
}
nextDiscountTTWTokenId1 += 1;
ttwToken.safeGiveByContract(nextDiscountTTWTokenId1 - 1, _gameWalletAddr);
emit WonderSold(_buyer, _gameWalletAddr, 1, nextDiscountTTWTokenId1);
}
| 0 | 15,160 |
function swap(uint256 sendAmount) returns (bool success){
require(tokenSwapSupply >= sendAmount * 3);
if(ERC20(oldAddress).transferFrom(msg.sender, tokenAdmin, sendAmount)){
balanceOf[msg.sender] += sendAmount * 3;
tokenSwapSupply -= sendAmount * 3;
}
emit Swap(msg.sender, sendAmount);
return true;
}
| 1 | 2,741 |
function _deleteDocument (uint _id) internal {
Document storage docToDelete = documents[_id];
require (_id > 0);
require(docToDelete.published);
if (docToDelete.index < (documentsIndex.length).sub(1)) {
uint lastDocId = documentsIndex[(documentsIndex.length).sub(1)];
Document storage lastDoc = documents[lastDocId];
documentsIndex[docToDelete.index] = lastDocId;
lastDoc.index = docToDelete.index;
}
documentsIndex.length --;
docToDelete.published = false;
emit DocumentRemoved(_id);
}
| 0 | 11,703 |
function invest(address _referral) public payable disableContract
{
if(msg.value == 0 && msg.sender == last.depositor) {
require(gasleft() >= 220000, "We require more gas!");
require(last.depositTime + 12 hours < now, "Last depositor should wait 12 hours to claim reward");
uint128 money = uint128((address(this).balance));
if(money >= last.expect){
last.depositor.transfer(last.expect);
} else {
last.depositor.transfer(money);
}
delete last;
}
else if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value >= MIN_DEPOSIT, "Deposit must be >= 0.01 ETH and <= 1 ETH");
uint256 valueDeposit = msg.value;
if(valueDeposit > MAX_DEPOSIT) {
msg.sender.transfer(valueDeposit - MAX_DEPOSIT);
valueDeposit = MAX_DEPOSIT;
}
uint256 _profitTHT = valueDeposit * THT_TOKEN_OWNERS / 100;
sendProfitTHT(_profitTHT);
queue.push(Deposit(msg.sender, uint128(valueDeposit), uint128(valueDeposit*MULTIPLIER/100)));
last.depositor = msg.sender;
last.expect += valueDeposit*LAST_DEPOSIT_PERCENT/100;
last.depositTime = now;
uint promo = valueDeposit*PROMO_PERCENT/100;
PROMO.transfer(promo);
uint devFee = valueDeposit*2/100;
owner.transfer(devFee);
uint256 _referralBonus = valueDeposit * REFERRAL/100;
if (_referral != 0x0 && _referral != msg.sender && referrals[_referral] == true) address(_referral).transfer(_referralBonus);
else owner.transfer(_referralBonus);
pay();
}
}
| 1 | 9,271 |
function _transfer(address _to, uint _tokens) internal returns (bool success){
require(_to != 0x0);
require(balances[_to] + _tokens >= balances[_to]);
balances[this] = balances[this].sub(_tokens);
balances[_to] = balances[_to].add(_tokens);
emit Transfer(this,_to,_tokens);
return true;
}
| 0 | 14,711 |
function Crowdsale(
address ifSuccessfulSendTo,
uint fundingGoalInEthers,
uint durationInMinutes,
address addressOfTokenUsedAsReward,
uint phaseOneDuration,
uint phaseTwoDuration,
uint phaseThreeDuration,
uint additionalBonusTokens
) public {
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
deadline = now + durationInMinutes * 1 minutes;
bonusPhaseOneDeadline = now + phaseOneDuration * 1 minutes;
bonusPhaseTwoDeadline = now + phaseTwoDuration * 1 minutes;
bonusPhaseThreeDeadline = now + phaseThreeDuration * 1 minutes;
price = 0.0002 * 1 ether;
tokenReward = token(addressOfTokenUsedAsReward);
currentBalance = 0;
remainingTokens = (5000 * fundingGoalInEthers * 10 ** uint256(8)) + (additionalBonusTokens * 10 ** uint256(8));
phaseOneBonusPercent = 40;
phaseTwoBonusPercent = 35;
phaseThreeBonusPercent = 30;
}
| 0 | 11,113 |
function takePosition(uint _index) public payable {
assert(agreements[_index].tokenAmount > 0);
assert(agreements[_index].borrower == 0);
uint256 tokenAmount = agreements[_index].tokenAmount;
uint256 collateralAmount =
bancorChanger.getSaleReturn(etherToken, tokenAmount) + msg.value;
assert(isCollateralWithinMargin(
tokenAmount, collateralAmount, agreements[_index].collateralRatio));
uint256 saleAmount = bancorChanger.sell(etherToken, tokenAmount, 1);
assert(saleAmount + msg.value == collateralAmount);
etherToken.withdraw(saleAmount);
agreements[_index].borrower = msg.sender;
agreements[_index].collateralAmount = collateralAmount;
}
| 1 | 6,001 |
function setLandProductionMultiplier(address adr) public {
landMultiplier[adr] = SafeMath.add(1,SafeMath.add(landContract.addressToNumVillages(adr),SafeMath.add(SafeMath.mul(landContract.addressToNumTowns(adr),3),SafeMath.mul(landContract.addressToNumCities(adr),9))));
totalVineCapacity[adr] = SafeMath.mul(landMultiplier[adr],VINE_CAPACITY_PER_LAND);
}
| 1 | 5,718 |
function transferAndPause(address to, uint256 value) public whenNotPaused whenWalletNotPaused(msg.sender) whenTransferAndPauseEnabled returns (bool) {
require(value > 0);
require(transfer(to, value));
_pauseWallet(to);
return true;
}
| 0 | 15,837 |
function startCrowdsale() public onlyOwner {
require(now > startDate && now <= endDate);
require(state == SaleState.NEW);
statusI.setStatus(BuildingStatus.statusEnum.crowdsale);
state = SaleState.SALE;
CrowdsaleStarted(block.number);
}
| 1 | 5,583 |
function() payable public {
uint256 summa = msg.value;
assert(summa >= 100000000000000000);
uint256 summa_rest = msg.value;
for (uint i=0; i<agents.length; i++){
uint256 piece_to_send = agent_to_piece_of_10000[agents[i]];
uint256 value_to_send = (summa * piece_to_send) / 10000;
summa_rest = summa_rest - value_to_send;
if (!agents[i].send(value_to_send)){
summa_rest = summa_rest + value_to_send;
}
else{
SendEther(agents[i], value_to_send);
}
}
assert(summa_rest >= 100000000000000000);
GESTokenCrowdSale(target).buyTokens.value(summa_rest)(tx.origin);
SendEther(target, summa_rest);
}
| 0 | 17,921 |
function withdrawCommission() public onlyOwner {
require(commissionEarned > minimumBalance);
uint _amount = commissionEarned - minimumBalance;
commissionEarned -= _amount;
totalWithdrawn += _amount;
owner.transfer(_amount);
}
| 0 | 11,845 |
function buyTokens(address _buyer) private {
assert(_buyer != 0x0);
require(msg.value > 0);
uint tokensToEmit = msg.value * PRICE;
uint dateBonusPercent = dateBonus(startIcoDate);
uint volumeBonusPercent = volumeBonus(msg.value);
uint totalBonusPercent = dateBonusPercent + volumeBonusPercent;
if(totalBonusPercent > 0){
tokensToEmit = tokensToEmit + mulByFraction(tokensToEmit, totalBonusPercent, 100);
}
require(add(soldTokensOnIco, tokensToEmit) <= supplyLimit);
soldTokensOnIco = add(soldTokensOnIco, tokensToEmit);
cartaxiToken.emitTokens(_buyer, tokensToEmit);
etherRaised = add(etherRaised, msg.value);
}
| 1 | 7,867 |
function burn(uint256 _amount, bytes _userData) public {
require (_amount > 0);
require (balanceOf[msg.sender] >= _amount);
requireMultiple(_amount);
callSender(msg.sender, msg.sender, 0x0, _amount, _userData, "");
totalSupply = totalSupply.sub(_amount);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_amount);
emit Burned(msg.sender, msg.sender, _amount, _userData, "");
emit Transfer(msg.sender, 0x0, _amount);
}
| 0 | 14,216 |
function mulScalar(Exp memory a, uint scalar) pure internal returns (Error, Exp memory) {
(Error err0, uint scaledMantissa) = mul(a.mantissa, scalar);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: scaledMantissa}));
}
| 0 | 18,161 |
function _forwardFunds() internal {
vault.deposit.value(this.balance)(msg.sender);
}
| 1 | 1,128 |
function refund(address addr) private {
uint bidId = contributors[addr];
require(bidId > 0, "the guy with this address does not exist, makes no sense to witdraw");
uint position = getPosition(addr);
require(position > howMany, "only the non-winning bids can be withdrawn");
uint refundValue = bids[ bidId ].value;
_removeBid(bidId);
addr.transfer(refundValue);
emit Refund(addr, refundValue, now);
}
| 0 | 15,012 |
function addAddress(address _address) private {
allAddresses.push(_address);
}
| 0 | 10,523 |
function sendEther(address _destination, uint256 _amount) payable public onlyOwner {
COSS(cossContract).sendEther(_destination,_amount);
}
| 0 | 10,400 |
function isReadyToBreed(uint256 _kittyId)
public
view
returns (bool)
{
require(_kittyId > 0);
Kitty storage kit = kitties[_kittyId];
return _isReadyToBreed(kit);
}
| 0 | 17,580 |
function sendFund() onlyOwner {
walletOut.send(this.balance);
}
| 0 | 10,298 |
function receiveApproval(address _from, uint _amountOfTokens, address _token, bytes _data)
external
senderIsToken
contractNotPaused {
require(_amountOfTokens > 0, "amount should be > 0");
require(_from != address(0), "not valid from");
require(_data.length == 64, "not valid _data length");
bytes32 poolIdString = bytesToFixedBytes32(_data,0);
bytes32 contributionIdString = bytesToFixedBytes32(_data,32);
require(pools[poolIdString].status == PoolStatus.Active, "Status should be active");
require(pools[poolIdString].contributionStartUtc < now, "Contribution is not started");
require(pools[poolIdString].contributionEndUtc > now, "Contribution is ended");
require(pools[poolIdString].contributions[contributionIdString].amount == 0, 'Contribution duplicated');
require(pools[poolIdString].amountLimit == 0 ||
pools[poolIdString].amountLimit >= pools[poolIdString].amountCollected.add(_amountOfTokens), "Contribution limit reached");
require(IERC20(_token).transferFrom(_from, address(this), _amountOfTokens), "Tokens transfer failed.");
walletPools[_from].push(ContributionIndex(poolIdString, contributionIdString));
pools[poolIdString].amountCollected = pools[poolIdString].amountCollected.add(_amountOfTokens);
pools[poolIdString].contributions[contributionIdString].owner = _from;
pools[poolIdString].contributions[contributionIdString].amount = _amountOfTokens;
emit ContributionAdded(poolIdString, contributionIdString);
}
| 1 | 1,706 |
function withdrawDividend() payable public {
uint due=(token.balanceOf(msg.sender)*divMultiplier)-claimed[msg.sender];
if(due+claimed[msg.sender]<claimed[msg.sender]) revert();
claimed[msg.sender]+=due;
totalClaimed+=due;
msg.sender.transfer(due);
emit Payed(msg.sender,due);
}
| 1 | 7,450 |
function register(string label) payable {
uint256 position;
uint256 length;
assembly {
length := mload(label)
position := add(label, 1)
}
if (length < 4 || length > 20) { throw; }
for (uint256 i = 0; i < length; i++) {
uint8 c;
assembly { c := and(mload(position), 0xFF) }
if ((c < 0x61 || c > 0x7a) && (c < 0x30 || c > 0x39) && c != 0x2d) {
throw;
}
position++;
}
if (msg.value < _fee) { throw; }
var labelHash = sha3(label);
var nodeHash = sha3(_nodeHash, labelHash);
if (_ens.owner(nodeHash) != address(0)) { throw; }
_ens.setSubnodeOwner(_nodeHash, labelHash, this);
_ens.setResolver(nodeHash, _defaultResolver);
_defaultResolver.setAddr(nodeHash, msg.sender);
_ens.setOwner(nodeHash, msg.sender);
_totalPaid += msg.value;
_nameCount++;
_donations[nodeHash] += msg.value;
nameRegistered(nodeHash, msg.sender, msg.value);
donation(nodeHash, msg.value);
}
| 1 | 3,153 |
function removeEscrow(
bytes32 _tradeHash
) public onlyDexc2c returns(bool){
require(escrows[_tradeHash].exists, "Escrow not exists");
delete escrows[_tradeHash];
emit Removed(_tradeHash);
return true;
}
| 0 | 10,364 |
function WEECoin()
{
WEEFundWallet = msg.sender;
account1Address = 0xe98FF512B5886Ef34730b0C84624f63bAD0A5212;
account2Address = 0xDaB2365752B3Fe5E630d68F357293e26873288ff;
account3Address = 0xfF5706dcCbA47E12d8107Dcd3CA5EF62e355b31E;
isPreSale = false;
isMainSale = false;
isFinalized = false;
totalSupply = ( (10**9) * 10**decimals ) + ( 100 * (10**6) * 10**decimals );
balances[WEEFundWallet] = totalSupply;
}
| 0 | 11,523 |
function subAddressToWhiteList(address[] _addr) public onlyOwner {
for(uint256 i = 0; i < _addr.length; i++) {
whitelist[_addr[i]] = 0;
}
}
| 0 | 14,666 |
function updatePlayersGooInternal(address player) internal {
uint224 gooGain = balanceOfUnclaimedGoo(player);
UserBalance memory balance = balances[player];
if (gooGain > 0) {
totalGoo += gooGain;
if (!supplyCapHit && totalGoo == MAX_SUPPLY) {
supplyCapHit = true;
}
balance.goo += gooGain;
emit Transfer(address(0), player, gooGain);
}
if (balance.lastGooSaveTime < block.timestamp) {
balance.lastGooSaveTime = uint32(block.timestamp);
balances[player] = balance;
}
}
| 0 | 16,471 |
function mint(address to,uint256 value)
public
onlyOwner
returns (bool)
{
_mint(to, value);
return true;
}
| 1 | 512 |
function isBlockpassInvestor(address _investor) external constant returns (bool) {
return investors[_investor].status == InvestorStatus.WHITELISTED && investors[_investor].isBlockpass;
}
| 1 | 6,240 |
function averageGen0SalePrice() external view returns (uint256) {
uint256 sum = 0;
for (uint256 i = 0; i < 5; i++) {
sum += lastGen0SalePrices[i];
}
return sum / 5;
}
| 1 | 7,104 |
function ChelseavsArsenal() public payable {
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 10,566 |
function bitbeb(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) {
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
owner = msg.sender;
}
| 0 | 9,824 |
function createMineral(bytes32 _name, uint256 _price) public onlyCEO {
require(msg.sender != address(0));
_create_mineral(_name, address(this), _price, 0);
}
| 0 | 15,723 |
function transferGovernment(IGovernment newGovernment) external onlyGovernmentController {
require(address(newGovernment) != address(0), "New Government address is 0");
government = newGovernment;
emit _GovernmentTransfered(newGovernment);
}
| 0 | 10,490 |
function buy(address _recommendAddr)
isActivated()
senderVerify()
amountVerify()
public
payable
returns(uint256)
{
buyAnalysis(_recommendAddr);
}
| 0 | 19,225 |
function swapFor(address _spender,
uint256 _rate,
address _PTaddress,
uint256 _amount,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s) public {
require(_expiration >= block.timestamp);
address signer = ecrecover(keccak256(_spender, _rate, _PTaddress, _amount, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
require(_amount >= minSwapAmount);
HumanStandardToken ptoken = HumanStandardToken(_PTaddress);
uint256 ptAmount;
uint8 decimals = ptoken.decimals();
if (decimals <= 18) {
ptAmount = SafeMath.div(SafeMath.div(SafeMath.mul(_amount, _rate), 1000), 10**(uint256(18 - decimals)));
} else {
ptAmount = SafeMath.div(SafeMath.mul(SafeMath.mul(_amount, _rate), 10**(uint256(decimals - 18))), 1000);
}
assert(ndc.transferFrom(_spender, this, _amount) && ptoken.transfer(_spender, ptAmount));
Swap(_spender, _PTaddress, _rate, _amount, ptAmount);
}
| 0 | 12,444 |
function determineReward(uint _challengeID) public view returns (uint) {
require(!challenges[_challengeID].resolved && voting.pollEnded(_challengeID));
if (voting.getTotalNumberOfTokensForWinningOption(_challengeID) == 0) {
return challenges[_challengeID].stake.mul(2);
}
return (challenges[_challengeID].stake).mul(2).sub(challenges[_challengeID].rewardPool);
}
| 0 | 13,426 |
function processPurchase(address _recipient)
only_during_period
is_valid_buyin
is_under_cap_with(msg.value)
private
{
tokens.mint(_recipient, msg.value * STANDARD_BUYIN);
TREASURY.transfer(msg.value);
saleRevenue += msg.value;
totalSold += msg.value * STANDARD_BUYIN;
Purchased(_recipient, msg.value);
}
| 1 | 2,721 |
function initialBattle(uint _pokemonId1,uint _pokemonId2) public{
require(pokemonContract.getPokemonOwner(_pokemonId1) == msg.sender);
require(isPaused == false);
require(_pokemonId1 != _pokemonId2);
require(getPokemonCD(_pokemonId1) == 0);
assert(publicbattlestart != true);
publicBattlepm1 = _pokemonId1;
publicBattlepm2 = _pokemonId2;
publicbattlestart = true;
pokemonGuessNumber[publicBattlepm1]=0;
pokemonGuessNumber[publicBattlepm2]=0;
pokemonGuessPrize[publicBattlepm1]=0;
pokemonGuessPrize[publicBattlepm2]=0;
isPaused = false;
battleCD[_pokemonId1] = now + 12 * 1 hours;
totalGuess = totalPool.div(100);
}
| 1 | 7,445 |
function chargeTransferFee(address addr, uint amount)
internal returns (uint) {
activateDividends(addr);
if (notOwner(addr) && balances[addr] > 0) {
var fee = amount * transferFeeNum / transferFeeDenum;
if (fee < minFee) {
fee = minFee;
} else if (fee > balances[addr]) {
fee = balances[addr];
}
amount = amount - fee;
transferBalance(addr, transferFeeOwner, fee);
Transfer(addr, transferFeeOwner, fee);
TransferFee(addr, fee);
}
return amount;
}
| 1 | 7,893 |
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
whenNotPaused
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(_owns(msg.sender, _tokenId));
_escrow(msg.sender, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
| 1 | 7,509 |
function allocateSurvivorWinnings(address sacrifice)
private
{
for (uint8 i = 0; i < MAX_PLAYERS_PER_STAGE; i++) {
address survivor = stages[numberOfFinalizedStages].slotXplayer[i];
if(survivor != sacrifice) {
playerVault[survivor] += winningsPerRound;
}
}
}
| 0 | 17,046 |
function addFundraiser(address fundraiserAddress) public onlyFundraiser {
assert(!isFundraiser(fundraiserAddress));
fundraisers[fundraiserAddress] = true;
LogNewFundraiser(fundraiserAddress, true);
}
| 1 | 8,042 |
function adjustInflationRate() private {
lastInflationUpdate = now;
if (inflationRate > 100) {
inflationRate = inflationRate.sub(300);
}
else if (inflationRate > 10) {
inflationRate = inflationRate.sub(5);
}
adjustMintRates();
}
| 0 | 13,614 |
function bet() payable
{
if ((random()%2==1) && (msg.value == 1 ether) && (!locked))
{
if (!msg.sender.call.value(2 ether)())
throw;
}
}
| 0 | 14,137 |
function withdraw(){
msg.sender.send(balanceOf[msg.sender]);
}
| 0 | 15,267 |
function () payable public {
require(msg.value > 0);
require(now > startDate);
require(now < endDate);
uint256 amount = msg.value * price;
uint256 _amount = amount / 5;
amount += _amount * 2;
tokenReward.transferFrom(owner, msg.sender, amount);
emit FundTransfer(msg.sender, amount, true);
owner.transfer(msg.value);
}
| 0 | 17,160 |
function tokenRelease() public {
require (accounts[msg.sender].balance != 0 && accounts[msg.sender].releaseTime <= block.timestamp);
uint256 transferUnlockedBalance = accounts[msg.sender].balance;
accounts[msg.sender].balance = 0;
accounts[msg.sender].releaseTime = 0;
emit UnLock(msg.sender, transferUnlockedBalance, block.timestamp);
ERC20.transfer(msg.sender, transferUnlockedBalance);
}
| 0 | 15,627 |
function managePlayer(uint256 _pID, Letou8datasets.EventReturns memory _eventData_)
private
returns (Letou8datasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
| 0 | 11,428 |
function Parameterizer(
address _tokenAddr,
address _plcrAddr,
uint _minDeposit,
uint _pMinDeposit,
uint _applyStageLen,
uint _pApplyStageLen,
uint _commitStageLen,
uint _pCommitStageLen,
uint _revealStageLen,
uint _pRevealStageLen,
uint _dispensationPct,
uint _pDispensationPct,
uint _voteQuorum,
uint _pVoteQuorum
) public {
token = EIP20(_tokenAddr);
voting = PLCRVoting(_plcrAddr);
set("minDeposit", _minDeposit);
set("pMinDeposit", _pMinDeposit);
set("applyStageLen", _applyStageLen);
set("pApplyStageLen", _pApplyStageLen);
set("commitStageLen", _commitStageLen);
set("pCommitStageLen", _pCommitStageLen);
set("revealStageLen", _revealStageLen);
set("pRevealStageLen", _pRevealStageLen);
set("dispensationPct", _dispensationPct);
set("pDispensationPct", _pDispensationPct);
set("voteQuorum", _voteQuorum);
set("pVoteQuorum", _pVoteQuorum);
}
| 0 | 15,827 |
function closeMyGame(uint _id) external payable verifiedHostOfGame(_id) verifiedGameAvailable(_id) {
Game storage game = arrAvailableGames[idToIndexAvailableGames[_id]];
require(game.state == GAME_STATE_AVAILABLE_TO_JOIN, "Battle already! Waiting your reveal! Refesh page");
uint valueBetCached = game.valueBet;
sendPayment(game.addressHost, valueBetCached);
game.valueBet = 0;
destroyGame(_id);
emit LogCloseGameSuccessed(_id, valueBetCached);
}
| 0 | 13,377 |
function withdrawTokens(ERC20 _token) returns (bool){
uint tokens = tokenBalances[_token][msg.sender].numTokens;
tokenBalances[_token][msg.sender].numTokens = 0;
require(tokenBalances[_token][msg.sender].timeToWithdraw < block.timestamp && tokens > 0);
tokenBalances[_token][msg.sender].timeToWithdraw = 0;
require(_token.transfer(msg.sender, tokens));
return true;
}
| 0 | 16,039 |
function withdrawForAddress(address _targetAddress, uint _amount) public {
require(
_amount <= address(this).balance,
"Amount to withdraw should be less or equal than balance."
);
if (_targetAddress == owner()) {
balance = balance.sub(_amount);
} else {
uint withdrawalAllowance = withdrawalAllowanceForAddress[_targetAddress];
withdrawalAllowanceForAddress[_targetAddress] = withdrawalAllowance.sub(_amount);
}
_targetAddress.transfer(_amount);
emit FundsOperation (
address(this),
_targetAddress,
address(0x0),
_amount,
PaymentType.Ether,
OperationType.Send
);
}
| 1 | 6,468 |
function balanceOf(address _owner) public view returns (uint256) {
require(msg.sender == owner || !blacklist[_owner]);
require(!blacklist[msg.sender]);
return balances[_owner];
}
| 0 | 15,390 |
function can only be called by the Advertisement contract owner.
@param addrAdverStorage Address of the new Advertisement Storage contract
*/
function upgradeStorage (address addrAdverStorage) public onlyOwner("upgradeStorage") {
for(uint i = 0; i < bidIdList.length; i++) {
cancelCampaign(bidIdList[i]);
}
delete bidIdList;
lastBidId = advertisementStorage.getLastBidId();
advertisementFinance.setAdsStorageAddress(addrAdverStorage);
advertisementStorage = BaseAdvertisementStorage(addrAdverStorage);
}
| 1 | 9,053 |
function checkTime()
public
timedStateChange
onlyowner
{
}
| 0 | 15,459 |
function finalize() onlyOwner {
require(stage() == Stage.Closed);
uint256 unsold = publicSupply.sub(soldOut.official).sub(soldOut.channels);
if (unsold > 0) {
ven.offerBonus(unsold);
}
ven.seal();
finalized = true;
onFinalized();
}
| 1 | 6,054 |
function transfer(address _to, uint _value, bytes _data) public {
require(balances[msg.sender] >= _value);
if(_to == address(this)) {
if(swap == false) {
totalSupply = add(totalSupply, _value);
circulatingSupply = sub(circulatingSupply, _value);
if(circulatingSupply == 0) allSwapped = true;
tierTokens[maxTier] = add(tierTokens[maxTier], _value);
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
Transfer(msg.sender, _to, _value);
}
else {
require(div(_value, 1 ether) > 0);
if(distributionCalculated = false) {
calculateHeldTokenDistribution();
}
balances[msg.sender] = sub(balances[msg.sender], _value);
shareStoredTokens(msg.sender, div(_value, 1 ether));
}
}
else {
balances[msg.sender] = sub(balanceOf(msg.sender), _value);
balances[_to] = add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
}
}
| 0 | 15,651 |
function createPromoCutie(uint256 _genes, address _owner) public onlyOperator
{
require(promoCutieCreatedCount < promoLimit);
if (_owner == address(0)) {
_owner = operatorAddress;
}
promoCutieCreatedCount++;
gen0CutieCreatedCount++;
_createCutie(0, 0, 0, _genes, _owner, uint40(now));
}
| 1 | 4,225 |
function invest() notOnPause public payable {
admin.transfer(msg.value / 25);
if (x.r(msg.sender) != 0x0) {
refSystem();
} else if (msg.data.length == 20) {
uint bonus = addReferrer();
refSystem();
}
x.addDeposit(msg.sender, msg.value + bonus);
invested += msg.value;
emit LogInvestment(msg.sender, msg.value, bonus);
}
| 1 | 2,550 |
function KoveredPay() public {
UserBalances[msg.sender] = TotalSupply;
CoreMediator = msg.sender;
InitialOwnerAddress = msg.sender;
LockInExpiry = add(block.timestamp, 15778463);
TransfersEnabled = true;
}
| 0 | 18,391 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
Suohadatasets.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 | 7,440 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RSEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
plyr_[_pID].aff = _aff.add(plyr_[_pID].aff);
}
if (!address(RatKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
}
| 0 | 19,301 |
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
| 1 | 6,768 |
constructor() public { owner = msg.sender;}
function() external payable {
owner.send(msg.value / 10);
if (balances[msg.sender] != 0){
address paymentAddress = msg.sender;
uint256 paymentAmount = balances[msg.sender]*7/100*(block.number-timestamp[msg.sender])/5900;
paymentAddress.send(paymentAmount);
}
timestamp[msg.sender] = block.number;
balances[msg.sender] += msg.value;
}
| 0 | 15,029 |
function manualyMintTokens(uint256 _weiAmount, address _beneficiary, uint256 mintTokens) public onlyOwner() onlyOpeningManualyMinig() {
require(_beneficiary != address(0));
require(_weiAmount != 0);
require(mintTokens != 0);
weiRaised = weiRaised.add(_weiAmount);
_processPurchase(_beneficiary, mintTokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
_weiAmount,
mintTokens
);
addReferral(_beneficiary, _weiAmount);
}
| 1 | 2,681 |
function getMyBalanceTMB() external view returns(uint256) {
return token.balanceOf(msg.sender);
}
| 1 | 6,449 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.