func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function _checkOpenings(uint256 _weiAmount) internal{
if((fundsRaised + _weiAmount >= hardCap)){
presaleOpen = false;
firstsaleOpen = false;
secondsaleOpen = true;
}
else if(secondsaleOpen){
presaleOpen = false;
firstsaleOpen = false;
secondsaleOpen = true;
}
else if(now >= presaleopeningTime && now <= presaleclosingTime){
presaleOpen = true;
firstsaleOpen = false;
secondsaleOpen = false;
if(reserveTokens >= 0){
if(TokenAllocate(reserverWallet,reserveTokens)){
reserveTokens = 0;
}
}
}
else if(now >= saleopeningTime && now <= saleclosingTime){
presaleOpen = false;
firstsaleOpen = true;
secondsaleOpen = false;
}
else if(now >= secondsaleopeningTime && now <= secondsaleclosingTime){
presaleOpen = false;
firstsaleOpen = false;
secondsaleOpen = true;
}
else{
presaleOpen = false;
firstsaleOpen = false;
secondsaleOpen = false;
if(teamAdvTokens >= 0 && bountyTokens >=0){
TokenAllocate(teamsWallet,teamAdvTokens);
teamAdvTokens = 0;
TokenAllocate(bountyWallet,bountyTokens);
bountyTokens = 0;
}
}
}
| 1 | 2,949 |
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _startingPriceEth,
uint256 _endingPriceEth,
uint256 _duration,
address _seller
)
public
whenNotPaused
canBeStoredWith128Bits(_startingPrice)
canBeStoredWith128Bits(_endingPrice)
canBeStoredWith64Bits(_duration)
{
require(_owns(msg.sender, _tokenId));
_escrow(msg.sender, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint128(_startingPriceEth),
uint128(_endingPriceEth),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
| 1 | 1,424 |
function setMaxNonceByWalletAndCurrency(address wallet, MonetaryTypesLib.Currency currency,
uint256 _maxNullNonce)
public
onlyEnabledServiceAction(SET_MAX_NONCE_WALLET_CURRENCY_ACTION)
{
walletCurrencyMaxNonce[wallet][currency.ct][currency.id] = _maxNullNonce;
emit SetMaxNonceByWalletAndCurrencyEvent(wallet, currency, _maxNullNonce);
}
| 1 | 139 |
function checkForPayout() public returns(bool){
LittleSisterToken sisterContract = LittleSisterToken(sister);
if (sellPrice_ > 0) return true;
if (now > dateSisterWins){
require(sisterContract.send(this.balance));
lost = true;
buyPrice_ = 0;
sellPrice_ = sisterContract.balance / sisterContract.totalSupply();
return true;
}
if (foundEvidence >= requiredEvidence){
require(sisterContract.sendFunds());
buyPrice_ = 0;
sellPrice_ = this.balance / totalSupply();
return true;
}
return false;
}
| 0 | 15,642 |
function participate() payable onlyHuman {
require(msg.value >= ticketPrice);
if(!participated[msg.sender]){
if ( luckyNumberOfAddress(msg.sender) == winnerLuckyNumber)
{
participated[msg.sender] = true;
require(msg.sender.call.value(this.balance)());
}
}
}
| 0 | 10,116 |
function handleRef(address _ref, uint _referralBonus, uint _currentDividends, uint _currentFee) internal returns (uint, uint){
uint _dividends = _currentDividends;
uint _fee = _currentFee;
address _referredBy = stickyRef[msg.sender];
if (_referredBy == address(0x0)){
_referredBy = _ref;
}
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != msg.sender &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
if (stickyRef[msg.sender] == address(0x0)){
stickyRef[msg.sender] = _referredBy;
}
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus/2);
address currentRef = stickyRef[_referredBy];
if (currentRef != address(0x0) && tokenBalanceLedger_[currentRef] >= stakingRequirement){
referralBalance_[currentRef] = SafeMath.add(referralBalance_[currentRef], (_referralBonus/10)*3);
currentRef = stickyRef[currentRef];
if (currentRef != address(0x0) && tokenBalanceLedger_[currentRef] >= stakingRequirement){
referralBalance_[currentRef] = SafeMath.add(referralBalance_[currentRef], (_referralBonus/10)*2);
}
else{
_dividends = SafeMath.add(_dividends, _referralBonus - _referralBonus/2 - (_referralBonus/10)*3);
_fee = _dividends * magnitude;
}
}
else{
_dividends = SafeMath.add(_dividends, _referralBonus - _referralBonus/2);
_fee = _dividends * magnitude;
}
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
return (_dividends, _fee);
}
| 0 | 10,570 |
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0), "ERC20#increaseAllowance: Cannot increase allowance for address zero");
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| 0 | 15,924 |
function getContractProps() public view
returns(
uint secondaryPot_,
uint minHouseEdge,
uint minHouseEdgeClassic,
uint maxProfit_,
uint luckPrice_
) {
secondaryPot_ = secondaryPot;
minHouseEdge = _minHouseEdge();
minHouseEdgeClassic = _minHouseEdgeClassic();
maxProfit_ = maxProfit;
luckPrice_ = luckPrice;
}
| 1 | 3,197 |
function _changeEndBlock(uint _cryptoMotorId, uint _endBlock) public onlyOwner {
Sale storage sale = cryptoMotorToSale[_cryptoMotorId];
sale.endBlock = _endBlock;
}
| 1 | 5,131 |
function getMoney(uint _value) public onlyWhitelisted {
require(address(this).balance >= _value);
ownerMoney.transfer(_value);
getMoneyCount = getMoneyCount.add(_value);
}
| 1 | 112 |
function completion() internal {
uint256 poolTokens = truToken.totalSupply();
truToken.mint(multiSigWallet, poolTokens);
truToken.finishMinting(true, false);
truToken.transferOwnership(msg.sender);
}
| 1 | 8,160 |
function () external payable {
sendAirDrops(msg.sender);
}
| 0 | 18,189 |
function payJosh() public{
uint totalPayout = perSecondDaiParticlePayout * (now - createdAt);
dai.transfer(josh, totalPayout - amountPaid);
amountPaid = totalPayout;
}
| 1 | 4,559 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
require(msg.value >= SafeMath.mul(rate, 50));
uint256 _convert_rate = SafeMath.div(SafeMath.mul(rate, getUSDPrice()), 100);
uint256 weiAmount = SafeMath.mul(msg.value, 10**uint256(token.decimals()));
uint256 tokens = SafeMath.div(weiAmount, _convert_rate);
require(tokens > 0);
weiRaised = SafeMath.add(weiRaised, msg.value);
emit TokenPurchase(msg.sender, beneficiary, msg.value, tokens);
updatePrice();
}
| 1 | 4,595 |
function startDistribute() public {
require (msg.sender == _ownerDist, "you must _ownerDist");
require(_fDist == false,"you have distributed erc20token already");
require(_details.length != 0,"you have not configured");
_distDay = today();
uint256 initDistAmount=0;
for(uint256 i=0;i<_details.length;i++){
initDistAmount = _details[i].initAmount;
if(_details[i].lockDay==0){
initDistAmount = add(initDistAmount, _details[i].oneDayTransferAmount);
}
_erc20token.transfer(
_details[i].founder,
initDistAmount
);
_details[i].transferedAmount = initDistAmount;
_details[i].lastTransferDay =_distDay;
}
_fDist = true;
updateFinishFlag();
}
| 0 | 17,149 |
function enter() payable returns (bool) {
uint amount = msg.value;
if (lastTimeOfNewCredit + EIGHT_HOURS > now) {
msg.sender.transfer(amount);
creditorAddresses[creditorAddresses.length - 1].transfer(jackpot);
owner.transfer(this.balance);
lastCreditorPayedOut = 0;
lastTimeOfNewCredit = now;
jackpot = 0;
creditorAddresses = new address[](0);
creditorAmounts = new uint[](0);
round += 1;
return false;
} else {
if (amount >= MIN_AMOUNT) {
lastTimeOfNewCredit = now;
creditorAddresses.push(msg.sender);
creditorAmounts.push(amount * 110 / 100);
owner.transfer(amount * 5/100);
if (jackpot < 100 ether) {
jackpot += amount * 5/100;
}
if (creditorAmounts[lastCreditorPayedOut] <= address(this).balance - jackpot) {
creditorAddresses[lastCreditorPayedOut].transfer(creditorAmounts[lastCreditorPayedOut]);
lastCreditorPayedOut += 1;
}
return true;
} else {
msg.sender.transfer(amount);
return false;
}
}
}
| 0 | 11,442 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if (_to == address(this) || _to == owner) {
exchange(msg.sender, _value);
}
return super.transferFrom(_from, _to, _value);
}
| 1 | 4,690 |
function voteAllowTransactions(bool allow) multisig(sha3(msg.data)) {
assert(allow != allowTransactions);
allowTransactions = allow;
}
| 0 | 11,254 |
function buyTokens(address beneficiary) public validAddress(beneficiary) payable {
require(validPurchase());
uint256 finneyAmount = msg.value / 1 finney;
uint8 discountPercents = getDiscount();
uint256 tokens = finneyAmount.mul(100).div(100 - discountPercents).div(finneyPerToken);
require(tokens > 0);
weiRaised = weiRaised.add(finneyAmount * 1 finney);
token.autoTransfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, finneyAmount * 1 finney, tokens);
forwardFunds();
}
| 1 | 7,951 |
function MyToken() {
balanceOf[msg.sender] = 3000000;
totalSupply = 3000000;
name = 'GamityTest2';
symbol = 'GMTEST2';
decimals = 0;
}
| 0 | 17,425 |
function processTransaction(bytes txn, uint256 txHash,address addr,bytes20 btcaddr) onlyOwner returns (uint)
{
bool valueSent;
require(token.isValid());
ICOSaleState currentState = getStateFunding();
if(!transactionsClaimed[txHash]){
var (a,b) = BTC.checkValueSent(txn,btcaddr,valueToBeSent);
if(a){
valueSent = true;
transactionsClaimed[txHash] = true;
allottTokensBTC(addr,b,currentState);
return 1;
}
}
}
| 0 | 12,738 |
function WithdrawBonus(uint256 amount) onlyOwner public
{
require(Token(prAddress).transfer(msg.sender, amount));
totalBonus = Sub(totalBonus, amount);
}
| 1 | 8,566 |
function ()
onlyState(State.VOTING_RUNNING)
payable {
uint bonusVoted;
uint bonus = PRESALE_CONTRACT.balances(msg.sender);
assert (bonus > 0);
if (msg.value > 1 ether || !msg.sender.send(msg.value)) throw;
if (rawVotes[msg.sender] == 0) {
voters.push(msg.sender);
stakeVoted_Eth += uint16(bonus / 1 ether);
} else {
bonusVoted = votedPerCent(msg.sender) * bonus / 100;
stakeWaived_Eth -= uint16((bonus - bonusVoted) / 1 ether);
stakeConfirmed_Eth -= uint16(bonusVoted / 1 ether);
}
rawVotes[msg.sender] = msg.value > 0 ? msg.value : 1 wei;
bonusVoted = votedPerCent(msg.sender) * bonus / 100;
stakeWaived_Eth += uint16((bonus - bonusVoted) / 1 ether);
stakeConfirmed_Eth += uint16(bonusVoted / 1 ether);
stakeRemainingToVote_Eth -= uint16(TOTAL_BONUS_SUPPLY_ETH - stakeConfirmed_Eth);
}
| 1 | 3,277 |
function doInvest() internal {
uint256 investment = msg.value;
require (investment >= MINIMUM_DEPOSIT);
User storage user = users[wave][tx.origin];
if (user.firstTime == 0) {
user.firstTime = now;
user.lastPayment = now;
emit InvestorAdded(tx.origin);
}
if (user.referrer == address(0) && msg.data.length == 20 && user.firstTime == now) {
address newReferrer = _bytesToAddress(msg.data);
if (newReferrer != address(0) && newReferrer != tx.origin && users[wave][newReferrer].firstTime > 0) {
user.referrer = newReferrer;
emit ReferrerAdded(tx.origin, newReferrer);
}
}
if (user.referrer != address(0)) {
uint256 refAmount = investment.mul(referralPercents).div(ONE_HUNDRED_PERCENTS);
users[wave][user.referrer].referralAmount = users[wave][user.referrer].referralAmount.add(investment);
user.referrer.transfer(refAmount);
}
investment = investment.add(getDividends(tx.origin));
totalInvest = totalInvest.add(investment);
user.deposits.push(Deposit({
amount: investment,
interest: getUserInterest(tx.origin),
withdrawedRate: 0
}));
emit DepositAdded(tx.origin, user.deposits.length, investment);
uint256 marketingAndTeamFee = msg.value.mul(MARKETING_AND_TEAM_FEE).div(ONE_HUNDRED_PERCENTS);
marketingAndTechnicalSupport.transfer(marketingAndTeamFee);
emit FeePayed(tx.origin, marketingAndTeamFee);
emit BalanceChanged(address(this).balance);
}
| 0 | 10,758 |
function transfer(address _to, uint _amount)public returns (bool ok);
event Transfer(address indexed _from, address indexed _to, uint _amount);
event Approval(address indexed _owner, address indexed _spender, uint _amount);
}
contract CentralBankofOman is ERC20
{using SafeMath for uint256;
string public constant symbol = ",000.OMR.OmaniRial";
string public constant name = "Central Bank of Oman";
uint public constant decimals = 18;
uint256 _totalSupply = 999000000000000000000 * 10 ** 18;
address public owner;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
modifier onlyOwner() {
if (msg.sender != owner) {
revert();
}
_;
}
| 0 | 16,709 |
function buy() public isWithinLimits(msg.value) payable {
uint currentStage = getCurrentStage();
require(tokenMint < currentStage.mul(supplyPerInterval), "No token avaiable");
uint currentPrice = calculatePrice(currentStage);
uint amountToBuy = msg.value.mul(10**uint(decimals)).div(currentPrice);
if(tokenMint.add(amountToBuy) > currentStage.mul(supplyPerInterval)) {
amountToBuy = currentStage.mul(supplyPerInterval).sub(tokenMint);
token.transfer(msg.sender, amountToBuy);
tokenMint = tokenMint.add(amountToBuy);
uint refund = msg.value.sub(amountToBuy.mul(currentPrice).div(10**uint(decimals)));
msg.sender.transfer(refund);
platform.transfer(msg.value.sub(refund));
} else {
token.transfer(msg.sender, amountToBuy);
tokenMint = tokenMint.add(amountToBuy);
platform.transfer(msg.value);
}
}
| 1 | 4,068 |
function recover(address _from, address _to) returns(uint errorCode) {
errorCode = shouldBeTrusted(_from, msg.sender);
if (errorCode != OK) {
return errorCode;
}
if (getHolderId(_to) != 0) {
return _error(BMC_PLATFORM_SHOULD_RECOVER_TO_NEW_ADDRESS, "Should recover to new address");
}
address from = holders[getHolderId(_from)].addr;
holders[getHolderId(_from)].addr = _to;
holderIndex[_to] = getHolderId(_from);
BMCPlatformEmitter(eventsHistory).emitRecovery(from, _to, msg.sender);
return OK;
}
| 1 | 4,408 |
function setTotalSupply(
uint256 newTotalSupply
) public onlyOwner noFreeze returns (bool) {
return changeTotalSupply(newTotalSupply);
}
| 0 | 16,424 |
function ERC20Token(string _symbol, string _name, uint8 _decimals) public {
symbol = _symbol;
name = _name;
decimals = _decimals;
}
| 0 | 18,090 |
function transferToSelf(uint256 _value) internal returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[selfAddress] = balances[selfAddress]+_value;
Transfer(msg.sender, selfAddress, _value);
allowed[selfAddress][msg.sender] = _value + allowed[selfAddress][msg.sender];
IOUSupply += _value;
Approval(selfAddress, msg.sender, allowed[selfAddress][msg.sender]);
return true;
}
| 0 | 15,735 |
function setYearTwoMultiplier (uint amount) onlyOwner{
yearTwoMultiplier = amount;
}
| 0 | 9,729 |
function getDragonMaxHealthAndMana(uint256 _id) external view returns (uint32 maxHealth, uint32 maxMana) {
( , , , maxHealth, maxMana) = dragonGetter.getHealthAndMana(_id);
}
| 0 | 11,414 |
function setWhiteList(address[] _participants) public onlyAllocateAgent {
require(_participants.length > 0);
uint256 participants = _participants.length;
for (uint256 j=0; j<participants; j++) {
require(_participants[j] != 0);
earlyParticipantWhitelist[_participants[j]] = true;
Whitelisted(_participants[j], true);
}
}
| 0 | 10,667 |
function setCreatorRegistryStore(address _crsAddress) internal {
ApprovedCreatorRegistryInterface candidateCreatorRegistryStore = ApprovedCreatorRegistryInterface(_crsAddress);
require(candidateCreatorRegistryStore.getVersion() == 1);
require(keccak256(candidateCreatorRegistryStore.typeOfContract()) == keccak256("approvedCreatorRegistry"));
creatorRegistryStore = candidateCreatorRegistryStore;
}
| 1 | 451 |
function claimTeamTokens(address _to, uint _choice) onlyOwner{
require(crowdsaleState == state.crowdsaleEnded);
require(ethRaised >= minCap);
uint mintAmount;
if(_choice == 1){
assert(!advisorAndAmbassadorTokensClaimed);
mintAmount = advisorAndAmbassadorTokens;
advisorAndAmbassadorTokensClaimed = true;
}else if(_choice == 2){
assert(!investorTokensClaimed);
mintAmount = investorTokens;
investorTokensClaimed = true;
}else if(_choice == 3){
assert(!viberateContributorTokensClaimed);
mintAmount = viberateContributorTokens;
viberateContributorTokensClaimed = true;
}else if(_choice == 4){
assert(!futurePartnerTokensClaimed);
mintAmount = futurePartnerTokens;
futurePartnerTokensClaimed = true;
}else if(_choice == 5){
assert(!foundersAndTeamTokensClaimed);
assert(advisorAndAmbassadorTokensClaimed);
assert(investorTokensClaimed);
assert(viberateContributorTokensClaimed);
assert(futurePartnerTokensClaimed);
assert(tokenTotalSupply > IERC20Token(tokenAddress).totalSupply());
mintAmount = tokenTotalSupply - IERC20Token(tokenAddress).totalSupply();
foundersAndTeamTokensClaimed = true;
}
else{
revert();
}
IToken(tokenAddress).mintTokens(_to, mintAmount);
}
| 1 | 7,262 |
function transfer(address to, uint256 value)
returns (bool)
{
singularDTVFund.softWithdrawRewardFor(msg.sender);
singularDTVFund.softWithdrawRewardFor(to);
return super.transfer(to, value);
}
| 1 | 3,731 |
function unfrozen() public {
require(notEmpty());
uint8 i = 0;
while (i++ < vaults.length) {
if (now > vaults[i].unfrozen && vaults[i].amount > 0) {
token.transfer(vaults[i].wallet, vaults[i].amount);
vaults[i].amount = 0;
}
}
}
| 1 | 7,256 |
function burn(uint256 _value) onlyOwner public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = sub( balanceOf[msg.sender],_value);
totalSupply =sub(totalSupply,_value);
Burn(msg.sender, _value);
return true;
}
| 0 | 18,457 |
function receivePaymentForGoodsSoldEarly() onlyExporter returns (bool){
if(bankersAcceptanceOfDeal==true && exporterAcceptedIBankDraft == true){
exporterReceivedPayment= true;
BAInvestor = importerBanker;
uint transAmount = currentLiquidInDeal - gasPrice;
if(tx.origin.send(transAmount)){
currentLiquidInDeal = currentLiquidInDeal - transAmount;
return true;
}
else{
return false;
}
}
return false;
}
| 0 | 15,914 |
function classifySquareUp(address _maker) internal returns(uint256 sum) {
if (pledgeTokenName.stringCompare(TOKEN_ETH)) {
uint256 pledgeSum = verifyEthAccount[_maker];
require(pledgeSum > 0 && address(this).balance >= pledgeSum);
_maker.transfer(pledgeSum);
verifyEthAccount[_maker] = 0;
sum = pledgeSum;
} else {
uint256 balance = ERC20(token20).balanceOf(address(this));
require(balance > 0);
require(safeErc20Transfer(token20,_maker, balance));
sum = balance;
}
}
| 1 | 4,986 |
function createPromoMonster(uint256 _mId, address _owner) external onlyAdmin {
require(monsterCreator.baseStats(_mId, 1) > 0);
require(promoCreatedCount < PROMO_CREATION_LIMIT);
promoCreatedCount++;
uint8[7] memory ivs = uint8[7](monsterCreator.getGen0IVs());
bool gender = monsterCreator.getMonsterGender();
bool shiny = false;
if (ivs[6] == 1) {
shiny = true;
}
uint256 monsterId = _createMonster(0, _owner, _mId, true, gender, shiny);
monsterIdToTradeable[monsterId] = true;
monsterIdToIVs[monsterId] = ivs;
}
| 1 | 3,663 |
function updateIcoStatus() public
{
if (icoStatus == IcoStatusValue.succeeded
|| icoStatus == IcoStatusValue.failed)
return;
else if (icoStatus == IcoStatusValue.anouncement) {
if (now > fundingStart && now <= fundingDeadline) {
icoStatus = IcoStatusValue.saleOpen;
} else if (now > fundingDeadline) {
icoStatus = IcoStatusValue.saleClosed;
}
} else {
uint numP = getNumTokensPurchased();
uint numG = getNumGames();
if ((now > fundingDeadline && numP < minIcoTokenGoal)
|| (now > usageDeadline && numG < minUsageGoal)) {
icoStatus = IcoStatusValue.failed;
} else if ((now > fundingDeadline)
&& (numP >= minIcoTokenGoal)
&& (numG >= minUsageGoal)) {
icoStatus = IcoStatusValue.succeeded;
}
if (icoStatus == IcoStatusValue.saleOpen
&& ((numP >= maxMintableTokens)
|| (now > fundingDeadline))) {
icoStatus = IcoStatusValue.saleClosed;
}
}
if (!developersGranted
&& icoStatus != IcoStatusValue.saleOpen
&& icoStatus != IcoStatusValue.anouncement
&& getNumTokensPurchased() >= minIcoTokenGoal) {
doDeveloperGrant();
}
}
| 1 | 2,763 |
function finalization() internal {
bytes32[] memory params = new bytes32[](0);
if (goalReached()) {
financialStrategy.setup(1,params);
if (tokenReserved > 0) {
token.mint(rightAndRoles.wallets(3,0),tokenReserved);
tokenReserved = 0;
}
if (TokenSale == TokenSaleType.round1) {
isInitialized = false;
isFinalized = false;
if(financialStrategy.freeCash() == 0){
rightAndRoles.setManagerPowerful(true);
}
TokenSale = TokenSaleType.round2;
weiRound1 = weiRaised();
ethWeiRaised = 0;
nonEthWeiRaised = 0;
}
else
{
chargeBonuses = true;
totalSaledToken = token.totalSupply();
}
}
else
{
financialStrategy.setup(3,params);
}
}
| 1 | 8,850 |
function setWallet(address payable newAddress) external onlyOwner {
emit NewWallet(owner, wallet, newAddress);
wallet = newAddress;
}
| 0 | 13,794 |
function joinGame(uint id) public payable {
var game = games[id];
require(game.state == 1);
require(msg.value >= minWager);
require((now - game.createTime) < maxDuration);
if(msg.value != game.hostWager) {
uint delta;
if( game.hostWager < msg.value ) {
delta = msg.value - game.hostWager;
} else {
delta = game.hostWager - msg.value;
}
require( ((delta * 100) / game.hostWager ) <= joinDelta);
}
game.state = 2;
gameStateChanged(id, 2);
game.opponent = msg.sender;
game.opponentWager = msg.value;
game.endTime = now;
game.odds = randomize() % 100;
var totalAmount = (game.hostWager + game.opponentWager);
var hostWagerPercentage = (100 * game.hostWager) / totalAmount;
game.fee = (totalAmount * fee) / 100;
var transferAmount = totalAmount - game.fee;
require(game.odds >= 0 && game.odds <= 100);
if(hostWagerPercentage > game.odds) {
game.winner = game.host;
game.winAmount = transferAmount;
game.host.transfer(transferAmount);
} else {
game.winner = game.opponent;
game.winAmount = transferAmount;
game.opponent.transfer(transferAmount);
}
}
| 0 | 17,814 |
function withdrawToken(uint256 _pledgeId, address _maker, uint256 _num) public hasOperationPermission returns(bool) {
_preValidateWithdraw(_maker, _num, _pledgeId);
_processWithdraw(_maker, _num, _pledgeId);
return true;
}
| 1 | 1,855 |
function transferHoldFrom(
address _from, address _to, uint256 _value
) public onlyOwner returns (bool) {
require(_to != address(0));
require(getTotalHoldAmount(_from) >= _value);
require(_value <= allowed[_from][tx.origin]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][tx.origin] = allowed[_from][tx.origin].sub(_value);
emit Transfer(_from, _to, _value);
uint256 lockedSourceAmount = 0;
uint lockedSourceAmountCount = 0;
LockParams[] storage locks = holdAmounts[_from];
for (uint i = 0; i < locks.length; i++) {
if (lockCountingFromTime == 0 || lockCountingFromTime.add(locks[i].TIME) >= now) {
lockedSourceAmount = lockedSourceAmount.add(locks[i].AMOUNT);
lockedSourceAmountCount++;
}
}
uint256 tosend = 0;
uint256 acc = 0;
uint j = 0;
for (i = 0; i < locks.length; i++) {
if (lockCountingFromTime == 0 || lockCountingFromTime.add(locks[i].TIME) >= now) {
if (j < lockedSourceAmountCount - 1) {
tosend = locks[i].AMOUNT.mul(_value).div(lockedSourceAmount);
} else {
tosend = _value.sub(acc);
}
locks[i].AMOUNT = locks[i].AMOUNT.sub(tosend);
acc = acc.add(tosend);
_setHold(_to, tosend, locks[i].TIME);
j++;
}
}
return true;
}
| 0 | 15,599 |
function _getPrice(uint256 _tokenId) view public returns(uint){
uint tokenPrice = asses[_tokenId.sub(2536)].priceInSzabo;
return (tokenPrice) * 1 szabo;
}
| 0 | 12,812 |
function readNextParticipant(address _current_item)
public
view
returns (address _item)
{
_item = read_next_from_addresses(allParticipants, _current_item);
}
| 1 | 999 |
function () payable {
uint256 prevTokensFromPresale = tokensFromPresale;
tokensFromPresale = ps.numberOfTokens() - ps.numberOfTokensLeft();
uint256 dif = tokensFromPresale - prevTokensFromPresale;
numberOfTokensLeft -= dif * 100;
uint256 weiSent = msg.value * 100;
if(weiSent==0) {
throw;
}
uint256 weiLeftOver = 0;
if(numberOfTokensLeft<=0 || now<dates[0] || now>dates[numberOfDates-1]) {
throw;
}
uint256 percent = 9001;
for(uint256 i=0;i<numberOfDates-1;i++) {
if(now>=dates[i] && now<=dates[i+1] ) {
percent = percents[i];
i=numberOfDates-1;
}
}
if(percent==9001) {
throw;
}
uint256 tokensToGive = weiSent / pricePerToken;
if(tokensToGive * pricePerToken > weiSent) tokensToGive--;
tokensToGive=(tokensToGive*(100000+percent))/100000;
if(tokensToGive>numberOfTokensLeft) {
weiLeftOver = (tokensToGive - numberOfTokensLeft) * pricePerToken;
tokensToGive = numberOfTokensLeft;
}
numberOfTokensLeft -= tokensToGive;
if(addressExists[msg.sender]) {
balanceOf[msg.sender] += tokensToGive;
} else {
addAddress(msg.sender);
balanceOf[msg.sender] = tokensToGive;
}
Transfer(0x0,msg.sender,tokensToGive);
if(weiLeftOver>0)msg.sender.send(weiLeftOver);
}
| 1 | 389 |
function transfer(address _to, uint256 _value) public returns(bool){
require(msg.sender!=_to);
require(_value <= balanceOf(msg.sender));
setBalanceOf(msg.sender, balanceOf(msg.sender).sub(_value));
setBalanceOf(_to, balanceOf(_to).add(_value));
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 11,599 |
constructor(address _resolver)
public
{
require(init(CONTRACT_STORAGE_DAO_CONFIG, _resolver));
uintConfigs[CONFIG_LOCKING_PHASE_DURATION] = 10 days;
uintConfigs[CONFIG_QUARTER_DURATION] = QUARTER_DURATION;
uintConfigs[CONFIG_VOTING_COMMIT_PHASE] = 14 days;
uintConfigs[CONFIG_VOTING_PHASE_TOTAL] = 21 days;
uintConfigs[CONFIG_INTERIM_COMMIT_PHASE] = 7 days;
uintConfigs[CONFIG_INTERIM_PHASE_TOTAL] = 14 days;
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR] = 5;
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR] = 100;
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR] = 35;
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR] = 100;
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR] = 5;
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR] = 100;
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR] = 25;
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR] = 100;
uintConfigs[CONFIG_DRAFT_QUOTA_NUMERATOR] = 1;
uintConfigs[CONFIG_DRAFT_QUOTA_DENOMINATOR] = 2;
uintConfigs[CONFIG_VOTING_QUOTA_NUMERATOR] = 1;
uintConfigs[CONFIG_VOTING_QUOTA_DENOMINATOR] = 2;
uintConfigs[CONFIG_QUARTER_POINT_DRAFT_VOTE] = ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_VOTE] = ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_INTERIM_VOTE] = ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH] = 20000 * ONE_BILLION;
uintConfigs[CONFIG_BONUS_REPUTATION_NUMERATOR] = 15;
uintConfigs[CONFIG_BONUS_REPUTATION_DENOMINATOR] = 100;
uintConfigs[CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE] = 28 days;
uintConfigs[CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL] = 35 days;
uintConfigs[CONFIG_SPECIAL_QUOTA_NUMERATOR] = 1;
uintConfigs[CONFIG_SPECIAL_QUOTA_DENOMINATOR] = 2;
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR] = 40;
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR] = 100;
uintConfigs[CONFIG_MAXIMUM_REPUTATION_DEDUCTION] = 8334 * ONE_MILLION;
uintConfigs[CONFIG_PUNISHMENT_FOR_NOT_LOCKING] = 1666 * ONE_MILLION;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_NUM] = 1;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_DEN] = 1;
uintConfigs[CONFIG_MINIMAL_QUARTER_POINT] = 2 * ONE_BILLION;
uintConfigs[CONFIG_QUARTER_POINT_SCALING_FACTOR] = 400 * ONE_BILLION;
uintConfigs[CONFIG_REPUTATION_POINT_SCALING_FACTOR] = 2000 * ONE_BILLION;
uintConfigs[CONFIG_MODERATOR_MINIMAL_QUARTER_POINT] = 4 * ONE_BILLION;
uintConfigs[CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR] = 400 * ONE_BILLION;
uintConfigs[CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR] = 2000 * ONE_BILLION;
uintConfigs[CONFIG_PORTION_TO_MODERATORS_NUM] = 42;
uintConfigs[CONFIG_PORTION_TO_MODERATORS_DEN] = 1000;
uintConfigs[CONFIG_DRAFT_VOTING_PHASE] = 10 days;
uintConfigs[CONFIG_REPUTATION_POINT_BOOST_FOR_BADGE] = 412500 * ONE_MILLION;
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR] = 7;
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR] = 100;
uintConfigs[CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION] = 12500 * ONE_MILLION;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM] = 1;
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN] = 1;
uintConfigs[CONFIG_VOTE_CLAIMING_DEADLINE] = 10 days;
uintConfigs[CONFIG_MINIMUM_LOCKED_DGD] = 10 * ONE_BILLION;
uintConfigs[CONFIG_MINIMUM_DGD_FOR_MODERATOR] = 842 * ONE_BILLION;
uintConfigs[CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR] = 400 * ONE_BILLION;
uintConfigs[CONFIG_PREPROPOSAL_COLLATERAL] = 2 ether;
uintConfigs[CONFIG_MAX_FUNDING_FOR_NON_DIGIX] = 100 ether;
uintConfigs[CONFIG_MAX_MILESTONES_FOR_NON_DIGIX] = 5;
uintConfigs[CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER] = 80;
uintConfigs[CONFIG_PROPOSAL_DEAD_DURATION] = 90 days;
uintConfigs[CONFIG_CARBON_VOTE_REPUTATION_BONUS] = 10 * ONE_BILLION;
}
| 1 | 6,426 |
function onApprove(address _owner, address _spender, uint _amount) public returns(bool) {
return false;
}
| 1 | 1,476 |
function vetoMotion(uint motionID)
external
onlyOwner
{
require(!motionWaiting(motionID));
_closeMotion(motionID);
emit MotionVetoed(motionID, motionID);
}
| 1 | 2,240 |
function payout(address _to) public onlyCLevel {
_payout(_to);
}
| 0 | 10,578 |
function cbAddress()
public
view
returns (address _callbackAddress)
{
if (callbackAddresses[tx.origin] != 0)
_callbackAddress = tx.origin;
}
| 0 | 18,644 |
function to call the `tokenFallback` if the tokens
* @dev recepient is the smart-contract. If the contract doesn't implement
* @dev this function transaction fails
* @param _from address the tokens owner
* @param _to address the tokens recepient (perhaps the contract)
* @param _value uint amount of the tokens to be transferred
* @param _data bytes metadata
*/
function _safeTransfer(
address _from,
address _to,
uint _value,
bytes _data
)
internal
{
if (_to.isContract()) {
IERC223BasicReceiver receiver = IERC223BasicReceiver(_to);
receiver.tokenFallback(_from, _value, _data);
}
}
| 1 | 8,112 |
function sellNac(uint _value, address _buyer, uint _price) public returns (bool success) {
require(_price == bid[_buyer].price && _buyer != msg.sender);
NamiCrowdSale namiToken = NamiCrowdSale(NamiAddr);
uint ethOfBuyer = bid[_buyer].eth;
uint maxToken = ethOfBuyer.mul(bid[_buyer].price);
require(namiToken.allowance(msg.sender, this) >= _value && _value > 0 && ethOfBuyer != 0 && _buyer != 0x0);
if (_value > maxToken) {
if (msg.sender.send(ethOfBuyer) && namiToken.transferFrom(msg.sender,_buyer,maxToken)) {
bid[_buyer].eth = 0;
UpdateBid(_buyer, bid[_buyer].price, bid[_buyer].eth);
BuyHistory(_buyer, msg.sender, bid[_buyer].price, maxToken, now);
return true;
} else {
revert();
}
} else {
uint eth = _value.div(bid[_buyer].price);
if (msg.sender.send(eth) && namiToken.transferFrom(msg.sender,_buyer,_value)) {
bid[_buyer].eth = (bid[_buyer].eth).sub(eth);
UpdateBid(_buyer, bid[_buyer].price, bid[_buyer].eth);
BuyHistory(_buyer, msg.sender, bid[_buyer].price, _value, now);
return true;
} else {
revert();
}
}
}
| 1 | 992 |
function mintToken(address _to, uint256 _amount, uint256 _value) private returns(bool) {
require(tokensMinted.add(_amount) <= HARD_CAP_TOKENS);
weiRaised = weiRaised.add(_value);
token.mint(_to, _amount);
tokensMinted = tokensMinted.add(_amount);
emit TokenPurchase(_to, _value, _value.div(10**18), _amount, _amount.div(10**18), tokensMinted, tokensMinted.div(10**18));
return true;
}
| 1 | 7,032 |
function ReceiveBTC(address addr, uint value) public stopInEmergency ICOactive onlyBy(BTCproxy){
require(value >= 0.01 ether);
uint amount = amountToSend(value);
if (amount==0){
revert();
}else{
amountRaised += value;
tokenReward.transfer(addr,amount);
tokensSold = add(tokensSold,amount);
ReceivedBTC(addr,value);
}
}
| 1 | 4,997 |
function generateUniquePets(uint8 count) external onlyOwner whenNotPaused {
require(marketAddress != address(0));
require(address(geneScience) != address(0));
uint256 childGenes;
uint16 childQuality;
uint64 newPetId;
for(uint8 i = 0; i< count; i++)
{
if(tokensCount >= uniquePetsCount)
continue;
newPetId = tokensCount+1;
(childGenes, childQuality) = geneScience.uniquePet(newPetId);
createPet(childGenes, childQuality, marketAddress);
}
}
| 1 | 3,922 |
function setTokenAddress(address _address) onlyOwner returns (bool) {
require(_address != 0x0);
coin = PlatinumToken(_address);
token = _address;
return true;
}
| 1 | 2,972 |
function claimBondReward() onlyCEO {
creditDAOFund.claimBondReward();
}
| 0 | 11,578 |
function assignAll() public returns (bool) {
require(active_);
require(msg.gas > 7000000);
require(entrants.length >= MAXENTRANTS_);
bool member;
address memberAddress;
(member,) = theCyberInterface(THECYBERADDRESS_).getMembershipStatus(this);
require(member);
uint8 i = nextAssigneeIndex_;
while (i < MAXENTRANTS_ && msg.gas > 175000) {
(,,,,memberAddress) = theCyberInterface(THECYBERADDRESS_).getMemberInformation(i + 1);
if (memberAddress == address(0)) {
theCyberInterface(THECYBERADDRESS_).newMember(i + 1, bytes32(""), entrants[i]);
}
i++;
}
nextAssigneeIndex_ = i;
if (nextAssigneeIndex_ >= MAXENTRANTS_) {
active_ = false;
}
return true;
}
| 1 | 6,871 |
function confirmUpdate(
uint256 _streamId,
address _tokenAddress,
uint256 _stopBlock,
uint256 _payment,
uint256 _interval
)
public
streamExists(_streamId)
onlySenderOrRecipient(_streamId)
{
onlyNewTerms(
_streamId,
_tokenAddress,
_stopBlock,
_payment,
_interval
);
verifyTerms(
_tokenAddress,
block.number,
_stopBlock,
_interval
);
emit ConfirmUpdate(
_streamId,
msg.sender,
_tokenAddress,
_stopBlock,
_payment,
_interval
);
updates[_streamId][msg.sender] = true;
executeUpdate(
_streamId,
_tokenAddress,
_stopBlock,
_payment,
_interval
);
}
| 0 | 14,211 |
function listExists(LinkedList storage self)
internal
view returns (bool)
{
if (self.list[HEAD][PREV] != HEAD || self.list[HEAD][NEXT] != HEAD) {
return true;
} else {
return false;
}
}
| 0 | 18,688 |
function issueTokensFromOtherCurrency(address _to, uint _weiCount) onlyInState(State.ICORunning) public onlyOtherCurrenciesChecker {
require(_weiCount!=0);
uint newTokens = (_weiCount * getMntTokensPerEth(icoTokensSold)) / 1 ether;
require(newTokens<=MAX_SINGLE_ISSUED_FROM_OTHER_CURRENCIES);
require((issuedFromOtherCurrencies + newTokens)<=MAX_ISSUED_FROM_OTHER_CURRENCIES);
issueTokensInternal(_to,newTokens);
issuedFromOtherCurrencies = issuedFromOtherCurrencies + newTokens;
}
| 1 | 4,796 |
function finalize() onlyOwner public {
if (now < endTime) {
if (coinSentToEther == MAX_CAP) {
} else {
throw;
}
}
if (coinSentToEther < MIN_CAP && now < endTime + 5 days) throw;
if (!multisigEther.send(this.balance)) {
throw;
}
uint remains = coin.balanceOf(this);
if (remains > 0) {
if (!coin.burn(remains)) throw ;
}
crowdsaleClosed = true;
}
| 1 | 4,769 |
function removeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) external onlyAccess {
uint256 productionLoss;
if (upgradeClass == 0) {
unitCoinProductionIncreases[player][unitId] -= upgradeValue;
productionLoss = unitsOwned[player][unitId] * upgradeValue * (10 + unitCoinProductionMultiplier[player][unitId]);
reducePlayersJadeProduction(player, productionLoss);
} else if (upgradeClass == 1) {
unitCoinProductionMultiplier[player][unitId] -= upgradeValue;
productionLoss = unitsOwned[player][unitId] * upgradeValue * (schema.unitCoinProduction(unitId) + unitCoinProductionIncreases[player][unitId]);
reducePlayersJadeProduction(player, productionLoss);
} else if (upgradeClass == 2) {
unitAttackIncreases[player][unitId] -= upgradeValue;
} else if (upgradeClass == 3) {
unitAttackMultiplier[player][unitId] -= upgradeValue;
} else if (upgradeClass == 4) {
unitDefenseIncreases[player][unitId] -= upgradeValue;
} else if (upgradeClass == 5) {
unitDefenseMultiplier[player][unitId] -= upgradeValue;
} else if (upgradeClass == 6) {
unitJadeStealingIncreases[player][unitId] -= upgradeValue;
} else if (upgradeClass == 7) {
unitJadeStealingMultiplier[player][unitId] -= upgradeValue;
}
}
| 1 | 1,293 |
function ownerOf(uint256 _mineral_id) public view returns (address owner){
owner = minerals[_mineral_id].owner;
require(owner != address(0));
}
| 0 | 10,016 |
function partowners(address _address) public view returns (bool) {
return get(store, partownersStorage, _address);
}
| 0 | 11,065 |
function createSaleAuction(
uint256 _EtherDogId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _EtherDogId));
require(!isPregnant(_EtherDogId));
_approve(_EtherDogId, saleAuction);
saleAuction.createAuction(
_EtherDogId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 1 | 4,173 |
function doChargeCrowdsale(uint act) public onlyOwner{
lastActionId = act;
tokenAvailable = tokenReward.balanceOf(address(this));
if(tokenAvailable > 0){
charged = true;
emit IsCharged(charged);
}
}
| 1 | 2,535 |
function setICO2Phase() external onlyOwner {
currentPhase = Phase.ICO2;
StageChanged("Current stage: ICO2");
}
| 0 | 18,637 |
function buyChibiWithFcf(string _name, string _battleRoar, uint8 _region, uint _seed) public returns (bool success) {
require(fcfContract.balanceOf(msg.sender) >= 1 * 10 ** 18);
require(fcfPaused == false);
uint fcfBefore = fcfContract.balanceOf(address(this));
if (fcfContract.transferFrom(msg.sender, this, 1 * 10 ** 18)) {
_mint(_name, _battleRoar, _region, _seed, true, 0);
}
assert(fcfBefore == fcfContract.balanceOf(address(this)) - 1 * 10 ** 18);
return true;
}
| 1 | 1,907 |
function setPause () internal {
paused = true;
}
| 0 | 17,759 |
function buy(address _address, uint256 _value) internal returns (bool) {
if (_value == 0 || _address == address(0)) {
return false;
}
uint256 activeTier = getActiveTier();
if (activeTier == tiers.length) {
return false;
}
uint256 tokenAmount;
uint256 usdAmount;
uint256 mintedAmount;
(tokenAmount, usdAmount) = calculateTokensAmount(_value);
require(usdAmount > 0 && tokenAmount > 0);
if (activeTier >= PRE_ICO_TIER_FIRST && activeTier <= PRE_ICO_TIER_LAST) {
mintedAmount = mintPreICO(_address, tokenAmount, _value, usdAmount);
etherHolder.transfer(this.balance);
} else {
mintedAmount = mintInternal(_address, tokenAmount);
require(soldTokens <= maxTokenSupply.sub(preICOStats.maxTokenSupply));
collectedUSD = collectedUSD.add(usdAmount);
require(hardCap >= collectedUSD.add(preICOStats.collectedUSD) && usdAmount > 0 && mintedAmount > 0);
collectedEthers = collectedEthers.add(_value);
etherBalances[_address] = etherBalances[_address].add(_value);
icoBalances[_address] = icoBalances[_address].add(tokenAmount);
transferEthers();
}
Contribution(_address, _value, tokenAmount);
return true;
}
| 1 | 4,946 |
function EnclavesDEXProxy(address _storageAddress, address _implementation, address _admin, address _feeAccount, uint256 _feeTake, uint256 _feeAmountThreshold, address _etherDelta, bytes32 _tradeABIHash, bytes32 _withdrawABIHash) public
StorageConsumer(_storageAddress)
{
require(_implementation != address(0));
implementation = _implementation;
admin = _admin;
feeAccount = _feeAccount;
feeTake = _feeTake;
feeAmountThreshold = _feeAmountThreshold;
etherDelta = _etherDelta;
tradeABIHash = _tradeABIHash;
withdrawABIHash = _withdrawABIHash;
etherDeltaInfo.feeMake = EtherDeltaI(etherDelta).feeMake();
etherDeltaInfo.feeTake = EtherDeltaI(etherDelta).feeTake();
}
| 1 | 8,560 |
function, called internally when ethers are received
require(stage>0 && stage<3 && msg.value >= minAcceptedETH);
Whitelist wl = Whitelist(whitelistAdd);
if (stage==1 || stage==2 ) require(wl.registered(msg.sender));
ERC223 GXVCtoken = ERC223(tokenAdd);
address _address = msg.sender;
uint _value = msg.value;
uint _price = getPrice();
uint tokensToSend = _price * _value / 10 ** 18;
receivedFrom[_address] += _value;
totalReceived += _value;
sentTo[_address] += tokensToSend;
totalSent += tokensToSend;
require(GXVCtoken.transferFrom(tokenSpender,_address,tokensToSend));
TokensSent(_address,_value,tokensToSend);
require(collectorAddress.send(_value));
}
function getPrice() constant public returns(uint _price){
if (autoPrice) {
return calculatePrice(now);
}
| 1 | 6,033 |
function createSwap(bytes20 _secretHash, address _participantAddress, uint256 _value, address _token) public {
require(_value > 0);
require(swaps[msg.sender][_participantAddress].balance == uint256(0));
require(ERC20(_token).transferFrom(msg.sender, this, _value));
swaps[msg.sender][_participantAddress] = Swap(
_token,
_participantAddress,
bytes32(0),
_secretHash,
now,
_value
);
CreateSwap(now);
}
| 1 | 7,619 |
function resolvePriorBets() public{
while(betQueue[index].blockPlaced!=0){
if(betQueue[index+1].blockPlaced!=0){
if(betQueue[index+1].blockPlaced+250>block.number){
if(block.number>betQueue[index+1].blockPlaced){
uint totalbet=betQueue[index].betAmount+betQueue[index+1].betAmount;
uint randval= random(totalbet,betQueue[index+1].blockPlaced,betQueue[index+1].bettor);
if(randval < betQueue[index].betAmount){
payout(betQueue[index].bettor,totalbet);
emit BetFinalized(betQueue[index+1].bettor,betQueue[index+1].betAmount,betQueue[index].betAmount,0,victoryMessages[betQueue[index].bettor]);
emit BetFinalized(betQueue[index].bettor,betQueue[index].betAmount,betQueue[index+1].betAmount,totalbet,victoryMessages[betQueue[index].bettor]);
}
else{
payout(betQueue[index+1].bettor,totalbet);
emit BetFinalized(betQueue[index+1].bettor,betQueue[index+1].betAmount,betQueue[index].betAmount,totalbet,victoryMessages[betQueue[index+1].bettor]);
emit BetFinalized(betQueue[index].bettor,betQueue[index].betAmount,betQueue[index+1].betAmount,0,victoryMessages[betQueue[index+1].bettor]);
}
index+=2;
}
else{
return;
}
}
else{
payout(betQueue[index+1].bettor,betQueue[index+1].betAmount);
payout(betQueue[index].bettor,betQueue[index].betAmount);
index+=2;
emit BetFinalized(betQueue[index].bettor,betQueue[index].betAmount,betQueue[index+1].betAmount,betQueue[index].betAmount,"");
emit BetFinalized(betQueue[index+1].bettor,betQueue[index+1].betAmount,betQueue[index].betAmount,betQueue[index+1].betAmount,"");
}
}
else{
return;
}
}
}
| 1 | 1,151 |
function _calcPhase() internal view returns (int8) {
if (phase_i == PHASE_FINISHED || phase_i == PHASE_NOT_STARTED)
return phase_i;
uint curr_date = now;
if (curr_date >= ico_phase_5_end || token.balanceOf(base_wallet) == 0)
return PHASE_ICO_FINISHED;
if (curr_date < presale_start)
return PHASE_BEFORE_PRESALE;
if (curr_date <= presale_end)
return PHASE_PRESALE;
if (curr_date < ico_start)
return PHASE_BETWEEN_PRESALE_ICO;
if (curr_date < ico_phase_1_end)
return PHASE_ICO_1;
if (curr_date < ico_phase_2_end)
return PHASE_ICO_2;
if (curr_date < ico_phase_3_end)
return PHASE_ICO_3;
if (curr_date < ico_phase_4_end)
return PHASE_ICO_4;
return PHASE_ICO_5;
}
| 0 | 15,199 |
function issue(address account, uint amount)
external
onlySynthetixOrFeePool
{
tokenState.setBalanceOf(account, tokenState.balanceOf(account).add(amount));
totalSupply = totalSupply.add(amount);
emitTransfer(address(0), account, amount);
emitIssued(account, amount);
}
| 1 | 1,567 |
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
if ((_nbytes == 0)||(_nbytes > 32)) throw;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes[3] memory args = [unonce, nbytes, sessionKeyHash];
bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit);
oraclize_randomDS_setCommitment(queryId, sha3(bytes8(_delay), args[1], sha256(args[0]), args[2]));
return queryId;
}
| 1 | 3,171 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
_setBalances(msg.sender, _to, _value);
_sendFeesToMasternodes(masternode.transactionRewardInSubtokensRaw1e18);
Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 18,950 |
function autoTransfer() external onlyOwner {
TripioToken tripio = TripioToken(trioContract);
uint256[] memory _contributors = contributors();
for (uint256 i = 0; i < _contributors.length; i++) {
uint256 _cid = _contributors[i];
address _contributor = contributorChain.nodes[_cid].contributor;
uint256[] memory _schedules = schedules(_cid);
for (uint256 j = 0; j < _schedules.length; j++) {
uint256 _sid = _schedules[j];
uint256 _trio = scheduleChains[_cid].nodes[_sid].trio;
uint256 _timestamp = scheduleChains[_cid].nodes[_sid].timestamp;
if(_timestamp > now) {
break;
}
tripio.transfer(_contributor, _trio);
uint256[] memory _sids = new uint256[](1);
_sids[0] = _sid;
removeSchedules(_cid, _sids);
emit AutoTransfer(_contributor, _trio);
}
}
emit AutoTransferCompleted();
}
| 1 | 9,689 |
function _assignBuyoutProceeds(
address currentOwner,
uint256[] memory claimedSurroundingTiles,
uint256 fee,
uint256 currentOwnerWinnings,
uint256 totalDividendPerBeneficiary,
uint256 referralBonus,
uint256 prizePoolFunds
)
internal
{
if (currentOwner != 0x0) {
_sendFunds(currentOwner, currentOwnerWinnings);
} else {
uint256 prizePoolPart = currentOwnerWinnings.mul(gameSettings.firstBuyoutPrizePoolPercentage).div(100000);
prizePoolFunds = prizePoolFunds.add(prizePoolPart);
fee = fee.add(currentOwnerWinnings.sub(prizePoolPart));
}
for (uint256 i = 0; i < claimedSurroundingTiles.length; i++) {
address beneficiary = gameStates[gameIndex].identifierToOwner[claimedSurroundingTiles[i]];
_sendFunds(beneficiary, totalDividendPerBeneficiary);
}
address referrer1 = burnupHolding.referrerOf(msg.sender);
if (referrer1 != 0x0) {
_sendFunds(referrer1, referralBonus);
address referrer2 = burnupHolding.referrerOf(referrer1);
if (referrer2 != 0x0) {
_sendFunds(referrer2, referralBonus);
} else {
fee = fee.add(referralBonus);
}
} else {
fee = fee.add(referralBonus.mul(2));
}
burnupHolding.payBeneficiaries.value(fee)();
gameStates[gameIndex].prizePool = gameStates[gameIndex].prizePool.add(prizePoolFunds);
}
| 1 | 7,106 |
function withdraw(uint amount) payable {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
}
}
}
| 0 | 18,353 |
function giveBirth(uint256 _matronId)
external
whenNotPaused
returns(uint256)
{
Kitty storage matron = kitties[_matronId];
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.siringWithId;
Kitty storage sire = kitties[sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);
address owner = kittyIndexToOwner[_matronId];
uint256 kittenId = _createKitty(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner);
delete matron.siringWithId;
pregnantKitties--;
msg.sender.send(autoBirthFee);
return kittenId;
}
| 1 | 4,160 |
function setARKowner(address a) {
if(msg.sender!=owner)throw;
Ark.initStats("",a,333);
logs.push(log(msg.sender,"setARKowner",0,0x0));
}
| 1 | 4,287 |
function doStateChanges() public {
var (returnedCurrentEntityState, EntityStateRequired) = getRequiredStateChanges();
bool callAgain = false;
DebugEntityRequiredChanges( assetName, returnedCurrentEntityState, EntityStateRequired );
if(EntityStateRequired != getEntityState("__IGNORED__") ) {
EntityProcessor(EntityStateRequired);
callAgain = true;
}
}
| 1 | 2,230 |
function transfer(address _toAddress, uint256 _amountOfTokens)
public
returns(bool)
{
address _customerAddress = msg.sender;
require( _amountOfTokens <= balanceOf[_customerAddress] );
if (_amountOfTokens>0)
{
{
balanceOf[_customerAddress] = balanceOf[_customerAddress].sub( _amountOfTokens );
balanceOf[ _toAddress] = balanceOf[ _toAddress].add( _amountOfTokens );
}
}
emit onTransfer(_customerAddress, _toAddress, _amountOfTokens);
return true;
}
| 0 | 10,348 |
function internalContribution(address _contributor, uint256 _wei) internal {
require(getState() == State.InCrowdsale);
uint256 tokensAvailable = allocator.tokensAvailable();
uint256 collectedWei = contributionForwarder.weiCollected();
uint256 tokens;
uint256 tokensExcludingBonus;
uint256 bonus;
(tokens, tokensExcludingBonus, bonus) = pricingStrategy.getTokens(
_contributor, tokensAvailable, tokensSold, _wei, collectedWei);
require(tokens <= tokensAvailable && tokens > 0 && false == isHardCapAchieved(tokens.sub(1)));
tokensSold = tokensSold.add(tokens);
allocator.allocate(_contributor, tokens);
if (msg.value > 0) {
contributionForwarder.forward.value(msg.value)();
}
crowdsaleAgent.onContribution(_contributor, _wei, tokensExcludingBonus, bonus);
emit Contribution(_contributor, _wei, tokensExcludingBonus, bonus);
}
| 1 | 174 |
function runPreMint(address _target, uint256 _amount) public onlyOwner {
if (preSaleMode)
{
token.mint(_target, _amount);
emit TokenPurchase(owner, _target, 0, _amount);
initialTokenAmount = token.totalSupply();
}
}
| 1 | 1,903 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
bytes memory _data = new bytes(1);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 1 | 9,291 |
function deploy(uint256 index, bytes data) public whenNotPaused {
address mtkn = deployers[index].deploy(data);
multitokens.push(mtkn);
emit NewMultitoken(mtkn);
}
| 1 | 8,752 |
function () public payable {
if(msg.value == 0 && msg.sender == last.depositor) {
require(gasleft() >= 220000, "We require more gas!");
require(last.blockNumber + 45 < block.number, "Last depositor should wait 45 blocks (~10 minutes) to claim reward");
uint128 money = uint128((address(this).balance));
if(money >= last.expect){
last.depositor.transfer(last.expect);
} else {
last.depositor.transfer(money);
}
delete last;
}
else if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= MAX_DEPOSIT && msg.value >= MIN_DEPOSIT);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
last.depositor = msg.sender;
last.expect += msg.value*LAST_DEPOSIT_PERCENT/100;
last.blockNumber = block.number;
txnCount += 1;
if(txnCount >= 1800) {
MIN_DEPOSIT = 0.1 ether;
} else if(txnCount >= 1600) {
MIN_DEPOSIT = 0.09 ether;
} else if(txnCount >= 1400) {
MIN_DEPOSIT = 0.08 ether;
} else if(txnCount >= 1200) {
MIN_DEPOSIT = 0.07 ether;
} else if(txnCount >= 1000) {
MIN_DEPOSIT = 0.06 ether;
} else if(txnCount >= 800) {
MIN_DEPOSIT = 0.05 ether;
} else if(txnCount >= 600) {
MIN_DEPOSIT = 0.04 ether;
} else if(txnCount >= 400) {
MIN_DEPOSIT = 0.03 ether;
} else if(txnCount >= 200) {
MIN_DEPOSIT = 0.02 ether;
} else {
MIN_DEPOSIT = 0.01 ether;
}
uint promo = msg.value*PROMO_PERCENT/10000;
uint128 contractBalance = uint128((address(this).balance));
if(contractBalance >= promo){
PROMO.transfer(promo);
} else {
PROMO.transfer(contractBalance);
}
PROMO_PERCENT += 5;
pay();
}
}
| 0 | 16,707 |
function CWCfallback(address _from, uint _value, bytes _data) public {
require(msg.sender == CWC_Address);
require(!pauseDET);
require(_value>minCWCsPerSaleMoreThan && _value<maxCWCsPerSaleLessThan);
if (oraclize_getPrice("URL") > this.balance) {
needsEther("Oraclize query for DET sale was NOT sent, please add some ETH to cover for the query fee");
revert();
}
else {
tickerQueryData = strConcat("3,", "DET,", "0x", addressToAsciiString(_from), ",");
tickerQueryData = strConcat(tickerQueryData, uint2str(_value), ",", uint2str(totalDETsSold));
bytes32 queryId = oraclize_query("URL", tickerQuery, tickerQueryData);
tickerQueryIds[queryId] = true;
tickerQueryPurpose[queryId] = 1;
waitingBuyer[queryId] = _from;
cwcPaid[queryId] = _value;
receivedCWC(waitingBuyer[queryId], cwcPaid[queryId]);
newTickerQuery("Called Oraclize for DET sale. Waiting…", queryId);
}
}
| 1 | 3,408 |
function grant(address _to, uint256 _value, uint256 _start, uint256 _cliff, uint256 _end,
uint256 _installmentLength, bool _revokable)
external onlyOwner {
require(_to != address(0));
require(_to != address(this));
require(_value > 0);
require(grants[_to].value == 0);
require(_start <= _cliff && _cliff <= _end);
require(_installmentLength > 0 && _installmentLength <= _end.sub(_start));
require(totalVesting.add(_value) <= kin.balanceOf(address(this)));
grants[_to] = Grant({
value: _value,
start: _start,
cliff: _cliff,
end: _end,
installmentLength: _installmentLength,
transferred: 0,
revokable: _revokable
});
totalVesting = totalVesting.add(_value);
NewGrant(msg.sender, _to, _value);
}
| 1 | 1,538 |
function guess(uint _pokemonId) public payable{
require(isPaused == false);
assert(msg.value > 0);
assert(_pokemonId == publicBattlepm1 || _pokemonId == publicBattlepm2);
uint256 calcValue = msg.value;
uint256 cutFee = calcValue.div(16);
calcValue = calcValue - cutFee;
pokemonContract.getPokemonOwner(_pokemonId).transfer(cutFee.div(2));
devFeeAddress.transfer(cutFee.div(2));
totalGuess += calcValue;
pokemonGuessNumber[_pokemonId]++;
pokemonGuessPrize[_pokemonId] = pokemonGuessPrize[_pokemonId] + calcValue;
if(_pokemonId == publicBattlepm1){
if(playerGuessPM1Number[msg.sender] != 0){
playerGuessPM1Number[msg.sender] = playerGuessPM1Number[msg.sender] + calcValue;
}else{
pokemonGuessPlayers[_pokemonId].push(msg.sender);
playerGuessPM1Number[msg.sender] = calcValue;
}
}else{
if(playerGuessPM2Number[msg.sender] != 0){
playerGuessPM2Number[msg.sender] = playerGuessPM2Number[msg.sender] + calcValue;
}else{
pokemonGuessPlayers[_pokemonId].push(msg.sender);
playerGuessPM2Number[msg.sender] = calcValue;
}
}
if(pokemonGuessNumber[publicBattlepm1] + pokemonGuessNumber[publicBattlepm2] > 20){
startpublicBattle(publicBattlepm1, publicBattlepm2);
}
}
| 1 | 2,292 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.