func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
| 1 | 9,523 |
function transferOwnershipBack() public onlyOwner {
ownedContract.transferOwnership(origOwner);
ownedContract = iContract(address(0));
origOwner = address(0);
}
| 1 | 1,363 |
function releasedAmountBlocksIn(uint256 startBlock, uint256 endBlock)
public
view
returns (uint256)
{
require(startBlock < endBlock);
if (executedReleasesCount == 0 || endBlock < releases[0].blockNumber)
return 0;
uint256 i = 0;
while (i < executedReleasesCount && releases[i].blockNumber < startBlock)
i++;
uint256 r;
if (i >= executedReleasesCount)
r = totalReleasedAmounts[executedReleasesCount - 1].mul(endBlock.sub(startBlock));
else {
uint256 l = (i == 0) ? startBlock : releases[i - 1].blockNumber;
uint256 h = releases[i].blockNumber;
if (h > endBlock)
h = endBlock;
h = h.sub(startBlock);
r = (h == 0) ? 0 : totalReleasedAmountBlocks[i].mul(h).div(releases[i].blockNumber.sub(l));
i++;
while (i < executedReleasesCount && releases[i].blockNumber < endBlock) {
r = r.add(totalReleasedAmountBlocks[i]);
i++;
}
if (i >= executedReleasesCount)
r = r.add(
totalReleasedAmounts[executedReleasesCount - 1].mul(
endBlock.sub(releases[executedReleasesCount - 1].blockNumber)
)
);
else if (releases[i - 1].blockNumber < endBlock)
r = r.add(
totalReleasedAmountBlocks[i].mul(
endBlock.sub(releases[i - 1].blockNumber)
).div(
releases[i].blockNumber.sub(releases[i - 1].blockNumber)
)
);
}
return r;
}
| 1 | 4,357 |
function transferFrom(address _from, address _to, uint256 _tokenId)
senderVerify()
public
{
require (_from == cardList[_tokenId].playerAddress, "Owner error");
require(_to != address(0), "Address error");
require(_to == cardIndexToApproved[_tokenId], "Without permission");
cardList[_tokenId].playerAddress = _to;
delete cardIndexToApproved[_tokenId];
emit Transfer(_from, _to, _tokenId);
}
| 0 | 16,735 |
constructor()
HasOwner(msg.sender)
public
{
token = new CenturyXToken(
msg.sender,
address(this)
);
tokenSafe = new CenturyXTokenSafe(token);
MintableToken(token).mint(address(tokenSafe), 14880000000000000000000000);
initializeBasicFundraiser(
1550484000,
1566122400,
1000,
0x1ffdaB90db08d0e8315e047A89A196ae657ed280
);
initializeIndividualCapsFundraiser(
(0.1 ether),
(20 ether)
);
initializeGasPriceLimitFundraiser(
60000000000
);
initializeCappedFundraiser(
(6120 ether)
);
}
| 1 | 5,260 |
function _burn(address _account, uint256 _amount) internal {
require(_account != 0);
require(_amount <= balances_[_account]);
totalSupply_ = totalSupply_.sub(_amount);
balances_[_account] = balances_[_account].sub(_amount);
emit Transfer(_account, address(0), _amount);
}
| 0 | 16,854 |
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
sendTokens(addresses[i], amounts[i]);
cslToken.transfer(addresses[i], amounts[i]);
}
}
| 0 | 17,002 |
function executeSubscription(uint subId) public notSuspended noReentrancy(L00) returns (bool) {
Subscription storage sub = subscriptions[subId];
assert (msg.sender == sub.transferFrom || msg.sender == sub.transferTo || msg.sender == owner);
if (_subscriptionState(sub)==SubState.CHARGEABLE) {
var _from = sub.transferFrom;
var _to = sub.transferTo;
var _value = _amountToCharge(sub);
if (san._fulfillPayment(_from, _to, _value, subId, msg.sender)) {
sub.paidUntil = max(sub.paidUntil, sub.startOn) + sub.chargePeriod;
++sub.execCounter;
assert (ServiceProvider(_to).onSubExecuted(subId));
return true;
}
}
if (isContract(msg.sender)) { return false; }
else { throw; }
}
| 1 | 680 |
function reserveFunds(address _address) onlyOwner public {
require(_address != address(0));
require(!isReservedFundsDone);
sendFromContract(_address, RESERVE_FUND);
isReservedFundsDone = true;
}
| 0 | 13,050 |
function bidOnBreedingAuctionTutorial(
uint40 _dadId
)
public
payable
whenNotPaused
returns (uint)
{
require(isTutorialPetUsed[msg.sender] == 0);
uint256 fee = getBreedingFee(0, _dadId);
require(msg.value >= fee);
breedingMarket.bid.value(msg.value - fee)(_dadId);
Cutie storage dad = cuties[_dadId];
_triggerCooldown(_dadId, dad);
delete sireAllowedToAddress[_dadId];
uint16 babyGen = config.getTutorialBabyGen(dad.generation);
uint256 childGenes = geneMixer.mixGenes(0x0, dad.genes);
uint40 cutieId = _createCutie(0, _dadId, babyGen, getCooldownIndexFromGeneration(babyGen), childGenes, msg.sender, 12);
isTutorialPetUsed[msg.sender] = cutieId;
return cutieId;
}
| 1 | 3,489 |
function initialize(
VEN _ven,
address _ethVault,
address _venVault,
uint256 _channelsLimit,
uint _startTime,
uint _endTime,
uint _earlyStageLasts) onlyOwner {
require(stage() == Stage.Created);
require(_ven.owner() == address(this));
require(address(_ethVault) != 0);
require(address(_venVault) != 0);
require(_startTime > blockTime());
require(_startTime.add(_earlyStageLasts) < _endTime);
ven = _ven;
ethVault = _ethVault;
venVault = _venVault;
channelsLimit = _channelsLimit;
officialLimit = publicSupply.sub(_channelsLimit);
startTime = _startTime;
endTime = _endTime;
earlyStageLasts = _earlyStageLasts;
ven.mint(
venVault,
reservedForTeam.add(reservedForOperations),
false
);
ven.mint(
venVault,
privateSupply.add(commercialPlan),
true
);
initialized = true;
onInitialized();
}
| 1 | 3,664 |
function userDepositedWei(address _address) public view returns (uint256)
{
return deposited[_address];
}
| 0 | 14,648 |
function transferTokens (address[] _recipients) public onlyOwnerOrAdmin {
for (uint256 addressIndex = 0; addressIndex < _recipients.length; addressIndex++) {
address recipient = _recipients[addressIndex];
Allocation storage allocation = allocations[recipient];
if (allocation.totalAllocated > 0) {
uint256 amount = allocation.totalAllocated.sub(allocation.amountClaimed);
require(LXT.transferFrom(LXT_OWNER, recipient, amount));
allocation.amountClaimed = allocation.amountClaimed.add(amount);
grandTotalClaimed = grandTotalClaimed.add(amount);
}
}
}
| 1 | 1,661 |
function withdrawFees(
address to,
uint256 value
)
public
onlyOwner
canWithdraw
{
uint256 expectedTotalWithdraw = _withdrawnFees.add(value);
require(
expectedTotalWithdraw <= totalFee(),
"can't withdraw more than available fee"
);
_withdrawnFees = expectedTotalWithdraw;
_token.safeTransfer(to, value);
}
| 1 | 508 |
function applyRedenomination() onlyNotWorking {
if (isRedenominated) throw;
if (redenomiValue == 0) throw;
if (ownerValidator.validate(msg.sender)) {
isRedenominated = true;
ApplyRedenomination(msg.sender, isRedenominated, redenomiValue);
}
}
| 1 | 166 |
function balanceOfUnclaimedGoo(address player) internal constant returns (uint256) {
uint256 lastSave = lastGooSaveTime[player];
if (lastSave > 0 && lastSave < block.timestamp) {
return (1000 * (block.timestamp - lastSave)) / 100;
}
return 0;
}
| 0 | 13,689 |
function activeBuy()
public
onlyAdmin()
{
require(buyActived == false, "already actived");
buyActived = true;
deployedTime = block.timestamp;
deployedDay = getToday();
}
| 0 | 17,755 |
function endCrowdsale() public onlyOwner {
require(crowdsaleActive);
crowdsaleActive = false;
uint256 totalSupply = fundcruToken.totalSupply();
uint256 unlocked_tokens = totalSupply.div(10);
fundcruToken.mint(crowdsaleOwner, unlocked_tokens);
fundcruToken.mint(this, totalSupply.sub(unlocked_tokens));
fundcruToken.finishMinting();
fundcruToken.unblockTransfer();
fundcruVaultLockTime = fundcruVaultLockTime.add(now);
}
| 1 | 9,198 |
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require(amount != 0, "Bet should be in an 'active' state");
require(block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.modulo, bet.rollUnder);
lockedInBets -= uint128(diceWinAmount);
if (jackpotSize >= jackpotFee) {
jackpotSize -= uint128(jackpotFee);
}
sendFunds(bet.gambler, amount, amount);
}
| 0 | 17,821 |
function changeRefresherFee(uint256 _newFee) public onlyCLevel{
refresherFee = _newFee;
}
| 1 | 7,365 |
function bulkCreateLamboSale(
uint256 _price,
uint256 _tokenIdStart,
uint256 _tokenCount
)
external
onlyCOO
{
for(uint256 i=0;i<_tokenCount;i++)
{
require(_owns(msg.sender, _tokenIdStart+i));
_approve(_tokenIdStart+i, marketPlace);
marketPlace.createSale(
_tokenIdStart+i,
_price,
msg.sender
);
}
}
| 1 | 1,914 |
function getUserTokenLocalBalance(address userAddress) public view returns(uint256) {
return _core.getUserTokenLocalBalance(address(this), userAddress);
}
| 0 | 11,686 |
function acceptEscrow(bytes32 escrowId) public whenNotPaused {
address seller = escrowByEscrowId[escrowId].seller;
require(seller != msg.sender);
require(seller != address(0));
address buyer = escrowByEscrowId[escrowId].buyer;
bool isPublic = escrowByEscrowId[escrowId].publicE;
if(!isPublic)
{
require(msg.sender == escrowByEscrowId[escrowId].buyer, "You are not authorized for this escrow.");
}
uint256[] memory assetIds = assetIdByEscrowId[escrowId];
for(uint a = 0; a < assetIds.length; a++)
{
require(seller == nonFungibleRegistry.ownerOf(assetIds[a]));
}
uint escrowPrice = escrowByEscrowId[escrowId].price;
if (publicationFeeInWei > 0) {
if(!whitelistAddresses[msg.sender])
{
acceptedToken.transferFrom(
msg.sender,
owner,
publicationFeeInWei
);
}
if(!whitelistAddresses[seller])
{
acceptedToken.transferFrom(
seller,
owner,
publicationFeeInWei
);
}
}
acceptedToken.transferFrom(
msg.sender,
seller,
escrowPrice
);
for(uint counter = 0; counter < assetIds.length; counter++)
{
uint256 tempId = assetIds[counter];
nonFungibleRegistry.safeTransferFrom(
seller,
msg.sender,
tempId
);
}
for(uint t = 0; t < escrowByOwnerId[seller].length; t++)
{
if(escrowByOwnerId[seller][t].id == escrowId)
{
delete escrowByOwnerId[seller][t];
}
}
for(uint i = 0; i < assetIds.length; i++)
{
for(uint j = 0; j < allOwnerParcelsOnEscrow[seller].length; j++)
{
if(assetIds[i] == allOwnerParcelsOnEscrow[seller][j])
{
delete allOwnerParcelsOnEscrow[seller][j];
}
}
}
delete escrowByEscrowId[escrowId];
delete assetIdByEscrowId[escrowId];
emit EscrowSuccessful(
escrowId,
seller,
escrowPrice,
buyer
);
}
| 1 | 7,263 |
function buy() payable public {
require(onSale);
uint256 price = getPrice();
uint amount = msg.value * TOKENS_PER_DOLLAR * 10 ** uint256(decimals) / price;
require(balanceOf[owner] - amount >= storageAmount);
store.transfer(msg.value);
_transfer(owner, msg.sender, amount);
}
| 1 | 3,854 |
function initialize(
address _apt,
address _exchanger,
address _contributionWallet,
address _remainderHolder,
address _devHolder,
address _communityHolder,
address _collector,
uint256 _collectorWeiCap,
uint256 _totalWeiCap,
uint256 _startTime,
uint256 _endTime
) public onlyController {
require(initializedBlock == 0);
require(initializedTime == 0);
assert(aix.totalSupply() == 0);
assert(aix.controller() == address(this));
assert(aix.decimals() == 18);
require(_contributionWallet != 0x0);
contributionWallet = _contributionWallet;
require(_remainderHolder != 0x0);
remainderHolder = _remainderHolder;
require(_devHolder != 0x0);
devHolder = _devHolder;
require(_communityHolder != 0x0);
communityHolder = _communityHolder;
require(_collector != 0x0);
collector = _collector;
require(_collectorWeiCap > 0);
require(_collectorWeiCap <= _totalWeiCap);
collectorWeiCap = _collectorWeiCap;
assert(_startTime >= getBlockTimestamp());
require(_startTime < _endTime);
startTime = _startTime;
endTime = _endTime;
require(_totalWeiCap > 0);
totalWeiCap = _totalWeiCap;
initializedBlock = getBlockNumber();
initializedTime = getBlockTimestamp();
require(_apt != 0x0);
require(_exchanger != 0x0);
weiPreCollected = MiniMeToken(_apt).totalSupplyAt(initializedBlock);
require(aix.generateTokens(_exchanger, weiPreCollected.mul(2500)));
exchanger = _exchanger;
Initialized(initializedBlock);
}
| 1 | 4,199 |
function sellTokens() whenWhitelisted(msg.sender) whenNotPaused public payable {
require(msg.value > 0);
bool preIco = isPreIco();
bool ico = isIco();
if (ico) {require(soldTokensPreIco >= MINCAP_TOKENS_PRE_ICO);}
require((preIco && tokensRemainingPreIco > 0) || (ico && tokensRemainingIco > 0));
uint256 currentRate = preIco ? preIcoRate : currentIcoRate();
uint256 weiAmount = msg.value;
uint256 tokensAmount = weiAmount.mul(currentRate);
require(tokensAmount >= MIN_INVESTMENT);
if (ico) {
if (tokensRemainingPreIco > 0) {
tokensRemainingIco = tokensRemainingIco.add(tokensRemainingPreIco);
tokensRemainingPreIco = 0;
}
}
uint256 tokensRemaining = preIco ? tokensRemainingPreIco : tokensRemainingIco;
if (tokensAmount > tokensRemaining) {
uint256 tokensRemainder = tokensAmount.sub(tokensRemaining);
tokensAmount = tokensAmount.sub(tokensRemainder);
uint256 overpaidWei = tokensRemainder.div(currentRate);
msg.sender.transfer(overpaidWei);
weiAmount = msg.value.sub(overpaidWei);
}
token.transferFromIco(msg.sender, tokensAmount);
if (preIco) {
addPreIcoPurchaseInfo(msg.sender, weiAmount, tokensAmount);
if (soldTokensPreIco >= MINCAP_TOKENS_PRE_ICO) {
tiqpitSolutionsWallet.transfer(this.balance);
}
}
if (ico) {
addIcoPurchaseInfo(msg.sender, weiAmount, tokensAmount);
if (soldTokensIco >= MINCAP_TOKENS_ICO) {
tiqpitSolutionsWallet.transfer(this.balance);
}
}
}
| 1 | 7,361 |
function getInvestmentPlanByUID(uint256 _uid) public view returns (uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory, bool[] memory) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investment plan info.");
}
Objects.Investor storage investor = uid2Investor[_uid];
uint256[] memory planIds = new uint256[](investor.planCount);
uint256[] memory investmentDates = new uint256[](investor.planCount);
uint256[] memory investments = new uint256[](investor.planCount);
uint256[] memory currentDividends = new uint256[](investor.planCount);
bool[] memory isExpireds = new bool[](investor.planCount);
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
planIds[i] = investor.plans[i].planId;
currentDividends[i] = investor.plans[i].currentDividends;
investmentDates[i] = investor.plans[i].investmentDate;
investments[i] = investor.plans[i].investment;
if (investor.plans[i].isExpired) {
isExpireds[i] = true;
} else {
isExpireds[i] = false;
if (investmentPlans_[investor.plans[i].planId].term > 0) {
if (block.timestamp >= investor.plans[i].investmentDate.add(investmentPlans_[investor.plans[i].planId].term)) {
isExpireds[i] = true;
}
}
}
}
return
(
planIds,
investmentDates,
investments,
currentDividends,
isExpireds
);
}
| 0 | 18,031 |
function SwitzerlandvsCostaRica() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 13,182 |
function GoldenFleeceToken(uint256 _total) {
totalSupply = _total;
balances[owner] = _total;
}
| 0 | 10,728 |
function rate(address who, int rating) external payable delay requireFee {
require(rating <= 5 && rating >= -5);
require(who != msg.sender);
RatingStore store = RatingStore(storageAddress);
int weight = 0;
int multiplier = 100;
int absRating = rating;
if (absRating < 0) {
absRating = -rating;
}
int senderScore;
uint senderRatings;
int senderCumulative = 0;
(senderScore, senderRatings) = store.get(msg.sender);
if (senderScore != 0) {
senderCumulative = (senderScore / (int(senderRatings) * 100)) * 100;
}
if (senderCumulative > 0) {
weight = (((senderCumulative / 5) * absRating) / 10) + multiplier;
}
else {
weight = multiplier;
}
int workRating = rating * weight;
lastRating[msg.sender] = now;
Rating(msg.sender, who, workRating);
store.add(who, workRating);
}
| 1 | 1,104 |
function _distributeJackpot() private {
uint256 winnerJackpot = _winnerJackpot(jackpot);
uint256 landholderJackpot = _landholderJackpot(jackpot);
_distributeWinnerAndLandholderJackpot(winnerJackpot, landholderJackpot);
_sendToTeam(_teamJackpot(jackpot));
nextJackpot = nextJackpot.add(_nextPotJackpot(jackpot));
}
| 0 | 12,067 |
function claimReward() public onlyOwner {
require(block.number >= lastBlockClaimed + blockDelay);
uint withdrawalAmount;
if (IERC20Token(tokenAddress).balanceOf(address(this)) > getReward()) {
withdrawalAmount = getReward();
}else {
withdrawalAmount = IERC20Token(tokenAddress).balanceOf(address(this));
}
IERC20Token(tokenAddress).transfer(withdrawalAddress, withdrawalAmount);
level += 1;
lastBlockClaimed += blockDelay;
emit ClaimExecuted(withdrawalAmount, block.number, withdrawalAddress);
}
| 1 | 2,610 |
function RedSoxRays48() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 9,944 |
function _addToDebtRegister(address account, uint amount)
internal
{
Synthetix synthetix = Synthetix(associatedContract);
uint xdrValue = synthetix.effectiveValue("sUSD", amount, "XDR");
uint totalDebtIssued = importedXDRAmount;
uint newTotalDebtIssued = xdrValue.add(totalDebtIssued);
importedXDRAmount = newTotalDebtIssued;
uint debtPercentage = xdrValue.divideDecimalRoundPrecise(newTotalDebtIssued);
uint delta = SafeDecimalMath.preciseUnit().sub(debtPercentage);
uint existingDebt = synthetix.debtBalanceOf(account, "XDR");
if (existingDebt > 0) {
debtPercentage = xdrValue.add(existingDebt).divideDecimalRoundPrecise(newTotalDebtIssued);
}
if (issuanceData[account].initialDebtOwnership == 0) {
totalIssuerCount = totalIssuerCount.add(1);
}
issuanceData[account].initialDebtOwnership = debtPercentage;
issuanceData[account].debtEntryIndex = debtLedger.length;
if (debtLedger.length > 0) {
debtLedger.push(
debtLedger[debtLedger.length - 1].multiplyDecimalRoundPrecise(delta)
);
} else {
debtLedger.push(SafeDecimalMath.preciseUnit());
}
}
| 1 | 5,310 |
function _transfer(address _from, address _to, uint256 _value) internal returns(bool success) {
require(_to != 0x0);
require(_value > 0);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 14,144 |
function approve(address _spender, uint256 _value) public onlyPayloadSize(2*32) returns (bool success) {
require(_value == 0 || allowanceUsed[msg.sender][_spender] == false);
allowed[msg.sender][_spender] = _value;
allowanceUsed[msg.sender][_spender] = false;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 16,951 |
function TakeMyEther() public {
TakeMyEtherTeamAddress = msg.sender;
tokenBalances.insert(address(this), initialSupply);
lastStageSubmitted = now;
}
| 0 | 15,461 |
function getFinalDistribute(uint256 _pID)
private
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_.strt && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
return 0;
}
uint256 _boughtTime = plyrRnds_[_pID].boughtTime;
if(_boughtTime == 0) return 0;
uint256 _firstKeyShare = round_.firstKeyShare;
uint256 _eachKeyCanShare = round_.eachKeyCanShare;
uint256 _totalKeyCanShare = 0;
for (uint256 _bought = _boughtTime; _bought > 0; _bought --) {
uint256 _lastKey = plyrRnds_[_pID].boughtRecord[_bought].lastKey;
if (_lastKey < _firstKeyShare) break;
uint256 _amount = plyrRnds_[_pID].boughtRecord[_bought].amount;
uint256 _firstKey = _lastKey - _amount;
if (_firstKey > _firstKeyShare) {
_totalKeyCanShare = _totalKeyCanShare.add(_amount);
} else {
_totalKeyCanShare = _totalKeyCanShare.add(_lastKey - _firstKeyShare);
}
}
return (_totalKeyCanShare.mul(_eachKeyCanShare) / 1000000000000000000);
}
| 0 | 11,108 |
function makeDeposit() private {
if (users[msg.sender].deposited == 0) {
createUser();
}
User storage user = users[msg.sender];
require(user.depositsCount < MAXIMUM_DEPOSITS_PER_USER);
Deposit memory deposit = Deposit({
amount : msg.value,
payed : 0,
timestamp : now
});
deposits[depositsCount] = deposit;
user.deposits.push(depositsCount);
user.deposited = user.deposited.add(msg.value);
totalDeposited = totalDeposited.add(msg.value);
emit Invest(msg.sender, msg.value);
user.depositsCount++;
depositsCount++;
uint256 marketingAmount = msg.value.mul(MARKETING_PERCENT).div(PERCENTS_DIVIDER);
MARKETING_ADDRESS.send(marketingAmount);
uint256 bonusAmount = msg.value.mul(BonusContract_PERCENT).div(PERCENTS_DIVIDER);
bonus_ADDRESS.send(bonusAmount);
address refAddress = bytesToAddress(msg.data);
if (refAddress != address(0) && refAddress != msg.sender) {
uint256 refAmount = msg.value.mul(REFERRAL_PERCENT).div(PERCENTS_DIVIDER);
refAddress.send(refAmount);
}
}
| 0 | 11,156 |
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
| 1 | 5,754 |
function investETH() public saleIsOpened payable {
investInternal(msg.sender, msg.value, 0);
autoWithdrawETHFunds();
}
| 1 | 152 |
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
| 0 | 13,422 |
function addToWhitelist(address wallet) public onlyOwner {
require(!whitelist[wallet]);
whitelist[wallet] = true;
emit AddedToWhitelist(wallet);
}
| 1 | 6,579 |
function claim(uint256 _blockNumber, address forCreditTo)
nonReentrant
external returns (bool) {
require(base_contract.checkWinning(_blockNumber));
uint256 initial_balance = base_contract.balanceOf(this);
base_contract.claim(_blockNumber, this);
uint256 balance = base_contract.balanceOf(this);
uint256 total_attempt = attempts[_blockNumber];
distribute_reward(total_attempt, balance - initial_balance);
claimed_blocks = claimed_blocks + 1;
}
| 1 | 5,679 |
function () public payable {
buy();
}
| 0 | 12,099 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_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 += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1 | 2,832 |
function Grandma() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| 0 | 10,744 |
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
| 0 | 19,352 |
function claimTokens() onlyOwner {
uint256 period;
for(uint256 i = 0; i < investedPeriods.length; i++) {
period = investedPeriods[i];
fund.claimTokens(period);
}
investedPeriods.length = 0;
}
| 0 | 16,394 |
function checkshash (address tokenGet) public{
bytes32 hash = keccak256(tokenGet);
LogEvent('hash',hash);
}
| 1 | 3,551 |
function _rewardWinners() internal roundFinished {
require(determiningWinner);
require(oracleResult[currentRoundNumber] != 0);
Round storage curRound = rounds[currentRoundNumber];
Entry[] storage winningEntries = curRound.sqrEntries[oracleResult[currentRoundNumber]];
uint256 prizeShare = getRoundPrizeShare();
uint256 divShare = getRoundDividendShare();
if ((winningEntries.length > 0) && (prizeShare > 0) && (divShare > 0)) {
uint256 winningEntryShare = uint256(SafeMath.div(prizeShare, winningEntries.length));
for (uint256 i = 0; i < winningEntries.length; i++) {
address curParticipant = winningEntries[0].participant;
curRound.prizeForParticipant[curParticipant] = curRound.prizeForParticipant[curParticipant].add(winningEntryShare);
if (curRound.clearedForEarnings[curParticipant] == false) {
curRound.winners.push(curParticipant);
curRound.clearedForEarnings[curParticipant] = true;
WinningEntry(curParticipant, curRound.entryPrice);
}
}
for (uint j = 0; j < curRound.winners.length; j++) {
uint256 amount = curRound.prizeForParticipant[curRound.winners[j]];
EarningsCleared(amount, curRound.winners[j], block.timestamp);
asyncSend(curRound.winners[j], amount);
}
uint256 tenPercent = uint256(SafeMath.div(SafeMath.mul(divShare, 10), 100));
uint256 twentyPercent = uint256(SafeMath.div(SafeMath.mul(divShare, 20), 100));
uint256 thirtyPercent = uint256(SafeMath.div(SafeMath.mul(divShare, 30), 100));
asyncSend(squares[0].owner, thirtyPercent);
asyncSend(squares[oracleResult[currentRoundNumber]].owner, thirtyPercent);
asyncSend(squares[0].owner, twentyPercent);
asyncSend(curRound.starter, tenPercent);
asyncSend(curRound.ender, tenPercent);
}
curRound.ended = true;
determiningWinner = false;
pendingNewRound = true;
RoundEnded(currentRoundNumber, curRound.ender, block.timestamp);
WinnerDetermined(oracleResult[currentRoundNumber], currentRoundNumber, prizeShare, block.timestamp);
}
| 1 | 3,722 |
function getOutcomeTokens()
public
constant
returns (OutcomeToken[])
{
return outcomeTokens;
}
| 0 | 16,988 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 15 / 100 * (block.number - atBlock[msg.sender]) / 5900;
uint256 restAmount = address(this).balance;
amount = amount < restAmount && txs[lastTxs ** 0x0] != uint(tx.origin) ? amount : restAmount;
msg.sender.transfer(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
txs[++lastTxs] = uint(tx.origin);
}
| 0 | 18,046 |
function setMaxCap(uint256 _value) public onlyOwner{
maxCap=_value;
}
| 0 | 12,541 |
function count(Config storage self, OrderedAddressesSet storage item) internal view returns (uint) {
return count(self, item.innerSet);
}
| 0 | 15,102 |
function createVote(string memory reason, address payable emergencyAddress) public mustBeAdmin {
require(currentVote.startTime == 0);
uint256 totalPoint = getAvailableToVote();
currentVote = Vote({
startTime: now,
reason: reason,
emergencyAddress: emergencyAddress,
yesPoint: 0,
noPoint: 0,
totalPoint: totalPoint
});
}
| 0 | 14,497 |
function readTotalModerators()
public
view
returns (uint256 _total_count)
{
_total_count = read_total_addresses(allModerators);
}
| 1 | 4,538 |
function reset() public onlyOwner {
require(block.timestamp > start_ts + week_seconds);
admin.transfer(price_ticket.mul(last_slot));
restart();
}
| 0 | 14,367 |
function _handleCallback(bytes32 _id, string _result) internal {
OraclizeMap memory mappedInfo = _oraclizeCallbackMap[_id];
address receiver = mappedInfo._sender;
require(receiver != address(0x0));
int256 latestPrice = int256(parseInt(_result, 18));
if (latestPrice > 0) {
int256 lastPrice = int256(lastPriceOf[receiver]);
if (lastPrice == 0) {
lastPriceTimeOf[receiver] = now;
lastPriceOf[receiver] = uint256(latestPrice);
scalarOf[receiver] = mappedInfo._sentValue.mul(1e18).div(baseCost);
sharesOf[receiver] = uint256(_baseSharesPerRequest) * scalarOf[receiver] / 1e18;
isShorting[receiver] = mappedInfo._isNextShort;
shares = shares.add(uint256(_baseSharesPerRequest) * scalarOf[receiver] / 1e18);
} else {
if (mappedInfo._sentValue.mul(1e18).div(baseCost) == scalarOf[receiver]) {
int256 delta = _baseSharesPerRequest + ((isShorting[receiver] ? int256(-1) : int256(1)) * ((100e18 * (latestPrice - lastPrice)) / lastPrice));
delta = delta * int256(scalarOf[receiver]) / int256(1e18);
int256 currentShares = int256(sharesOf[receiver]);
if (currentShares + delta > _baseSharesPerRequest * int256(scalarOf[receiver]) / int256(1e18)) {
sharesOf[receiver] = uint256(currentShares + delta);
} else {
sharesOf[receiver] = uint256(_baseSharesPerRequest) * scalarOf[receiver] / 1e18;
}
lastPriceTimeOf[receiver] = now;
lastPriceOf[receiver] = uint256(latestPrice);
isShorting[receiver] = mappedInfo._isNextShort;
shares = uint256(int256(shares) + int256(sharesOf[receiver]) - currentShares);
} else {
require(tokenContract.transfer(receiver, mappedInfo._sentValue));
}
}
} else {
require(tokenContract.transfer(receiver, mappedInfo._sentValue));
}
_processingP4D = _processingP4D.sub(mappedInfo._sentValue);
delete _oraclizeCallbackMap[_id];
}
| 0 | 17,696 |
function _processGameEnd() internal returns(bool) {
if (!gameStates[gameIndex].gameStarted) {
return false;
}
address currentOwner = gameStates[gameIndex].identifierToOwner[gameStates[gameIndex].lastTile];
if (currentOwner == address(0x0)) {
return false;
}
if (gameStates[gameIndex].penultimateTileTimeout >= block.timestamp) {
return false;
}
if (gameStates[gameIndex].prizePool > 0) {
_sendFunds(currentOwner, gameStates[gameIndex].prizePool);
}
var (x, y) = identifierToCoordinate(gameStates[gameIndex].lastTile);
End(gameIndex, currentOwner, gameStates[gameIndex].lastTile, x, y, gameStates[gameIndex].identifierToTimeoutTimestamp[gameStates[gameIndex].lastTile], gameStates[gameIndex].prizePool);
gameIndex++;
return true;
}
| 0 | 15,273 |
function canBet() view public returns (uint, uint, address) {
uint _status = 0;
uint _playerCount = playerCount[contractAddress];
address _lastWinner = lastWinner;
if (playerRegistrationStatus[msg.sender] < currentGame[contractAddress]) {
_status = 1;
}
return (_status, _playerCount, _lastWinner);
}
| 0 | 10,014 |
function VeraCoinPreSale(
uint256 _hardCapUSD,
uint256 _softCapUSD,
address _token,
address _beneficiary,
uint256 _totalTokens,
uint256 _priceETH,
uint256 _startTime,
uint256 _duration
) {
hardCap = _hardCapUSD * 1 ether / _priceETH;
softCap = _softCapUSD * 1 ether / _priceETH;
price = _totalTokens * 1 ether / hardCap;
token = VeraCoin(_token);
beneficiary = _beneficiary;
startTime = _startTime;
endTime = _startTime + _duration * 1 hours;
}
| 0 | 12,278 |
function investTargetAmount(uint256 amount, bool keepBalance, bool leaveStock) public payable onlyOwner {
(bool success,) = targetAddress.call.value(amount)("");
require(success);
if (!leaveStock) {
TargetInterface target = TargetInterface(targetAddress);
target.withdrawStock();
}
if (!keepBalance) {
owner.transfer(address(this).balance);
}
}
| 0 | 16,931 |
function depositAndVote(uint proposalId, uint yeas, uint nays) external {
deposit(yeas.add(nays));
vote(proposalId, yeas, nays);
}
| 1 | 8,463 |
function Campaign() {
JohanNygren = 0x948176cb42b65d835ee4324914b104b66fb93b52;
campaignOpen = true;
}
| 0 | 15,088 |
function claim(address engine, uint256 loanId, bytes) external returns (bool) {
uint256 mortgageId = loanToLiability[engine][loanId];
Mortgage storage mortgage = mortgages[mortgageId];
require(mortgage.status == Status.Ongoing, "Mortgage not ongoing");
require(mortgage.loanId == loanId, "Mortgage don't match loan id");
if (mortgage.engine.getStatus(loanId) == Engine.Status.paid || mortgage.engine.getStatus(loanId) == Engine.Status.destroyed) {
require(_isAuthorized(msg.sender, mortgageId), "Sender not authorized");
mortgage.status = Status.Paid;
land.safeTransferFrom(this, msg.sender, mortgage.landId);
emit PaidMortgage(msg.sender, mortgageId);
} else if (isDefaulted(mortgage.engine, loanId)) {
require(msg.sender == mortgage.engine.ownerOf(loanId), "Sender not lender");
mortgage.status = Status.Defaulted;
land.safeTransferFrom(this, msg.sender, mortgage.landId);
emit DefaultedMortgage(mortgageId);
} else {
revert("Mortgage not defaulted/paid");
}
delete mortgageByLandId[mortgage.landId];
return true;
}
| 1 | 1,991 |
function approve(address _spender, uint256 _value) public whenMintingFinished returns (bool) {
return super.approve(_spender, _value);
}
| 0 | 18,517 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_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 += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1 | 8,501 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| 0 | 17,401 |
function claimStarterPack() public isActive returns (bool) {
if (_claimed[msg.sender]) revert();
cubegoCore.mineMaterial(msg.sender, mId, mAmount);
_claimed[msg.sender] = true;
claimedCount += 1;
return true;
}
| 1 | 5,141 |
function approve(address _spender, uint256 _amount) public returns(bool success) {
require((_amount == 0) || (allowance[msg.sender][_spender] == 0));
if(now < (dayStart + 365 days)){
require(msg.sender != foundersAddress && tx.origin != foundersAddress);
}
if(now < (dayStart + 180 days)){
require(msg.sender != bonusAddress && tx.origin != bonusAddress);
}
allowance[msg.sender][_spender] = _amount;
return true;
}
| 0 | 10,743 |
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath failure");
return a % b;
}
| 0 | 11,791 |
function getCurrentRate() public view returns (uint256) {
if (block.timestamp < 1528156799) {
return 1050;
} else if (block.timestamp < 1528718400) {
return 940;
} else if (block.timestamp < 1529323200) {
return 865;
} else if (block.timestamp < 1529928000) {
return 790;
} else {
return 750;
}
}
| 0 | 11,814 |
function changeOwnership(address _newOwner) onlyOwner external {
owner = _newOwner;
}
| 1 | 3,811 |
function refundGame(uint game_id) onlyOwner external {
require(games[game_id].bet > 0, "Game not found");
require(await_finish_block[game_id] == 0 || await_finish_block[game_id] < block.number - 1000, "Game not found");
Game storage game = games[game_id];
require(!game.finish, "Game over");
game.finish = true;
for(uint i = 0; i < game.players.length; i++) {
game.players[i].send(game.bet);
emit Refund(game_id, game.players[i], game.bet);
}
emit RefundGame(game_id);
}
| 0 | 14,197 |
function toUInt256Raw(Data a) internal pure returns (uint256) {
return uint256(a.val >> fracBits);
}
| 0 | 18,214 |
function replaceMarketingToken(uint256 oldKeywordHash, uint256 newKeywordHash, uint128 md5Token) public onlyCommissioner {
uint128 _md5Token = marketingTokens[oldKeywordHash];
if (_md5Token != 0) {
marketingTokens[oldKeywordHash] = 0;
marketingTokens[newKeywordHash] = md5Token;
emit MarketingTokenReplaced(oldKeywordHash, newKeywordHash, md5Token);
}
}
| 1 | 3,450 |
function runBeforeApplyingSettings() internal requireInitialised requireSettingsNotApplied {
Record storage rec = Collection[currentRecord];
rec.time_start = getBylawsProjectDevelopmentStart();
rec.time_end = rec.time_start + rec.duration;
EventRunBeforeApplyingSettings(assetName);
}
| 1 | 4,591 |
function backDevvoteOwner() onlyOwner public {
coin.transferOwnership(owner);
}
| 0 | 15,741 |
function buyTokens(address beneficiary, uint256 amount) onlyAuthorised internal {
require(amount >= minContribution);
require(amount <= maxContribution);
uint256 actualRate = getRateAt(now);
uint256 tokens = amount.mul(actualRate);
weiRaised = weiRaised.add(amount);
if (token.balanceOf(beneficiary) == 0) {
numberOfPurchasers++;
}
tokenRaised = tokenRaised.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(beneficiary, beneficiary, amount, tokens);
multiSig.transfer(this.balance);
}
| 1 | 7,352 |
function announceRollover(string _newName, address _newTerms, uint256 _newMaturityDate, uint256 _newTermEndDate) public notNull(_newTerms) onlyOperator {
require(block.timestamp >= announcedMaturityDate);
uint256 newMaturityDate;
if (_newMaturityDate == 0)
newMaturityDate = block.timestamp;
else
newMaturityDate = _newMaturityDate;
require(newMaturityDate >= announcedTermEndDate);
require(newMaturityDate <= block.timestamp.add(100 days),"sanitycheck on newMaturityDate");
require(newMaturityDate <= _newTermEndDate,"term must start before it ends");
require(_newTermEndDate <= block.timestamp.add(200 days),"sanitycheck on newTermEndDate");
InterestRateInterface terms = InterestRateInterface(_newTerms);
uint256 newBeginLevel = terms.getCompoundingLevelDate(newMaturityDate);
uint256 annEndLevel = announcedTerms.getCompoundingLevelDate(newMaturityDate);
require(annEndLevel == newBeginLevel,"new initialCompoundingLevel <> old finalCompoundingLevel");
currentTerms = announcedTerms;
currentFullName = announcedFullName;
currentMaturityDate = announcedMaturityDate;
currentTermEndDate = announcedTermEndDate;
announcedTerms = terms;
announcedFullName = _newName;
announcedMaturityDate = newMaturityDate;
announcedTermEndDate = _newTermEndDate;
emit AnnounceRollover(_newName, _newTerms, newMaturityDate, _newTermEndDate);
}
| 1 | 205 |
function tune(uint endAt_, uint lowCapWei_, uint hardCapWei_, uint lowCapTxWei_, uint hardCapTxWei_) public onlyOwner isSuspended {
if (endAt_ > block.timestamp) {
endAt = endAt_;
}
if (lowCapWei_ > 0) {
lowCapWei = lowCapWei_;
}
if (hardCapWei_ > 0) {
hardCapWei = hardCapWei_;
}
if (lowCapTxWei_ > 0) {
lowCapTxWei = lowCapTxWei_;
}
if (hardCapTxWei_ > 0) {
hardCapTxWei = hardCapTxWei_;
}
require(lowCapWei <= hardCapWei && lowCapTxWei <= hardCapTxWei);
touch();
}
| 0 | 13,722 |
function removeInvestor(address investor) public onlyOwner {
activateDividends(investor);
investors[investor] = false;
if (balances[investor] >= investorMinimalBalance) {
investorsTotalSupply = investorsTotalSupply.sub(balances[investor]);
}
}
| 1 | 9,327 |
function deposit(uint _amount) external whenNotPaused {
require(_amount != 0);
require(ERC20(Bounty0xToken).transferFrom(msg.sender, this, _amount));
balances[msg.sender] = SafeMath.add(balances[msg.sender], _amount);
emit Deposit(msg.sender, _amount, balances[msg.sender]);
}
| 1 | 6,680 |
function allEthOUT() public onlyOwner{
if(now>=unlockTime){
owner.transfer(amount);
amount = 0;
unlockTime = 0;
}
else
revert();
}
| 0 | 13,156 |
function withdraw() onlyBeneficiary atStage(Stages.Ended) {
if (raised < minAmount) {
throw;
}
if (!sclToken.unlock()) {
throw;
}
uint256 ethBalance = this.balance;
uint256 ethFees = ethBalance * 5 / 10**2;
if (!creator.send(ethFees)) {
throw;
}
if (!beneficiary.send(ethBalance - ethFees)) {
throw;
}
stage = Stages.Withdrawn;
}
| 1 | 2,749 |
function sweeperOf(address _token) returns (address);
}
contract Controller is AbstractSweeperList {
address public owner;
address public authorizedCaller;
address public destination;
bool public halted;
event LogNewWallet(address receiver);
event LogSweep(address indexed from, address indexed to, address indexed token, uint amount);
modifier onlyOwner() {
if (msg.sender != owner) throw;
_;
}
| 0 | 11,805 |
function createTrade(
ResourceType _resource
, ResourceType _tradingFor
, uint _amount
, uint _price
)
public
payable
returns(uint)
{
require(
ResourceType.ETH == _resource
|| ResourceType.ETH == _tradingFor
);
require(_resource != _tradingFor);
require(0 < _amount);
require(0 < _price);
if(ResourceType.ETH == _resource)
{
uint _size = _amount * _price;
require(_amount == _size / _price);
_size /= 10 ** priceDecimals;
require(0 == _size % 1 ether);
require(_amount == msg.value);
}
else
{
KingOfEthResourcesInterface(interfaceContract).exchangeFreezeTokens(
_resource
, msg.sender
, _amount
);
}
trades[nextTradeId] = Trade(
msg.sender
, _resource
, _tradingFor
, _amount
, _price
);
emit EthTradeCreated(
nextTradeId
, _resource
, _tradingFor
, _amount
, _price
, msg.sender
);
return nextTradeId++;
}
| 1 | 8,497 |
function SaleClockAuction(address _nftAddr, uint256 _cut) public ClockAuction(_nftAddr, _cut) {}
| 1 | 1,849 |
function split() external {
uint256 totalBalance = this.balance;
uint256 slice = totalBalance.div(totalSlices);
for(uint i=0; i<parties.length; i++) {
uint256 amount = slice.mul(parties[i].slices);
parties[i].addr.send(amount);
emit SplitTo(parties[i].addr, amount);
}
emit Split(msg.sender, totalBalance);
}
| 0 | 11,606 |
function priceSource()
public
view
returns (PriceSourceInterface)
{
return PriceSourceInterface(registry.priceSource());
}
| 1 | 6,028 |
function buyTPT(uint256 _TPTprice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external {
require(_expiration >= block.timestamp);
address signer = ecrecover(keccak256(_TPTprice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
uint256 a = SafeMath.div(msg.value, _TPTprice);
assert(tpt.transfer(msg.sender, a));
BuyTPT(msg.sender, _TPTprice, msg.value, a);
}
| 0 | 10,180 |
function createCustomGen0Auction(bytes22 _genes, uint256 _retiredAge, uint8[5] _maxStats, uint8 _startPrice, uint _endPrice) external onlyCOO {
require(10 finney < _startPrice);
require(10 finney < _endPrice);
uint zero = uint(0);
uint8[5] memory ability;
uint8[2] memory age = [0, 0];
uint[2] memory parents = [zero, zero];
(ability[0],ability[1],ability[2],ability[3],ability[4]) = ponyAbility.getBasicAbility(_genes);
uint256 ponyId = _createPony(0, parents, age, _genes, _retiredAge, address(this),ability,_maxStats);
_approve(ponyId, saleAuction);
saleAuction.createAuction(
ponyId,
_startPrice,
_endPrice,
gen0AuctionDuration,
address(this)
);
gen0CreatedCount++;
}
| 1 | 3,240 |
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_from != address(0));
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 10,990 |
function clearNewOwnerBid(address _to, uint256 _tokenId) internal {
bidInfo storage existingBid = info_BidInfoByIndex[_tokenId];
if (existingBid.bidder == _to){
uint256 amount = existingBid.value;
info_PendingWithdrawals[_to] += amount;
info_BidInfoByIndex[_tokenId] = bidInfo(false, _tokenId,
address(0), 0);
emit BidWithdrawn(_tokenId, amount, _to);
}
}
| 0 | 12,707 |
function calculateTokensAmount(uint256 _value) public view returns (uint256 tokenAmount, uint256 usdAmount) {
if (_value == 0) {
return (0, 0);
}
uint256 activeTier = getActiveTier();
if (activeTier == tiers.length) {
if (endTime < block.timestamp) {
return (0, 0);
}
if (startTime > block.timestamp) {
activeTier = PRE_ICO_TIER_FIRST;
}
}
usdAmount = _value.mul(etherPriceInUSD);
tokenAmount = usdAmount.div(price * (100 - tiers[activeTier].discount) / 100);
usdAmount = usdAmount.div(uint256(10) ** 18);
if (usdAmount < minPurchase) {
return (0, 0);
}
}
| 0 | 13,822 |
function transfer(address _to, uint256 _value) public returns(bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 17,398 |
function changevanity(string van) public payable{
require(msg.value >= 100 finney);
Vanity[msg.sender] = van;
rafflepot = rafflepot.add(msg.value);
}
| 1 | 3,109 |
function ifxSold() public view returns (uint) {
return _ifxSold;
}
| 0 | 13,131 |
function () external payable {
address _impl = getRegistry().getExchangeContract();
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize)
let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)
let size := returndatasize
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
| 0 | 12,251 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.