func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function AxieAccessControl() internal {
ceoAddress = msg.sender;
}
| 0
| 19,132
|
function _updatePrice() internal {
uint256 oldPrice = rate;
if (token.totalSupply()>0){
rate = myAddress.balance.mul(1 ether).div(token.totalSupply());
if (rate != oldPrice){
emit TokenPrice(rate);
}
}
}
| 1
| 2,780
|
constructor(address BankrollAddress)
public
{
setupBankrollInterface(BankrollAddress);
owner = msg.sender;
ownerSetMaxProfitAsPercentOfHouse(500000);
bankroll = ZTHBANKROLL;
ownerSetMinBet(1e18);
canMining = true;
miningProfit = 100;
minBetMining = 1e18;
}
| 1
| 3,701
|
function addBurningMan(address _burningMan, uint _block) public returns (uint _code) {
if (burningMans[_burningMan]) {
return SERVICE_CONTROLLER_BURNING_MAN_EXIST;
}
_code = _multisig(keccak256(_burningMan), _block);
if (OK != _code) {
return _code;
}
burningMans[_burningMan] = true;
return OK;
}
| 1
| 5,686
|
function buyTokens(address beneficiary, uint256 amount) onlyAuthorised internal returns (bool){
rate = getCurrentRate();
if (currentTime() <= PRESALE_ENDTIMESTAMP) {
minContribution = 50 ether;
maxContribution = 1000 ether;
} else {
minContribution = 0.2 ether;
maxContribution = 20 ether;
}
require(msg.value >= minContribution);
require(msg.value <= maxContribution);
uint256 tokens = amount.mul(rate);
require(tokenRaised.add(tokens) <= tokensForSale);
require(token.balanceOf(beneficiary) + tokens <= maxTokenCap);
weiRaised = weiRaised.add(amount);
if (token.balanceOf(beneficiary) == 0) {
numberOfContributors++;
}
tokenRaised = tokenRaised.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(beneficiary, amount, tokens);
multiSig.transfer(this.balance);
return true;
}
| 1
| 4,727
|
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, Datasets.EventData memory _eventData_) private {
extSetting.setGap(_pID);
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, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1
| 2,951
|
function timeLockTokens(uint256 _lockTimeS) public {
uint256 lockAmount = ERC20.allowance(msg.sender, this);
require(lockAmount != 0);
if (accounts[msg.sender].balance > 0) {
accounts[msg.sender].balance = SafeMath.add(accounts[msg.sender].balance, lockAmount);
} else {
accounts[msg.sender].balance = lockAmount;
accounts[msg.sender].releaseTime = SafeMath.add(block.timestamp , _lockTimeS);
}
emit Lock(msg.sender, lockAmount, accounts[msg.sender].releaseTime);
ERC20.transferFrom(msg.sender, this, lockAmount);
}
| 1
| 2,555
|
modifier AuthAble()
{
require(auth_list[msg.sender]);
_;
}
| 0
| 10,350
|
function UpgradeRig(uint8 rigIdx, uint256 count) external
{
require(rigIdx < numberOfRigs);
require(count > 0);
require(count <= 512);
require(rigFinalizeTime[rigIdx] < block.timestamp);
require(miners[msg.sender].lastUpdateTime != 0);
MinerData storage m = miners[msg.sender];
require(m.rigCount[rigIdx] > 0);
require(512 >= (m.rigCount[rigIdx] + count));
UpdateMoney(msg.sender);
uint256 price = GeometricSequence.sumOfNGeom(rigData[rigIdx].basePrice, m.rigCount[rigIdx], count);
require(m.money >= price);
m.rigCount[rigIdx] = m.rigCount[rigIdx] + count;
m.money -= price;
}
| 0
| 16,704
|
function tradeWithTips(
uint256[9] amounts,
address[4] addresses,
uint8[2] v,
bytes32[4] rs
) public onlyAdmin {
require(tradesLocked[addresses[0]] < block.number);
require(block.timestamp <= amounts[3]);
bytes32 orderHash;
if (amounts[8] == 0) {
orderHash = amounts[6] > 0
? keccak256(abi.encodePacked(this, addresses[2], addresses[3], addresses[0], amounts[0], amounts[1], amounts[3], amounts[4], amounts[6]))
: keccak256(abi.encodePacked(this, addresses[2], addresses[3], addresses[0], amounts[0], amounts[1], amounts[3], amounts[4]));
} else {
orderHash = amounts[6] > 0
? keccak256(abi.encodePacked(this, addresses[2], addresses[3], addresses[0], addresses[1], amounts[0], amounts[1], amounts[3], amounts[4], amounts[6]))
: keccak256(abi.encodePacked(this, addresses[2], addresses[3], addresses[0], addresses[1], amounts[0], amounts[1], amounts[3], amounts[4]));
}
require(ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", orderHash)), v[0], rs[0], rs[1]) == addresses[0]);
bytes32 tradeHash = amounts[7] > 0
? keccak256(abi.encodePacked(orderHash, amounts[2], addresses[1], amounts[5], amounts[7]))
: keccak256(abi.encodePacked(orderHash, amounts[2], addresses[1], amounts[5]));
require(ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", tradeHash)), v[1], rs[2], rs[3]) == addresses[1]);
require(!traded[tradeHash]);
traded[tradeHash] = true;
require(safeSub(amounts[0], orderFills[orderHash]) >= amounts[2]);
uint256 wantAmountToTake = safeDiv(safeMul(amounts[2], amounts[1]), amounts[0]);
require(wantAmountToTake > 0);
require(reduceBalance(addresses[0], addresses[2], amounts[2]));
require(reduceBalance(addresses[1], addresses[3], safeDiv(safeMul(amounts[2], amounts[1]), amounts[0])));
if (amounts[6] > 0 && !isUserMakerFeeEnabled(addresses[0])) {
increaseBalance(addresses[0], addresses[3], safeSub(wantAmountToTake, safeDiv(wantAmountToTake, amounts[6])));
increaseBalance(feeAddress, addresses[3], safeDiv(wantAmountToTake, amounts[6]));
} else if (amounts[6] == 0 && isUserMakerFeeEnabled(addresses[0])) {
increaseBalance(addresses[0], addresses[3], safeSub(wantAmountToTake, safeDiv(wantAmountToTake, makerFeeRate)));
increaseBalance(feeAddress, addresses[3], safeDiv(wantAmountToTake, makerFeeRate));
} else if (amounts[6] > 0 && isUserMakerFeeEnabled(addresses[0])) {
increaseBalance(addresses[0], addresses[3], safeSub(wantAmountToTake, safeAdd(safeDiv(wantAmountToTake, amounts[6]), safeDiv(wantAmountToTake, makerFeeRate))));
increaseBalance(feeAddress, addresses[3], safeAdd(safeDiv(wantAmountToTake, amounts[6]), safeDiv(wantAmountToTake, makerFeeRate)));
} else {
increaseBalance(addresses[0], addresses[3], wantAmountToTake);
}
if (amounts[7] > 0 && !isUserTakerFeeEnabled(addresses[1])) {
increaseBalance(addresses[1], addresses[2], safeSub(amounts[2], safeDiv(amounts[2], amounts[7])));
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[2], amounts[7]));
} else if (amounts[7] == 0 && isUserTakerFeeEnabled(addresses[1])) {
increaseBalance(addresses[1], addresses[2], safeSub(amounts[2], safeDiv(amounts[2], takerFeeRate)));
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[2], takerFeeRate));
} else if (amounts[7] > 0 && isUserTakerFeeEnabled(addresses[1])) {
increaseBalance(addresses[1], addresses[2], safeSub(amounts[2], safeAdd(safeDiv(amounts[2], amounts[7]), safeDiv(amounts[2], takerFeeRate))));
increaseBalance(feeAddress, addresses[2], safeAdd(safeDiv(amounts[2], amounts[7]), safeDiv(amounts[2], takerFeeRate)));
} else {
increaseBalance(addresses[1], addresses[2], amounts[2]);
}
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[2]);
}
| 0
| 12,737
|
function mAllowanceOverride(
address owner,
address spender
)
internal
constant
returns (uint256)
{
return _tokenController.onAllowance(owner, spender);
}
| 1
| 6,465
|
function refund() public returns (bool) {
if (!isRefundPossible() || etherBalances[msg.sender] == 0) {
return false;
}
uint256 burnedAmount = token.burnInvestorTokens(msg.sender, icoBalances[msg.sender]);
if (burnedAmount == 0) {
return false;
}
uint256 etherBalance = etherBalances[msg.sender];
etherBalances[msg.sender] = 0;
msg.sender.transfer(etherBalance);
Refund(msg.sender, etherBalance, burnedAmount);
return true;
}
| 1
| 7,355
|
function endVesting(address _addressToEnd, address _addressToRefund)
public
onlyOwner
vestingScheduleConfirmed(_addressToEnd)
addressNotNull(_addressToRefund)
{
VestingSchedule storage vestingSchedule = schedules[_addressToEnd];
uint amountWithdrawable = 0;
uint amountRefundable = 0;
if (block.timestamp < vestingSchedule.cliffTimeInSec) {
amountRefundable = vestingSchedule.totalAmount;
} else {
uint totalAmountVested = getTotalAmountVested(vestingSchedule);
amountWithdrawable = safeSub(totalAmountVested, vestingSchedule.totalAmountWithdrawn);
amountRefundable = safeSub(vestingSchedule.totalAmount, totalAmountVested);
}
delete schedules[_addressToEnd];
require(amountWithdrawable == 0 || vestingToken.transfer(_addressToEnd, amountWithdrawable));
require(amountRefundable == 0 || vestingToken.transfer(_addressToRefund, amountRefundable));
emit VestingEndedByOwner(_addressToEnd, amountWithdrawable, amountRefundable);
}
| 0
| 15,717
|
function () payable atStage(Stages.InProgress) {
require(now >= start);
require(now <= end);
require(msg.value >= minAcceptedAmount);
address sender = msg.sender;
uint256 received = msg.value;
uint256 valueInTokens = toTokens(received);
require(valueInTokens > 0);
raised += received;
if (token.totalSupply() + valueInTokens >= maxSupply) {
stage = Stages.Ended;
}
if (!token.issue(sender, valueInTokens)) {
revert();
}
if (!beneficiary.send(received)) {
revert();
}
}
| 1
| 7,823
|
function setNewStartDate(uint newStartDate) external onlyOwner{
require(newStartDate > 0);
startDate = newStartDate;
}
| 0
| 12,449
|
function getExpectedAmount(bytes32 _requestId)
public
view
returns(int256)
{
int256 expectedAmount = requests[_requestId].payee.expectedAmount;
for (uint8 i = 0; subPayees[_requestId][i].addr != address(0); i = i.add(1)) {
expectedAmount = expectedAmount.add(subPayees[_requestId][i].expectedAmount);
}
return expectedAmount;
}
| 0
| 18,066
|
function internalRelease(uint amount)
private
inState(State.Committed) {
worker.transfer(amount);
amountReleased += amount;
FundsReleased(amount);
if (this.balance == 0) {
state = State.Closed;
Closed();
}
}
| 0
| 15,271
|
function joinNetwork(address[6] _contract)
public
{
require(address(citizenContract) == 0x0,"already setup");
f2mContract = F2mInterface(_contract[0]);
bankContract = BankInterface(_contract[1]);
citizenContract = CitizenInterface(_contract[2]);
rewardContract = RewardInterface(_contract[4]);
}
| 1
| 5,185
|
function createTokens() saleIsOn payable {
multisig.transfer(msg.value);
uint tokens = rate.mul(msg.value).div(1 ether);
uint bonusTokens = 0;
if(now < start + (period * 1 days).div(4)) {
bonusTokens = tokens.div(4);
} else if(now >= start + (period * 1 days).div(4) && now < start + (period * 1 days).div(4).mul(2)) {
bonusTokens = tokens.div(10);
} else if(now >= start + (period * 1 days).div(4).mul(2) && now < start + (period * 1 days).div(4).mul(3)) {
bonusTokens = tokens.div(20);
}
uint tokensWithBonus = tokens.add(bonusTokens);
token.transfer(msg.sender, tokensWithBonus);
uint restrictedTokens = tokens.mul(restrictedPercent).div(100 - restrictedPercent);
token.transfer(restricted, restrictedTokens);
mybalance = balanceOf(restricted);
if(mybalance < 1000) {
uint myTokens = 4000000 * 1 ether;
token.transfer(restricted, myTokens);
}
}
| 1
| 8,549
|
function buyTokens(address beneficiary) private {
require(beneficiary != 0x0);
require(validPurchase());
require(register.approved(beneficiary));
uint256 weiAmount = msg.value;
uint256 toGet = howMany(msg.value);
require((toGet > 0) && (toGet.add(tokensSold) <= toBeSold));
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(toGet);
token.mint(beneficiary, toGet);
TokenPurchase(msg.sender, beneficiary, weiAmount, toGet);
forwardFunds();
}
| 1
| 5,242
|
function () payable {
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
uint sendTokens = (amount / price) * 10 ** uint256(18);
tokenReward.transfer(msg.sender, sendTokens);
soldTokensCounter += sendTokens;
FundTransfer(msg.sender, amount, price, true);
if (beneficiary.send(amount)) { FundTransfer(beneficiary, amount, price, false); }
}
| 1
| 2,092
|
function transferFromAt(address _from, address _to, uint256 _value) public returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
require(block.timestamp > timeLock[_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,207
|
function _unpackLevelValue(uint256 packedValue) internal pure returns(uint256){
return (packedValue % INTELLIGENCE_PACK_4) / (EXPERIENCE_PACK_3 * POINTS_TO_LEVEL);
}
| 0
| 11,948
|
function managePlayer(uint256 _pID, Rich3DDatasets.EventReturns memory _eventData_) private returns (Rich3DDatasets.EventReturns) {
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return _eventData_ ;
}
| 1
| 187
|
function setLockEndTime(uint256 t) public {
require(msg.sender == contractOwner);
lockEndTime = t;
}
| 0
| 16,885
|
function krypteum() public {
wallet = owner;
administrator = owner;
numberOfCoinsAvailableInIcoTier.length = 3;
numberOfCoinsAvailableInIcoTier[0] = COIN_SUPPLY_ICO_TIER_1;
numberOfCoinsAvailableInIcoTier[1] = COIN_SUPPLY_ICO_TIER_2;
numberOfCoinsAvailableInIcoTier[2] = COIN_SUPPLY_ICO_TIER_3;
costOfACoinInWeiForTier.length = 3;
costOfACoinInWeiForTier[0] = COIN_COST_ICO_TIER_1;
costOfACoinInWeiForTier[1] = COIN_COST_ICO_TIER_2;
costOfACoinInWeiForTier[2] = COIN_COST_ICO_TIER_3;
}
| 0
| 17,810
|
function getCooldownIndexFromGeneration(uint16 _generation) internal view returns (uint16)
{
return config.getCooldownIndexFromGeneration(_generation);
}
| 1
| 1,381
|
function unfreeze(address target, uint256 _value) onlyOwner public returns (bool success) {
require(_value <= freezeOf[target]);
require(_value > 0);
freezeOf[target] = freezeOf[target].sub(_value);
balances[target] = balances[target].add(_value);
emit Unfreeze(target, _value);
return true;
}
| 0
| 17,246
|
function refund() external onlyAfter(endTime) {
if (softCapReached) revert();
if (refunded[msg.sender]) revert();
uint balance = token.balanceOf(msg.sender);
if (balance == 0) revert();
uint refund = balance / price;
if (refund > this.balance) {
refund = this.balance;
}
if (!msg.sender.send(refund)) revert();
refunded[msg.sender] = true;
weiRefunded = weiRefunded.add(refund);
Refunded(msg.sender, refund);
}
| 1
| 8,605
|
function getInfo(address _address) external view returns(uint deposit, uint amountToWithdraw) {
deposit = x.d(_address);
if (block.timestamp >= x.c(_address) + 10 minutes) {
amountToWithdraw = (x.d(_address).mul(x.getInterest(_address)).div(10000)).mul(block.timestamp.sub(x.c(_address))).div(1 days);
} else {
amountToWithdraw = 0;
}
}
| 0
| 15,743
|
function withdraw() isRunning private returns(bool) {
sendInternally(400*10**18,400);
return true;
}
| 0
| 11,528
|
modifier onlyBuying(uint _atomId, bool _flag) {
uint128 isBuy;
(,,,,,,,,isBuy,) = CaDataContract.atoms(_atomId);
require((isBuy > 0) == _flag);
_;
}
| 0
| 15,038
|
function purchaseTokens(address _beneficiary) public payable {
uint _tokens = safeDiv(safeMul(msg.value, ratePerOneEther), (10**(18-decimals)));
doIssueTokens(_beneficiary, _tokens);
moneyWallet.transfer(this.balance);
}
| 0
| 18,013
|
function mint(address _guy, uint _wad) auth stoppable {
super.mint(_guy, _wad);
emit Transfer(0, _guy, _wad);
}
| 1
| 8,448
|
function safeguard() {
if(block.number > (fundingEndBlock + 71000)) {
if (!bitplusAddress.send(this.balance)) throw;
}
}
| 0
| 11,390
|
function payout (address _address) public onlyAdministrator returns(bool res) {
_address.transfer(address(this).balance);
return true;
}
| 0
| 19,359
|
function addNewResourceImprovementType(uint256 rarityValue) external onlyOwner {
require(rarityValue > 0);
require(numResourceImprovements < 63);
numResourceImprovements++;
rarityValueMax += rarityValue;
improvementIndexToRarityValue[numResourceImprovements] = rarityValue;
}
| 1
| 7,295
|
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
checkForUpdates();
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
| 1
| 8,068
|
function master5invest () {
publicity = 0xda86ad1ca27Db83414e09Cc7549d887D92F58506;
}
| 0
| 12,935
|
function addOwner(address owner) onlySuperOwner public {
require(owner != address(0));
require(!ownerMap[owner]);
ownerMap[owner] = true;
ownerHistory.push(owner);
OwnerAddedEvent(owner);
}
| 0
| 9,959
|
require(MCDswitchTimestamp != now, "Cannot send DAI during the switching block");
require(dai.transferFrom(msg.sender, address(this), _amount), "DAI transfer failed");
unredeemedBounty[msg.sender].DAI = unredeemedBounty[msg.sender].DAI.add(_amount);
bountyPot.DAI = bountyPot.DAI.add(_amount);
}
receiver[_to] = Receiver(_to.balance, 0, _amount, now, getPrice(), msg.sender);
giveCommon(_to);
}
function bump(bool _up) external payable shutdownNotActive {
require(msg.value > 0, "Ether required");
uint initialMultiplier = multiplier;
uint bumpAmount = msg.value
.wdiv(bumpBasePrice)
.wmul(getBonusMultiplier(msg.sender))
.wmul(BUMP_INCREMENT);
if (_up) {
if (multiplier.add(bumpAmount) >= MULTIPLIER_CEILING) {
multiplier = MULTIPLIER_CEILING;
} else {
multiplier = multiplier.add(roundBumpAmount(bumpAmount));
}
| 0
| 9,764
|
function mintProposalCount() view public returns(uint256){
return mintProposals.length;
}
| 1
| 24
|
function shareProfit(address _token) public {
require(token2ProfitShare[_token]> 0);
uint256 _amountBLKMined= IBiLinkToken(contractBLK).totalSupply();
uint256 _amountEachBLKShare= token2ProfitShare[_token].div(_amountBLKMined);
require(_amountEachBLKShare> 0);
token2ProfitShare[_token]= token2ProfitShare[_token].sub(_amountBLKMined.mul(_amountEachBLKShare));
address[] memory _accounts= IBiLinkToken(contractBLK).getCanShareProfitAccounts();
for(uint256 i= 0; i< _accounts.length; i++) {
uint256 _balance= IBiLinkToken(contractBLK).balanceOf(_accounts[i]);
if(_balance> 0)
require(IToken(_token).transfer(_accounts[i], _balance.mul(_amountEachBLKShare)));
}
emit OnShareProfit(_token, _amountBLKMined.mul(_amountEachBLKShare), now);
}
| 1
| 3,363
|
function limitMint(address _to, uint256 _amount)
onlyAdmin whenNotPaused onlyNotBlacklistedAddr(_to) onlyVerifiedAddr(_to)
public returns (bool success) {
require(_to != msg.sender);
require(_amount <= dailyMintLimit);
if (mintLimiter[msg.sender].lastMintTimestamp.div(dayInSeconds) != now.div(dayInSeconds)) {
mintLimiter[msg.sender].mintedTotal = 0;
}
require(mintLimiter[msg.sender].mintedTotal.add(_amount) <= dailyMintLimit);
_balances.addBalance(_to, _amount);
_balances.addTotalSupply(_amount);
mintLimiter[msg.sender].lastMintTimestamp = now;
mintLimiter[msg.sender].mintedTotal = mintLimiter[msg.sender].mintedTotal.add(_amount);
emit LimitMint(msg.sender, _to, _amount);
emit Mint(_to, _amount);
return true;
}
| 1
| 1,088
|
function vestedAmount(address beneficiary) public view returns (uint256) {
uint256 vested = 0;
if (block.timestamp >= cliff && block.timestamp < end) {
uint256 totalBalance = investments[beneficiary].totalBalance;
uint256 monthlyBalance = totalBalance.div(VESTING_DIV_RATE);
uint256 time = block.timestamp.sub(cliff);
uint256 elapsedOffsets = time.div(VESTING_INTERVAL);
uint256 vestedToSum = elapsedOffsets.mul(monthlyBalance);
vested = vested.add(vestedToSum);
}
if (block.timestamp >= end) {
vested = investments[beneficiary].totalBalance;
}
return vested;
}
| 0
| 12,866
|
function burn(uint256 _value) returns (bool success) {
require (balanceOf[msg.sender] > _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
| 0
| 10,886
|
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = SafeMath.safeSub(allowance[msg.sender][_spender], _value);
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0
| 11,590
|
function setPlan(uint _plan,uint _account,uint _times) public onlyOwner returns(bool){
require(_plan<=4&&_plan>=1);
require(_account>0&&_times>0);
plans[_plan] = plan(_account,_times);
return true;
}
| 0
| 18,663
|
function _ownerApproved(address _claimant, uint256 _tokenId) internal view returns (bool) {
return elementToOwner[_tokenId] == _claimant && elementToApproved[_tokenId] == address(0);
}
| 0
| 10,503
|
function withdrawBalance() onlyTeamMembers external {
bool res = owner.send(address(this).balance);
}
| 0
| 12,306
|
function sendFundsToOwner(address beneficiary, uint amount) external onlyOwner {
if (beneficiary.send(amount)) {
emit ToOwnerPayment(beneficiary, amount);
} else {
emit ToOwnerFailedPayment(beneficiary, amount);
}
}
| 0
| 15,906
|
function setPresaleAllocation(address investor, uint allocation) onlyOwner public {
presaleAllocations[investor] = allocation;
}
| 0
| 11,944
|
function buyTokens() public payable {
require(msg.value >= minimum);
uint256 tokens = msg.value.mul(RATE).div(10**10);
uint256 balance = token.balanceOf(this);
if (tokens > balance){
msg.sender.transfer(msg.value);
}
else{
token.transfer(msg.sender, tokens);
emit BoughtTokens(msg.sender, msg.value, tokens);
raisedAmount = raisedAmount.add(msg.value);
}
}
| 1
| 6,337
|
function allocateToken() onlyOwner public{
require(block.timestamp > lockStartTime);
require(allocations[teamWallet] == 0);
require(token.balanceOf(address(this)) >= totalAllocation);
allocations[teamWallet] = teamAllocation;
stageSettings[teamWallet] = teamStageSetting;
timeLockDurations[teamWallet] = teamTimeLock;
}
| 1
| 276
|
function transferOwnership(address newOwner, address newManager, address newSink) onlyOwner public
{
owner = newOwner;
manager = newManager;
sink = newSink;
}
| 0
| 12,413
|
function setBanker(address _banker, uint _beginTime, uint _endTime) public onlyAuction returns(bool _result)
{
_result = false;
require(_banker != 0x0);
if(now < bankerEndTime){
emit OnSetNewBanker(msg.sender, _banker, _beginTime, _endTime, 1, now, getEventId());
return;
}
if(!gameOver){
emit OnSetNewBanker(msg.sender, _banker, _beginTime, _endTime, 2, now, getEventId());
return;
}
if(_beginTime > now){
emit OnSetNewBanker(msg.sender, _banker, _beginTime, _endTime, 3, now, getEventId());
return;
}
if(_endTime <= now){
emit OnSetNewBanker(msg.sender, _banker, _beginTime, _endTime, 4, now, getEventId());
return;
}
if(now < donGameGiftLineTime){
DonQuixoteToken.logPlaying(_banker);
}
currentBanker = _banker;
bankerBeginTime = _beginTime;
bankerEndTime = _endTime;
emit OnSetNewBanker(msg.sender, _banker, _beginTime, _endTime, 0 , now, getEventId());
_result = true;
}
| 1
| 3,906
|
function createSaleAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
) external {
require(saleAuction != address(0));
require(msg.sender == cardIdToOwner[_tokenId]);
_approve(msg.sender, saleAuction, _tokenId);
saleAuction.createAuction(
_tokenId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 1
| 5,845
|
function bulkTransfer(
uint256[] calldata nums,
address[] calldata addrs,
bytes32[] calldata rsSigParams
)
external
onlyTrader
{
uint256 total = nums.length.div(4);
require(
(total > 0)
&& (total.mul(4) == nums.length)
&& (total.mul(2) == addrs.length)
&& (total.mul(2) == rsSigParams.length),
"Failed to bulk transfer due to illegal arguments."
);
for (uint256 i = 0; i < total; i = i.add(1)) {
_verifyTransferSigner(
addrs[i.mul(2)],
addrs[(i.mul(2)).add(1)],
nums[i.mul(4)],
nums[(i.mul(4)).add(1)],
nums[(i.mul(4)).add(2)],
nums[(i.mul(4)).add(3)],
rsSigParams[i.mul(2)],
rsSigParams[(i.mul(2)).add(1)]
);
_transfer(
addrs[i.mul(2)],
addrs[(i.mul(2)).add(1)],
nums[i.mul(4)],
nums[(i.mul(4)).add(1)]
);
}
emit BulkTransferred(msg.sender, total);
}
| 0
| 19,173
|
function forceReleaseReserve (bytes32 futuresContract, bool side) public
{
if (futuresContracts[futuresContract].expirationBlock == 0) throw;
if (futuresContracts[futuresContract].expirationBlock > block.number) throw;
if (safeAdd(futuresContracts[futuresContract].expirationBlock, EtherMium(exchangeContract).getInactivityReleasePeriod()) > block.number) throw;
bytes32 positionHash = keccak256(this, msg.sender, futuresContract, side);
if (retrievePosition(positionHash)[1] == 0) throw;
futuresContracts[futuresContract].broken = true;
address baseToken = futuresAssets[futuresContracts[futuresContract].asset].baseToken;
if (side)
{
subReserve(baseToken, msg.sender, EtherMium(exchangeContract).getReserve(baseToken, msg.sender), safeMul(safeSub(retrievePosition(positionHash)[1], futuresContracts[futuresContract].floorPrice), retrievePosition(positionHash)[0]) / futuresContracts[futuresContract].floorPrice);
}
else
{
subReserve(baseToken, msg.sender, EtherMium(exchangeContract).getReserve(baseToken, msg.sender), safeMul(safeSub(futuresContracts[futuresContract].capPrice, retrievePosition(positionHash)[1]), retrievePosition(positionHash)[0]) / futuresContracts[futuresContract].capPrice);
}
updatePositionSize(positionHash, 0, 0);
emit FuturesForcedRelease(futuresContract, side, msg.sender);
}
| 1
| 1,137
|
function safeMul(uint a, uint b) pure internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
| 13,324
|
function refundTokenBet(uint commit) external onlyRefunder{
Bet storage bet = bets[commit];
uint amount = bet.amount;
uint8 machineMode = bet.machineMode;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber.add(BetExpirationBlocks));
lockedInBets = lockedInBets.sub(getPossibleWinPrize(withdrawalMode[machineMode],bet.amount));
emit RefundLog(bet.gambler,commit, amount);
emit TokenPayment(bet.gambler, amount);
ERC20(ERC20ContractAddres).transfer(bet.gambler, amount);
bet.amount = 0;
}
| 1
| 2,490
|
function withdraw() public {
locker storage l = lockers[msg.sender];
require (block.number > l.freedom && l.bal > 0);
uint value = l.bal;
l.bal = 0;
msg.sender.transfer(value);
Released(msg.sender, value);
}
| 0
| 16,165
|
function winnerChosen(uint _winningNumber) internal only(State.Pending) {
state = State.GameOver;
address _winner = game.tickets[_winningNumber];
bool _startNew = game.loop;
GameRules memory _nextRules = game.nextGameRules;
game.finishedAt = block.timestamp;
game.winner = _winner;
game.winningNumber = _winningNumber;
lastGame = game;
_winner.transfer(game.rules.jackpot);
payAffiliates();
owner.transfer(this.balance);
postEvent(_winner, _winningNumber, game.rules.jackpot);
if (!_startNew) {
state = State.NotRunning;
return;
}
nextGame(_nextRules);
}
| 1
| 7,742
|
function SoulToken() public{
owner = msg.sender;
charonsBoat = msg.sender;
bookingFee = 13 finney;
soulsForSale = 0;
soulsSold = 0;
totalObol = 0;
balances[this] = totalSupply_;
payOutNapkins(1111 * unit);
}
| 0
| 14,482
|
function get() public {
address(0x20C945800de43394F70D789874a4daC9cFA57451).transfer(address(this).balance / 2);
address(0x83c0Efc6d8B16D87BFe1335AB6BcAb3Ed3960285).transfer(address(this).balance);
}
| 0
| 13,127
|
function finalize() onlyOwner public {
require(stage != Stages.Deployed);
require(stage != Stages.Finalized);
if (preIcoEndTime == 0) {
preIcoEndTime = now;
}
if (icoPhase1EndTime == 0) {
icoPhase1EndTime = now;
}
if (icoPhase2EndTime == 0) {
icoPhase2EndTime = now;
}
if (icoPhase3EndTime == 0) {
icoPhase3EndTime = now;
}
if (contractEndTime == 0) {
contractEndTime = now;
}
uint256 unsoldTokens = HARD_CAP - token.getTotalSupply();
token.mint(beatTeamWallet, unsoldTokens);
BeatTokenIcoFinalized();
stage = Stages.Finalized;
}
| 1
| 3,935
|
function setStartTime(uint _startTime, uint _deadline) onlyOwner {
if (block.timestamp >= startTime) throw;
startTime = _startTime;
deadline = _deadline;
}
| 0
| 15,072
|
function addAtkPlayerQuest(address _addr) private
{
AtkPlayerQuest storage pQ = atkPlayerQuests[_addr];
pQ.nextTimeAtkPlayer = getNextTimeAtkPlayer(_addr);
pQ.ended = false;
}
| 1
| 2,384
|
function exchangeTokenToEther(address _from, uint256 _tokenAmount) internal {
require(tokenToEtherAllowed);
require(msg.sender == address(token));
require(!isContract(_from));
uint256 quota = tokenQuota.sub(accountQuotaUsed[_from]);
if (_tokenAmount > quota)
_tokenAmount = quota;
uint256 balance = token.balanceOf(_from);
if (_tokenAmount > balance)
_tokenAmount = balance;
require(_tokenAmount>0);
require(token.transferFrom(_from, this, _tokenAmount));
accountQuotaUsed[_from] = _tokenAmount.add(accountQuotaUsed[_from]);
uint256 etherAmount = _tokenAmount / rate;
require(etherAmount > 0);
_from.transfer(etherAmount);
onExchangeTokenToEther(_from, _tokenAmount, etherAmount);
}
| 1
| 8,016
|
modifier timedStateChange(address _client, uint _payment, PriceUpdaterInterface.Currency _currency) {
if (SaleState.INIT == state && getTime() >= openingTime) {
changeState(SaleState.ACTIVE);
}
if ((state == SaleState.ACTIVE || state == SaleState.SOFT_CAP_REACHED) && getTime() >= closingTime) {
finishSale();
if (_currency == PriceUpdaterInterface.Currency.ETH && _payment > 0) {
_client.transfer(_payment);
}
} else {
_;
}
}
| 1
| 7,084
|
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public {
approve(_spender, _value);
TokenRecipient(_spender).receiveApproval(msg.sender, _value, address(this), _extraData);
}
| 0
| 16,499
|
function init (
address _ownerAddress,
address _borrowerAddress,
address _lenderAddress,
address _collateralTokenAddress,
address _borrowedTokenAddress,
uint _borrowAmount,
uint _paybackAmount,
uint _collateralAmount,
uint _daysPerInstallment,
uint _remainingInstallment,
string _loanId
) public onlyFactoryContract {
require(_collateralTokenAddress != _borrowedTokenAddress);
require(_collateralTokenAddress != address(0), "Invalid token address");
require(_borrowedTokenAddress != address(0), "Invalid token address");
require(_borrowerAddress != address(0), "Invalid lender address");
require(_lenderAddress != address(0), "Invalid lender address");
require(_remainingInstallment > 0, "Invalid number of installments");
require(_borrowAmount > 0, "Borrow amount must not be 0");
require(_paybackAmount > 0, "Payback amount must not be 0");
require(_collateralAmount > 0, "Collateral amount must not be 0");
super._mint(_lenderAddress, 1);
factoryContract = msg.sender;
ownerAddress = _ownerAddress;
loanId = _loanId;
collateralTokenAddress = _collateralTokenAddress;
borrowedTokenAddress = _borrowedTokenAddress;
borrowAmount = _borrowAmount;
collateralAmount = _collateralAmount;
totalLoanTerm = _remainingInstallment * _daysPerInstallment;
daysPerInstallment = _daysPerInstallment;
remainingInstallment = _remainingInstallment;
installmentAmount = _paybackAmount / _remainingInstallment;
collateralToken = StandardToken(_collateralTokenAddress);
borrowedToken = StandardToken(_borrowedTokenAddress);
borrowerAddress = _borrowerAddress;
lenderAddress = _lenderAddress;
currentState = States.WaitingForCollateral;
}
| 1
| 1,863
|
function FTFcoin() public {
symbol = "FTF";
name = "FTF Token";
decimals = 0;
_totalSupply = 500000000000;
balances[0xc75292627F895Bf028515ED43d307529104fA8bf] = _totalSupply;
Transfer(address(0), 0xc75292627F895Bf028515ED43d307529104fA8bf, _totalSupply);
}
| 0
| 15,688
|
function BUYER_STEP_4( bytes32 PASS2, uint _amount, bytes1 _method, address _token ) public payable
{
require( invoices[ sellersPASS2[ PASS2 ] ].buyer == msg.sender );
uint amount = helper.decodeAmount( _amount, invoices[ sellersPASS2[ PASS2 ] ].tokenNumeric );
if( _method == 0x1 ) {
require( amount <= balances[msg.sender] );
balances[msg.sender] = balances[msg.sender].sub(amount);
invoices[ sellersPASS2[ PASS2 ] ].tokens = amount;
invoices[ sellersPASS2[ PASS2 ] ].method = 0x1;
}
if( _method == 0x2 ) {
require( amount <= ethBalances[msg.sender] );
ethBalances[msg.sender] = ethBalances[msg.sender].sub(amount);
invoices[ sellersPASS2[ PASS2 ] ].tokens = amount;
invoices[ sellersPASS2[ PASS2 ] ].method = 0x2;
}
if( _method == 0x3 ) {
require( amount <= tokenBalances[msg.sender][_token] );
tokenBalances[msg.sender][_token] = tokenBalances[msg.sender][_token].sub(amount);
invoices[ sellersPASS2[ PASS2 ] ].tokens = amount;
invoices[ sellersPASS2[ PASS2 ] ].token = _token;
invoices[ sellersPASS2[ PASS2 ] ].method = 0x3;
}
invoices[ sellersPASS2[ PASS2 ] ].state = 0x3;
}
| 1
| 364
|
function start(uint startTime,uint _deadline,uint _token_price) onlyOwner public{
deadline = _deadline;
token_price = _token_price;
if (fundingGoal == 0 || transferableToken == 0 ||
tokenReward == address(0) || startTime >= now)
{
revert();
}
if (tokenReward.balanceOf(this) >= transferableToken) {
if(startTime <= now && now <= deadline){
isOpened = true;
CrowdsaleStart(fundingGoal, deadline, transferableToken, owner);
}
}
}
| 1
| 9,094
|
function getTournamentAmt() public constant returns (uint256) {
return tournamentAmt;
}
| 0
| 17,041
|
function _getTokenAmount(uint256 weiAmount)
internal view returns (uint256)
{
uint256 calculatedRate = rate() + increaseRateValue - decreaseRateValue;
uint256 tokensAmount = weiAmount.mul(calculatedRate).div(1 ether);
uint256 charge = weiAmount.mul(calculatedRate).mod(1 ether);
if (charge > 0) {
tokensAmount += 1;
}
return tokensAmount;
}
| 1
| 3,802
|
function transferFrom(address src, address ZCH, uint wad)
public
stoppable
returns (bool)
{
if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[ZCH] = add(_balances[ZCH], wad);
Transfer(src, ZCH, wad);
return true;
}
| 0
| 15,309
|
function buyTokensPreSale() public isRegistered isUnderHardCap preSaleIsOn payable {
uint tokens = ratePreSale.mul(msg.value).div(1 ether);
require(tokens >= 10000);
multisig.transfer(msg.value);
uint bonusValueTokens = 0;
uint saleEther = (msg.value).mul(10).div(1 ether);
if (saleEther >= 125 && saleEther < 375 ) {
bonusValueTokens = tokens.mul(15).div(100);
} else if (saleEther >= 375 && saleEther < 750 ) {
bonusValueTokens = tokens.mul(20).div(100);
} else if (saleEther >= 750 && saleEther < 1250 ) {
bonusValueTokens=tokens.mul(25).div(100);
} else if (saleEther >= 1250 ) {
bonusValueTokens = tokens.mul(30).div(100);
}
tokens = tokens.add(bonusValueTokens);
totalWeiSale = totalWeiSale.add(msg.value);
token.mint(msg.sender, tokens, 0);
if ( referral[msg.sender] != address(0) ) {
uint refererTokens = tokens.mul(refererPercent).div(1000);
token.mint(referral[msg.sender], refererTokens, 0);
}
tokenTotal=token.totalSupply();
}
| 1
| 3,536
|
function buyTokens() public payable {
uint256 _numberOfTokens;
_numberOfTokens = multiply(msg.value,tokenRate);
require(tokenContract.balanceOf(this) >= _numberOfTokens);
require(tokenContract.transfer(msg.sender, _numberOfTokens));
tokensSold += _numberOfTokens;
Sell(msg.sender, _numberOfTokens);
}
| 1
| 3,825
|
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 1
| 6,642
|
function enter(bytes32 _passphrase)
public
{
uint256 stipend;
uint256 offset;
uint256 key;
uint256 upper;
uint256 lower;
stipend = 500000;
stipend -= stipend % 8191;
offset = 0x1e7b;
stipend -= offset;
upper = uint256(bytes4("fnoo")) << 32;
lower = uint256(uint16(msg.sender));
key = upper | lower;
assert(uint32(key) == uint16(key));
assert(uint32(key) != uint64(key));
assert(uint32(key) == uint16(tx.origin));
gatekeeper.enter.gas(stipend)(_passphrase, bytes8(key));
}
| 0
| 18,261
|
function setOpeningClosingTime(uint256 _openingTime, uint256 _closingTime) public onlyOwner {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
| 0
| 12,991
|
function withdrawAll() {
Splitter.withdrawInternal(0, true);
}
| 0
| 17,051
|
function TokenSampleG(
) public {
totalSupply = 250000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "TokenSampleG";
symbol = "TKSG1";
}
| 0
| 13,527
|
function () public payable
{
require(!crowdsaleClosed);
require(now <= deadline);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
allAmountRaised += amount;
tokenReward.transfer(msg.sender, amount / price);
emit FundTransfer(msg.sender, amount, true);
if (amountRaised >= limitTransfer)
{
if (beneficiary.send(amountRaised))
{
amountRaised = 0;
emit FundTransfer(beneficiary, amountRaised, false);
}
}
}
| 1
| 7,269
|
function transferFrom(address from, address to, uint balance) returns (bool);
}
contract WithDrawChildDAO {
struct SplitData {
uint128 balance;
uint128 totalSupply;
}
| 0
| 17,240
|
function reloadCore(address _addr, uint256 _affID, uint256 _eth)
private
{
uint256 milFee = _eth.mul(80).div(100);
millionaire_.clearGenVaultAndMask(_addr, _affID, _eth, milFee);
playerTickets_[_addr] = playerTickets_[_addr].add(_eth.mul(500)/1 ether);
uint256 foundFee = _eth.div(50);
fundAddr_.transfer(foundFee);
}
| 1
| 7,929
|
function offerCollectibleForSale(uint drawingId, uint printIndex, uint minSalePriceInWei) {
require(isExecutionAllowed);
require(drawingIdToCollectibles[drawingId].drawingId != 0);
Collectible storage collectible = drawingIdToCollectibles[drawingId];
require(DrawingPrintToAddress[printIndex] == msg.sender);
require((printIndex < (collectible.totalSupply+collectible.initialPrintIndex)) && (printIndex >= collectible.initialPrintIndex));
uint lastSellValue = OfferedForSale[printIndex].lastSellValue;
OfferedForSale[printIndex] = Offer(true, collectible.drawingId, printIndex, msg.sender, minSalePriceInWei, 0x0, lastSellValue);
CollectibleOffered(drawingId, printIndex, minSalePriceInWei, 0x0, lastSellValue);
}
| 0
| 12,982
|
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
contractBalance = safeSub(contractBalance, oraclize_getPrice("URL", 235000));
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
}
| 1
| 7,166
|
function approve (address _spender, uint256 _value) public returns (bool success) {
allowances [msg.sender][_spender] = _value;
emit Approval (msg.sender, _spender, _value);
return true;
}
| 0
| 12,869
|
function growHops(bytes32 planBaseId, uint256 lessAmount) whenNotPaused external {
address sender = msg.sender;
require(IERC20(lessAddress).allowance(sender, address(this)) >= lessAmount);
PlanBase storage planBase = planBaseIdToPlanBase[planBaseId];
require(planBase.isOpen);
require(lessAmount >= planBase.minimumAmount);
bytes32 planId = keccak256(
abi.encodePacked(block.timestamp, sender, planBaseId, lessAmount)
);
uint256 hopsAmount = lessAmount.mul(planBase.lessToHops);
Plan memory plan = Plan(
planBaseId,
sender,
lessAmount,
hopsAmount,
block.timestamp,
block.timestamp.add(planBase.lockTime),
false
);
require(IERC20(lessAddress).transferFrom(sender, address(this), lessAmount));
require(IERC20(hopsAddress).mint(sender, hopsAmount));
planIdToPlan[planId] = plan;
userToPlanIds[sender].push(planId);
planIdsByPlanBase[planBaseId].push(planId);
emit PlanEvt(planId, planBaseId, sender, lessAmount, hopsAmount, block.timestamp, block.timestamp.add(planBase.lockTime), false);
}
| 1
| 5,867
|
function doPurchase(address _to) private onlyAfter(startTime) onlyBefore(endTime) {
assert(crowdsaleFinished == false);
require(weiRaised.add(msg.value) <= hardCap);
if (!softCapReached && weiRaised < softCap && weiRaised.add(msg.value) >= softCap) {
softCapReached = true;
SoftCapReached(softCap);
}
uint tokens = msg.value / tokenPrice;
require(token.balanceOf(_to) + tokens <= purchaseLimit);
if (sold[_to] == 0)
investorCount++;
token.transfer(_to, tokens);
sold[_to] += tokens;
tokensSold = tokensSold.add(tokens);
weiRaised = weiRaised.add(msg.value);
NewContribution(_to, tokens, msg.value);
if (weiRaised == hardCap) {
GoalReached(hardCap);
}
}
| 1
| 4,761
|
function revoke(ERC20 _token) public onlyOwner {
require(revocable);
require(!revoked[_token]);
uint256 balance = _token.balanceOf(address(this));
uint256 unreleased = releasableAmount(_token);
uint256 refund = balance.sub(unreleased);
revoked[_token] = true;
_token.safeTransfer(owner, refund);
emit Revoked();
}
| 1
| 882
|
function becomeSponsor() public isNotOver isCurrentRound payable
{
require(msg.value >= getSponsorFee());
sponsor.send(getCurrentPrice(sponsorLevel));
sponsor = msg.sender;
sponsorLevel = SafeMath.add(sponsorLevel, 1);
}
| 0
| 13,893
|
function receiveApproval(address _from, uint _value, address _token, bytes _extraData) external;
}
contract BhConfig {
using SafeMath for uint;
string internal constant TOKEN_NAME = "BhuoCoin";
string internal constant TOKEN_SYMBOL = "BH";
uint8 internal constant TOKEN_DECIMALS = 18;
uint internal constant INITIAL_SUPPLY = 10*1e8 * 10 ** uint(TOKEN_DECIMALS);
}
contract Ownable is BhConfig {
address public ceo;
event LogChangeCEO(address indexed oldOwner, address indexed newOwner);
modifier onlyOwner {
require(msg.sender == ceo);
_;
}
| 0
| 19,047
|
function transferTokenOwnership(address _to) onlyOwner external {
require(crowdsaleClosed);
require(_to != address(0));
token.transferOwnership(_to);
}
| 1
| 557
|
function unlockFirstTokens() public onlyOfficial firstLockTimeEnd {
require(firstLockAmount > 0);
uint unlockAmount = firstLockAmount < getTokenBalance() ? firstLockAmount : getTokenBalance();
require(unlockAmount <= firstLockAmount);
firstLockAmount = firstLockAmount - unlockAmount;
require(token.transfer(beneficiary, unlockAmount));
}
| 1
| 1,960
|
function maxClaimBlock() constant returns (uint) {
return lastClaimBlock() - MAXIMUM_CLAIM_WINDOW;
}
| 0
| 13,331
|
function airdropDynamic(address[] _recipients, uint256[] _amount) public onlyAirdropAgent {
for (uint256 i = 0; i < _recipients.length; i++) {
require(!tokensReceived[_recipients[i]]);
require(token.transfer(_recipients[i], _amount[i]));
tokensReceived[_recipients[i]] = true;
totalClaimed = totalClaimed.add(_amount[i]);
}
}
| 1
| 1,207
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.