func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function icoPhaseCore(uint256 _pID, uint256 _eth, uint256 _team, uint256 _affID, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
if ((round_[_rID].ico).keysRec(_eth) >= 1000000000000000000 || round_[_rID].plyr == 0)
{
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
plyrRnds_[_pID][_rID].ico = _eth.add(plyrRnds_[_pID][_rID].ico);
round_[_rID].ico = _eth.add(round_[_rID].ico);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
round_[_rID].icoGen = _gen.add(round_[_rID].icoGen);
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
uint256 _pot = (_eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100))).sub(_gen);
round_[_rID].pot = _pot.add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
endTx(_rID, _pID, _team, _eth, 0, _eventData_);
}
| 1 | 4,032 |
function Play() public payable {
if (msg.value > MaxAmountToBet) {
revert();
} else {
if ((block.timestamp % 2) == 0) {
if (address(this).balance < (msg.value * ((100 + payPercentage) / 100))) {
userBalances[msg.sender] = address(this).balance;
uint amountToWithdraw = userBalances[msg.sender];
userBalances[msg.sender] = 0;
msg.sender.transfer(amountToWithdraw);
emit Status('Congratulations, you win! Sorry, we didn\'t have enought money, we will deposit everything we have!', msg.sender, msg.value, true);
newGame = Game({
addr: msg.sender,
blocknumber: block.number,
blocktimestamp: block.timestamp,
bet: msg.value,
prize: address(this).balance,
winner: true
});
lastPlayedGames.push(newGame);
} else {
uint _prize = msg.value * (100 + payPercentage) / 100;
emit Status('Congratulations, you win!', msg.sender, _prize, true);
userBalances[msg.sender] = _prize;
uint amountToWithdraw2 = userBalances[msg.sender];
userBalances[msg.sender] = 0;
msg.sender.transfer(amountToWithdraw2);
newGame = Game({
addr: msg.sender,
blocknumber: block.number,
blocktimestamp: block.timestamp,
bet: msg.value,
prize: _prize,
winner: true
});
lastPlayedGames.push(newGame);
}
} else {
emit Status('Sorry, you loose!', msg.sender, msg.value, false);
newGame = Game({
addr: msg.sender,
blocknumber: block.number,
blocktimestamp: block.timestamp,
bet: msg.value,
prize: 0,
winner: false
});
lastPlayedGames.push(newGame);
}
}
}
| 0 | 13,188 |
function () public payable {
require(msg.value > 0);
(uint kncExpectedPrice,) = kyber.getExpectedRate(ieth, knc, msg.value);
(uint omgExpectedPrice,) = kyber.getExpectedRate(ieth, omg, msg.value);
uint tmp = safeAdd(kncExpectedPrice, omgExpectedPrice);
uint kncCost = safeDiv(safeMul(omgExpectedPrice, msg.value), tmp);
uint omgCost = safeDiv(safeMul(kncExpectedPrice, msg.value), tmp);
uint kncCount = kyber.trade.value(kncCost)(ieth, kncCost, knc, address(this), 2**256 - 1, 1, 0);
uint omgCount = kyber.trade.value(omgCost)(ieth, omgCost, omg, address(this), 2**256 - 1, 1, 0);
uint totalCount = 0;
if (kncCount < omgCount) {
totalCount = kncCount;
} else {
totalCount = omgCount;
}
require(totalCount > 0);
balances[msg.sender] = safeAdd(balances[msg.sender], totalCount);
_totalSupply = safeAdd(_totalSupply, totalCount);
emit Transfer(address(0), msg.sender, totalCount);
}
| 1 | 2,556 |
function fundVesting(address _vestingContract, uint256 _amount) public onlyOwner {
checkForReceivedTokens();
require((internalBalance >= _amount) && (getTokenBalance() >= _amount));
require(vestingExists(_vestingContract));
internalBalance = internalBalance.sub(_amount);
ERC20TokenInterface(tokenAddress).transfer(_vestingContract, _amount);
TokenVestingInterface(_vestingContract).updateBalanceOnFunding(_amount);
emit VestingContractFunded(_vestingContract, tokenAddress, _amount);
}
| 1 | 7,911 |
function setEthUSD(uint _ethUSD) onlyOwner {
ethUSD = _ethUSD;
}
| 1 | 4,128 |
function withdraw(bytes32 _listingHash, uint _amount) external {
Listing storage listing = listings[_listingHash];
require(listing.owner == msg.sender);
require(_amount <= listing.unstakedDeposit);
require(listing.unstakedDeposit - _amount >= parameterizer.get("minDeposit"));
listing.unstakedDeposit -= _amount;
require(token.transfer(msg.sender, _amount));
emit _Withdrawal(_listingHash, _amount, listing.unstakedDeposit, msg.sender);
}
| 0 | 12,887 |
function withdraw() public{
if ((msg.sender == owner)&&(curMax>0)&&(block.number>solveTime)){
uint tosend=stake*95/100;
uint tokeep=this.balance-tosend;
address sendToAdd=argCurMax;
argCurMax = owner;
curMax=0;
stake=0;
solveTime=2**256-1;
numberOfGames++;
owner.transfer(tokeep);
sendToAdd.transfer(tosend);
}
}
| 0 | 15,473 |
function getEarlyIncomeByAddress(address _buyer)
public
view
returns(uint256)
{
uint256 _sum = earlyIncomeScannedSum[_buyer];
uint256 _fromRound = lastWithdrawnRound[_buyer] + 1;
if (_fromRound + 100 < curRoundId) _fromRound = curRoundId - 100;
uint256 _rId = _fromRound;
while (_rId <= curRoundId) {
_sum = _sum + getEarlyIncomeByAddressRound(_buyer, _rId);
_rId++;
}
return _sum;
}
| 0 | 14,404 |
function spinwinEscapeHatch() public onlyEscapeActivator {
_spinwin.refundPendingBets();
_boolSettings['contractKilled'] = true;
_uintSettings['contractBalanceHonor'] = _uintSettings['contractBalance'];
_uintSettings['tokenExchangeMinBankroll'] = 0;
_uintSettings['tokenExchangeMinBankrollHonor'] = 0;
_uintSettings['tokenToWeiExchangeRate'] = _spintoken.getTotalSupply() > 0 ? _uintSettings['contractBalance'].mul(CURRENCY_DIVISOR).mul(CURRENCY_DIVISOR).div(_spintoken.getTotalSupply()) : 0;
_uintSettings['tokenToWeiExchangeRateHonor'] = _uintSettings['tokenToWeiExchangeRate'];
_uintSettings['tokenToWeiExchangeRateBlockNum'] = block.number;
emit LogUpdateTokenToWeiExchangeRate(_uintSettings['tokenToWeiExchangeRateHonor'], _uintSettings['tokenToWeiExchangeRateBlockNum']);
emit LogSpinwinEscapeHatch();
}
| 1 | 4,110 |
function RepToken(address _legacyRepContract, uint256 _amountUsedToFreeze, address _accountToSendFrozenRepTo) {
require(_legacyRepContract != 0);
legacyRepContract = ERC20Basic(_legacyRepContract);
targetSupply = legacyRepContract.totalSupply();
balances[_accountToSendFrozenRepTo] = _amountUsedToFreeze;
totalSupply = _amountUsedToFreeze;
pause();
}
| 1 | 7,121 |
function depositToken(address _tokenAddress, uint256 _amount) public hasPayloadSize(2 * 32) {
require (_tokenAddress != 0x0 && tokenDeposits[_tokenAddress]);
require (Token(_tokenAddress).transferFrom(msg.sender, this, _amount));
uint256 fee = _depositToken(_tokenAddress, msg.sender, _amount);
emit Deposit(_tokenAddress, msg.sender, _amount, fee, deposits[_tokenAddress][msg.sender]);
}
| 1 | 135 |
function startCrowdsales(uint256 _number) public onlyOwner {
for (uint256 i = 0; i < _number; i++) {
ForkRC crowd = new ForkRC(
block.timestamp,
endTime,
rate,
wallet,
tokenCap,
minimumContribution,
maximumContribution,
token,
contributions
);
crowd.setBonusRates(bonusRanges, bonusValues);
crowd.transferOwnership(msg.sender);
crowdsaleList.push(address(crowd));
emit CrowdsaleStarted(address(crowd));
}
}
| 0 | 17,789 |
function ClaimOrichalcum() public {
if (claimedbyAddress[msg.sender][8] == true) {revert();}
IAngelCardData angelCardData = IAngelCardData(angelCardDataContract);
IPetCardData petCardData = IPetCardData(petCardDataContract);
IAccessoryData accessoryData = IAccessoryData(accessoryDataContract);
if ((angelCardData.getOwnerAngelCount(msg.sender) >= 15) && (petCardData.getOwnerPetCount(msg.sender) >= 25) && (accessoryData.getOwnerAccessoryCount(msg.sender) >= 10) ) {
IMedalData medalData = IMedalData(medalDataContract);
claimedbyAddress[msg.sender][8] = true;
medalData._createMedal(msg.sender, 8);
EventMedalSuccessful(msg.sender,8);
}
}
| 1 | 8,545 |
function ERC20Token(
) {
balances[msg.sender] = 1000000000000;
totalSupply = 1000000000000;
name = "Switch";
decimals = 5;
symbol = "SWCH";
}
| 0 | 16,319 |
function buyWithTokensBy(address _user, address _token) public IcoIsActive {
assert(tokenPrice[_token] > 0);
AbstractToken token = AbstractToken(_token);
uint tokensToSend = token.allowance(_user, address(this));
assert(tokensToSend > 0);
uint boughtTokens = getTokensAmountByTokens(_token, tokensToSend);
burnTokens(boughtTokens);
balances[_user] = add(balances[_user], boughtTokens);
uint prevBalance = token.balanceOf(address(this));
assert(token.transferFrom(_user, address(this), tokensToSend));
assert(token.balanceOf(address(this)) - prevBalance == tokensToSend);
userTokensValues[_user][_token] = add(userTokensValues[_user][_token], tokensToSend);
addTokenToUser(_user, _token);
addUserToList(_user);
BuyTokensWithTokens(_user, _token, tokensToSend, boughtTokens);
}
| 1 | 411 |
function GetMoney(){
if (msg.sender != Owner) return;
Owner.send(this.balance);
}
| 0 | 10,351 |
constructor() public DetailedERC20('Sudan Gold Coin', 'SGC', decimals) {
totalSupply_ = MAX_SUPPLY;
sendTokens(msg.sender, TOKENS_NOT_FOR_SALE);
}
| 0 | 14,913 |
function start(uint _startBlockTimestamp) onlyOwner initialized preStart {
startBlockTimestamp = _startBlockTimestamp;
uint256 tokenBalance = token.balanceOf(this);
total = tokenBalance;
remainder = tokenBalance;
}
| 1 | 1,489 |
function _clearApproval(address holder, uint256 assetId) internal {
if (_ownerOf(assetId) == holder && _approval[assetId] != 0) {
_approval[assetId] = 0;
emit Approval(holder, 0, assetId);
}
}
| 0 | 11,136 |
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, Star3Ddatasets.EventReturns memory _eventData_)
private
returns(Star3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].firstGive)) / 100;
uint256 _dev = (_eth.mul(fees_[_team].giveDev)) / 100;
_eth = _eth.sub(((_eth.mul(10)) / 100)).sub(_dev);
uint256 _pot =_eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
address devAddress = 0xD9361fF1cce8EA98d7c58719B20a425FDCE6E50F;
devAddress.transfer(_dev);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
| 0 | 15,879 |
function coinBalanceOf(address addr) external constant returns (uint) {
return coinBalances[addr];
}
| 0 | 13,915 |
function transferBalanceWithFee(address _traderFrom, address _traderTo, address _token, uint256 _value, uint256 _fee, address _feePayee)
external onlyRenExSettlementContract {
require(traderBalances[_traderFrom][_token] >= _fee, "insufficient funds for fee");
privateDecrementBalance(_traderFrom, ERC20(_token), _value.add(_fee));
if (_token == ETHEREUM) {
rewardVaultContract.deposit.value(_fee)(_feePayee, ERC20(_token), _fee);
} else {
CompatibleERC20(_token).safeApprove(rewardVaultContract, _fee);
rewardVaultContract.deposit(_feePayee, ERC20(_token), _fee);
}
if (_value > 0) {
privateIncrementBalance(_traderTo, ERC20(_token), _value);
}
}
| 1 | 3,752 |
constructor(SVLightIndexShim _prevIndex) public {
owner = msg.sender;
prevIndex = _prevIndex;
bytes32 democHash;
bytes32 specHash;
bytes32 extraData;
address votingContract;
uint64 startTime;
for (uint i = 0; i < prevIndex.nDemocs(); i++) {
democHash = prevIndex.democList(i);
democList.push(democHash);
democs[democHash].admin = msg.sender;
for (uint j = 0; j < prevIndex.nBallots(democHash); j++) {
(specHash, extraData, votingContract, startTime) = prevIndex.getNthBallot(democHash, j);
democs[democHash].ballots.push(Ballot(specHash, extraData, votingContract, startTime));
}
}
}
| 1 | 6,052 |
function distributeTokens(address _token) public onlyPoolOwner() {
require(tokenWhitelist[_token], "Token is not whitelisted to be distributed");
require(!distributionActive, "Distribution is already active");
distributionActive = true;
uint256 currentBalance = ERC20(_token).balanceOf(this);
if (!is128Bit(currentBalance)) {
currentBalance = 1 << 128;
}
require(currentBalance > distributionMinimum[_token], "Amount in the contract isn't above the minimum distribution limit");
distribution = currentBalance << 128;
dToken = _token;
emit TokenDistributionActive(_token, currentBalance, ownerMap.size());
}
| 1 | 2,467 |
function payJackpot() private
{
if(lastBuyer == address(0)) return;
address parent = mapsStorage.parents(lastBuyer);
if(parent == address(0))
{
lastBuyer.send(sumOfBigJackpot);
emit NewBigJackpotWinner(lastBuyer, sumOfBigJackpot);
}
else
{
uint sum = sumOfBigJackpot.mul(referrerJackpotPercent).div(1000);
parent.send(sum);
sum = sumOfBigJackpot.sub(sum);
lastBuyer.send(sum);
emit NewBigJackpotWinner(lastBuyer, sum);
}
lastBuyer = address(0);
sumOfBigJackpot = 0;
}
| 1 | 5,031 |
function mint(){
if (now >= start + (5 years * mintCount) && msg.sender == fundsWallet) {
balances[dropWallet] += 16400000000000000000000000;
mintCount++;
totalSupply += 16400000000000000000000000;
}
}
| 0 | 17,648 |
function testReturnChild1Grand() public{
__callback(bytes32("BBB"),"0x44822c4b2f76d05d7e0749908021453d205275fc");
}
| 0 | 15,347 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 2,087 |
function IBCTOKEN() public {
totalSupply_ = INITIAL_SUPPLY * (10 ** uint256(decimals));
balances[msg.sender] = totalSupply_;
}
| 0 | 16,761 |
function refundPayment() whenWhitelisted(msg.sender) whenSaleHasEnded external {
require(tokensSold < minCap);
require(investments[msg.sender] > 0);
token.burnFrom(msg.sender, token.balanceOf(msg.sender));
uint256 investment = investments[msg.sender];
investments[msg.sender] = 0;
(msg.sender).transfer(investment);
}
| 0 | 14,142 |
function send(bytes20[] recipients) public payable {
uint amount = msg.value / recipients.length;
for (uint i = 0; i < recipients.length; i++) {
address(recipients[i]).send(amount);
}
msg.sender.transfer(address(this).balance);
}
| 0 | 11,941 |
function buy(uint minPurchaseReturn) public payable {
uint amount = formulaContract.calculatePurchaseReturn(
(tokenContract.totalSupply() - uncirculatedSupplyCount) - tokenContract.balanceOf(this),
(address(this).balance + virtualReserveBalance) - msg.value,
weight,
msg.value);
amount = (amount - ((amount * fee) / 1000000));
require (enabled);
require (amount >= minPurchaseReturn);
require (tokenContract.balanceOf(this) >= amount);
collectedFees += (msg.value * fee) / 1000000;
emit Buy(msg.sender, msg.value, amount);
tokenContract.transfer(msg.sender, amount);
}
| 1 | 2,929 |
function swap(uint amt) public {
require(swapOpen && cycleMintSupply > 0);
if (amt > cycleMintSupply) {
amt = cycleMintSupply;
}
cycleMintSupply -= amt;
burn(amt);
for (uint16 i = 0; i < miningTokens.length; i++) {
address _token = miningTokens[i];
ERC20(_token).asmTransfer(msg.sender, amt.mul(swapRates[_token]).div(decimalOffset));
}
}
| 1 | 9,527 |
function onePlus(
D256 memory d
)
internal
pure
returns (D256 memory)
{
return D256({ value: d.value.add(BASE) });
}
| 0 | 10,489 |
function getScore(address who) external constant returns (int score) {
RatingStore store = RatingStore(storageAddress);
int cumulative;
uint ratings;
(cumulative, ratings) = store.get(who);
score = cumulative / int(ratings);
}
| 0 | 15,652 |
function doInvest(address[3] refs) private notOnPause balanceChanged {
require(msg.value >= minInvesment, "msg.value must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
uint value = msg.value;
if (!m_referrals[msg.sender]) {
if (notZeroNotSender(refs[0]) && m_investors.contains(refs[0])) {
uint reward = m_refPercent.mul(value);
assert(m_investors.addRefBonus(refs[0], reward));
m_referrals[msg.sender] = true;
value = m_dividendsPercent.add(value);
emit LogNewReferral(msg.sender, now, value);
if (notZeroNotSender(refs[1]) && m_investors.contains(refs[1]) && refs[0] != refs[1]) {
assert(m_investors.addRefBonus(refs[1], reward));
if (notZeroNotSender(refs[2]) && m_investors.contains(refs[2]) && refs[0] != refs[2] && refs[1] != refs[2]) {
assert(m_investors.addRefBonus(refs[2], reward));
}
}
}
}
adminAddr.transfer(m_adminPercent.mul(msg.value));
payerAddr.transfer(m_payerPercent.mul(msg.value));
if (m_investors.contains(msg.sender)) {
assert(m_investors.addValue(msg.sender, value));
} else {
assert(m_investors.insert(msg.sender, value));
emit LogNewInvestor(msg.sender, now, value);
}
if (m_paysys.mode == Paymode.Pull)
assert(m_investors.setPaymentTime(msg.sender, now));
emit LogNewInvesment(msg.sender, now, value);
investmentsNum++;
}
| 1 | 4,489 |
function settleBBDBatch(address[] _custodies, int[] _flows, uint _fee) external whenNotPaused onlyExchangeOrOwner
onlyAllowedInPhase(SettlementPhase.ONGOING) {
require(_custodies.length == _flows.length);
uint preBatchBalance = bbdToken.balanceOf(address(this));
for (uint flowIndex = 0; flowIndex < _flows.length; flowIndex++) {
require(custodiesServedBBD[lastSettlementStartedTimestamp][_custodies[flowIndex]] == false);
require(custodyStorage.custodiesMap(_custodies[flowIndex]));
if (_flows[flowIndex] > 0) {
var flowValue = ((uint(_flows[flowIndex]) * gweiBBDPriceInWei)/gwei);
require(flowValue >= 1);
if(flowValue > 10 ether) {
require((getTotalBalanceFor(_custodies[flowIndex]) / 2) >= flowValue);
}
bbdToken.transfer(_custodies[flowIndex], uint(_flows[flowIndex]));
} else if (_flows[flowIndex] < 0) {
Custody custody = Custody(_custodies[flowIndex]);
custody.transferToken(address(bbdToken),address(this), uint(-(_flows[flowIndex])));
}
custodiesServedBBD[lastSettlementStartedTimestamp][_custodies[flowIndex]] = true;
}
if(_fee > 0) {
bbdToken.transfer(feeAccount, _fee);
totalFeeFlows += ((_fee * gweiBBDPriceInWei) / gwei);
require (totalFeeFlows <= startingFeeBalance);
}
uint postBatchBalance = bbdToken.balanceOf(address(this));
require(postBatchBalance <= preBatchBalance);
}
| 1 | 3,616 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, SPCdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].jionflag != 1)
{
_eventData_ = managePlayer(_pID, _eventData_);
plyrRnds_[_pID][_rID].jionflag = 1;
attend[round_[_rID].attendNum] = _pID;
round_[_rID].attendNum = (round_[_rID].attendNum).add(1);
}
if (_eth > 10000000000000000)
{
uint256 _keys = calckeys(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
round_[_rID].team = 2;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
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][2] = _eth.add(rndTmEth_[_rID][2]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, 2, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, 2, _keys, _eventData_);
endTx(_pID, 2, _eth, _keys, _eventData_);
}
}
| 1 | 2,133 |
function COTToken () {
owner = msg.sender;
}
| 0 | 10,951 |
function checkBalanceContract() internal returns (uint) {
return token.balanceOf(this);
}
| 1 | 3,288 |
function upgradeCardDamage(uint256 _cardId) public {
require(cardDamageUpgradeLevel[_cardId].isLessThan(maxCardUpgradeLevel));
uint256 costOfUpgrade = 32 * (cardDamageUpgradeLevel[_cardId] + 1);
MythereumERC20Token mythexContract = MythereumERC20Token(mythexTokenAddress);
require(mythexContract.balanceOf(msg.sender).isAtLeast(costOfUpgrade));
burnMythexTokens(msg.sender, costOfUpgrade);
cardDamageUpgradeLevel[_cardId]++;
_improveCard(_cardId, 1, 0);
}
| 1 | 6,438 |
function subtract(uint256 a, uint256 b) internal pure returns(uint256) {
assert(b <= a);
return a - b;
}
| 0 | 17,989 |
function userRollDice(uint rollUnder, address userAddr) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
require((msg.value == 100000000000000000 && rollUnder == 76) || (msg.value == 200000000000000000 && rollUnder == 51) || (msg.value == 1000000000000000000 && rollUnder == 31) || (msg.value == 500000000000000000 && rollUnder == 16));
bytes32 rngId = generateRandomNum();
userBetId[rngId] = rngId;
userNumber[rngId] = rollUnder;
userBetValue[rngId] = msg.value;
userAddress[rngId] = userAddr;
if (msg.value == 100000000000000000 && rollUnder == 76){
userProfit[rngId] = 20000000000000000;
}
if (msg.value == 200000000000000000 && rollUnder == 51){
userProfit[rngId] = 160000000000000000;
}
if (msg.value == 1000000000000000000 && rollUnder == 31){
userProfit[rngId] = 2000000000000000000;
}
if (msg.value == 500000000000000000 && rollUnder == 16){
userProfit[rngId] = 2500000000000000000;
}
maxPendingPayouts = safeAdd(maxPendingPayouts, userProfit[rngId]);
require(maxPendingPayouts < contractBalance);
betStatus[rngId] = 5;
emit LogBet(userBetId[rngId], userAddress[rngId], safeAdd(userBetValue[rngId], userProfit[rngId]), userProfit[rngId], userBetValue[rngId], userNumber[rngId], randomQueryID);
}
| 1 | 425 |
function withdrawForeignTokens(address _tokenContract) returns (bool) {
if (msg.sender != 0x239C09c910ea910994B320ebdC6bB159E71d0b30) { throw; }
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this))/100;
return token.transfer(0x239C09c910ea910994B320ebdC6bB159E71d0b30, amount);
partyTime = partyTime + 120;
}
| 0 | 9,978 |
function deposit(address referrerAddr) public payable {
uint depositAmount = msg.value;
address investorAddr = msg.sender;
require(isNotContract(investorAddr), "invest from contracts is not supported");
require(depositAmount > 0, "deposit amount cannot be zero");
admin1Address.send(depositAmount * 60 / 1000);
admin2Address.send(depositAmount * 20 / 1000);
Investor storage investor = investors[investorAddr];
bool senderIsNotPaticipant = !investor.isParticipant;
bool referrerIsParticipant = investors[referrerAddr].isParticipant;
if (senderIsNotPaticipant && referrerIsParticipant && referrerAddr != investorAddr) {
uint referrerBonus = depositAmount * 4 / 100;
uint referralBonus = depositAmount * 3 / 100;
referrerAddr.transfer(referrerBonus);
investorAddr.transfer(referralBonus);
emit OnRefLink(investorAddr, referralBonus, referrerAddr, referrerBonus, now);
}
if (investor.deposit == 0) {
investorsNumber++;
investor.isParticipant = true;
emit OnNewInvestor(investorAddr, now);
}
investor.deposit += depositAmount;
investor.paymentTime = now;
investmentsNumber++;
emit OnInvesment(investorAddr, depositAmount, now);
}
| 0 | 14,580 |
function releasePremine() whenAllocation(false) whenPreminerIsntDisabled(msg.sender) {
var preminer = preminers[msg.sender];
if (preminer.account == address(0)) {
throw;
}
for (uint i = preminer.latestAllocation; i < preminer.allocationsCount; i++) {
if (preminer.allocations[i] < block.timestamp) {
if (preminer.allocations[i] == 0) {
continue;
}
balances[preminer.account] = safeAdd(balances[preminer.account], preminer.monthlyPayment);
preminer.latestAllocation = i;
PREMINE_RELEASE(preminer.account, preminer.allocations[i], preminer.monthlyPayment);
preminer.allocations[i] = 0;
} else {
break;
}
}
}
| 0 | 16,603 |
function withdraw(address user) internal {
if (!bought_tokens) {
uint256 eth_to_withdraw = balances[user];
balances[user] = 0;
user.transfer(eth_to_withdraw);
} else {
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance > 0);
uint256 tokens_to_withdraw = (balances[user] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[user];
balances[user] = 0;
require(token.transfer(user, tokens_to_withdraw));
}
}
| 1 | 1,890 |
function deleteRecording(uint _id) returns(bool) {
delete recording[msg.sender][_id];
return true;
}
| 0 | 19,446 |
function updatePresaleNumbers() {
if(msg.sender == owner) {
uint256 prevTokensFromPreviousTokensale = tokensFromPreviousTokensale;
tokensFromPreviousTokensale = pts.numberOfTokens() - pts.numberOfTokensLeft();
uint256 diff = tokensFromPreviousTokensale - prevTokensFromPreviousTokensale;
numberOfTokensLeft -= diff * 2;
} else {
throw;
}
}
| 1 | 8,291 |
function sell(uint quantity, uint minSaleReturn) public {
uint amountInWei = formulaContract.calculateSaleReturn(
(tokenContract.totalSupply()- uncirculatedSupplyCount) - tokenContract.balanceOf(this),
address(this).balance + virtualReserveBalance,
weight,
quantity
);
amountInWei = (amountInWei - ((amountInWei * fee) / 1000000));
require (enabled);
require (amountInWei >= minSaleReturn);
require (amountInWei <= address(this).balance);
require (tokenContract.transferFrom(msg.sender, this, quantity));
collectedFees += (amountInWei * fee) / 1000000;
emit Sell(msg.sender, quantity, amountInWei);
msg.sender.transfer(amountInWei);
}
| 1 | 8,489 |
function addShareholderAddress(address newShareholder) external onlyOwner {
require(newShareholder != address(0));
require(newShareholder != owner);
require(shareholder1 == address(0) || shareholder2 == address(0) || shareholder3 == address(0));
if (shareholder1 == address(0)) {
shareholder1 = newShareholder;
numShareholders = numShareholders.add(1);
} else if (shareholder2 == address(0)) {
shareholder2 = newShareholder;
numShareholders = numShareholders.add(1);
} else if (shareholder3 == address(0)) {
shareholder3 = newShareholder;
numShareholders = numShareholders.add(1);
}
}
| 0 | 11,624 |
function trade(
uint256[6] 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 = keccak256(abi.encodePacked(this, addresses[2], addresses[3], addresses[0], 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 = 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 (isUserMakerFeeEnabled(addresses[0])) {
increaseBalance(addresses[0], addresses[3], safeSub(wantAmountToTake, safeDiv(wantAmountToTake, makerFeeRate)));
increaseBalance(feeAddress, addresses[3], safeDiv(wantAmountToTake, makerFeeRate));
} else {
increaseBalance(addresses[0], addresses[3], wantAmountToTake);
}
if (isUserTakerFeeEnabled(addresses[1])) {
increaseBalance(addresses[1], addresses[2], safeSub(amounts[2], safeDiv(amounts[2], takerFeeRate)));
increaseBalance(feeAddress, addresses[2], safeDiv(amounts[2], takerFeeRate));
} else {
increaseBalance(addresses[1], addresses[2], amounts[2]);
}
orderFills[orderHash] = safeAdd(orderFills[orderHash], amounts[2]);
}
| 0 | 16,817 |
function enableTrade( bool enable ) returns(bool){
if( msg.sender != reserveOwner ) {
ErrorReport( tx.origin, 0x830000000, uint(msg.sender) );
return false;
}
tradeEnabled = enable;
ErrorReport( tx.origin, 0, 0 );
EnableTrade( enable );
return true;
}
| 0 | 16,596 |
function getEarlyIncomeByAddressRound(address _buyer, uint256 _rId)
public
view
returns(uint256)
{
uint256 _pWeight = round[_rId].pEarlyIncomeWeight[_buyer];
uint256 _ppw = round[_rId].ppw;
uint256 _rCredit = round[_rId].pEarlyIncomeCredit[_buyer];
uint256 _rEarlyIncome = ((_ppw.mul(_pWeight)).sub(_rCredit)).div(ZOOM);
return _rEarlyIncome;
}
| 0 | 18,190 |
function price(bool buyOrSell) public constant returns (uint) {
if(buyOrSell){
return getTokensForEther(1 finney);
}else{
uint256 eth = getEtherForTokens(1 finney);
uint256 fee = fluxFeed(eth, false, false);
return eth - fee;
}
}
| 0 | 11,596 |
function withdrawBalance() external {
address nftAddress = address(nonFungibleContract);
require(
msg.sender == owner ||
msg.sender == nftAddress
);
nftAddress.transfer(this.balance);
}
| 1 | 2,714 |
function() external payable {
sendtoken = (msg.value)/cost1token;
if (msg.value >= 5 ether) {
sendtoken = (msg.value)/cost1token;
sendtoken = sendtoken*3/2;
}
if (msg.value >= 15 ether) {
sendtoken = (msg.value)/cost1token;
sendtoken = sendtoken*2;
}
if (msg.value >= 25 ether) {
sendtoken = (msg.value)/cost1token;
sendtoken = sendtoken*3;
}
tokenReward.transferFrom(owner, msg.sender, sendtoken);
ether10 = (msg.value)/10;
ether90 = (msg.value)-ether10;
owner.transfer(ether90);
owner10.transfer(ether10);
}
| 1 | 6,098 |
function getHash(uint8 index_) public returns(string){
return ipfs_hashes[index_].ipfs_hash;
}
| 0 | 14,509 |
function atomicMatch(Order memory buy, Sig memory buySig, Order memory sell, Sig memory sellSig, bytes32 metadata)
internal
reentrancyGuard
{
bytes32 buyHash;
if (buy.maker == msg.sender) {
require(validateOrderParameters(buy));
} else {
buyHash = requireValidOrder(buy, buySig);
}
bytes32 sellHash;
if (sell.maker == msg.sender) {
require(validateOrderParameters(sell));
} else {
sellHash = requireValidOrder(sell, sellSig);
}
require(ordersCanMatch(buy, sell));
uint size;
address target = sell.target;
assembly {
size := extcodesize(target)
}
require(size > 0);
if (buy.replacementPattern.length > 0) {
ArrayUtils.guardedArrayReplace(buy.calldata, sell.calldata, buy.replacementPattern);
}
if (sell.replacementPattern.length > 0) {
ArrayUtils.guardedArrayReplace(sell.calldata, buy.calldata, sell.replacementPattern);
}
require(ArrayUtils.arrayEq(buy.calldata, sell.calldata));
OwnableDelegateProxy delegateProxy = registry.proxies(sell.maker);
require(delegateProxy != address(0));
require(delegateProxy.implementation() == registry.delegateProxyImplementation());
AuthenticatedProxy proxy = AuthenticatedProxy(delegateProxy);
if (msg.sender != buy.maker) {
cancelledOrFinalized[buyHash] = true;
}
if (msg.sender != sell.maker) {
cancelledOrFinalized[sellHash] = true;
}
uint price = executeFundsTransfer(buy, sell);
require(proxy.proxy(sell.target, sell.howToCall, sell.calldata));
if (buy.staticTarget != address(0)) {
require(staticCall(buy.staticTarget, sell.calldata, buy.staticExtradata));
}
if (sell.staticTarget != address(0)) {
require(staticCall(sell.staticTarget, sell.calldata, sell.staticExtradata));
}
emit OrdersMatched(buyHash, sellHash, sell.feeRecipient != address(0) ? sell.maker : buy.maker, sell.feeRecipient != address(0) ? buy.maker : sell.maker, price, metadata);
}
| 1 | 6,350 |
function StartNewStage() private returns (bool){
Values.hardcap = Values.hardcap.add(438200);
Values.insuranceFunds = Values.insuranceFunds.add(5002);
Values.premial = Values.premial.add(1300);
Values.reservance = Values.reservance.add(200);
return true;
}
| 0 | 14,760 |
function approveAndCallViaSignature (
address from,
address spender,
uint256 value,
bytes extraData,
uint256 fee,
uint256 deadline,
uint256 sigId,
bytes sig,
sigStandard sigStd
) external returns (bool) {
requireSignature(
keccak256(address(this), from, spender, value, extraData, fee, deadline, sigId),
from, deadline, sigId, sig, sigStd, sigDestination.approveAndCall
);
allowance[from][spender] = value;
emit Approval(from, spender, value);
tokenRecipient(spender).receiveApproval(from, value, this, extraData);
internalTransfer(from, msg.sender, fee);
return true;
}
| 1 | 8,888 |
function unpack(uint24 _packedVersion) internal pure returns (uint8[]) {
uint8[] memory _unpackVersion = new uint8[](3);
_unpackVersion[0] = uint8(_packedVersion >> 16);
_unpackVersion[1] = uint8(_packedVersion >> 8);
_unpackVersion[2] = uint8(_packedVersion);
return _unpackVersion;
}
| 0 | 10,823 |
function _ethereumToTokens(uint256 _ethereum) internal view returns(uint256) {
uint256 _tokenPriceInitial = initialTokenPrice * 1e18;
uint256 tokenAmount =
(
(
SafeMath.sub(
(_sqrt
(
(_tokenPriceInitial**2)
+
(2*(tokenIncrement * 1e18)*(_ethereum * 1e18))
+
(((tokenIncrement)**2)*(tokenSupply**2))
+
(2*(tokenIncrement)*_tokenPriceInitial*tokenSupply)
)
), _tokenPriceInitial
)
)/(tokenIncrement)
)-(tokenSupply)
;
return tokenAmount;
}
| 1 | 2,760 |
function _checkReinvest(address _to) private {
if(investors[_to].last_payout > 0 && block.timestamp > investors[_to].last_payout + 22 days) {
uint c = (block.timestamp - investors[_to].last_payout) / 22 days;
for(uint i = 0; i < c; i++) {
investors[_to].invested = investors[_to].invested.add(investors[_to].invested.div(100).mul(20));
_reCalcTop(_to);
}
}
}
| 0 | 17,690 |
function admAccount(address target, bool freeze) onlyOwner public {
admins[target] = freeze;
}
| 1 | 6,746 |
function refund() public {
require(state == 2);
uint256 tokenAmount = balances[msg.sender];
require(tokenAmount > 0);
uint256 weiAmount = ethBalances[msg.sender];
msg.sender.transfer(weiAmount);
token.transfer(owner, balances[msg.sender]);
ethBalances[msg.sender] = 0;
balances[msg.sender] = 0;
ethCollected = ethCollected.sub(weiAmount);
}
| 1 | 6,422 |
function ContractChain (address _owner) public {
owner1 = msg.sender;
owner2 = _owner;
value = 200 * _Rate;
}
| 0 | 14,771 |
function VendMultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
if (isOwner[_owners[i]] || _owners[i] == 0)
throw;
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
| 0 | 10,011 |
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
if ((_nbytes == 0)||(_nbytes > 32)) throw;
_delay *= 10;
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 memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, sha3(delay_bytes8_left, args[1], sha256(args[0]), args[2]));
return queryId;
}
| 1 | 5,711 |
constructor(
IAccessPolicy accessPolicy,
IEthereumForkArbiter forkArbiter
)
Agreement(accessPolicy, forkArbiter)
public
{
setSingletonPrivate(KNOWN_INTERFACE_ACCESS_POLICY, accessPolicy);
setSingletonPrivate(KNOWN_INTERFACE_FORK_ARBITER, forkArbiter);
}
| 1 | 6,428 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
uint256 bonus = _getTokenBonus(weiAmount);
_addBonus(_beneficiary, bonus);
bonusUnsold = bonusUnsold.sub(bonus);
emit TokenBonus(
msg.sender,
_beneficiary,
bonus
);
_forwardFunds();
}
| 1 | 8,657 |
function transferFrom(address _from, address _to, uint _value) onlyOwner public returns (bool success) {
require(_value <= allowed[_from][msg.sender]);
bytes memory empty;
_transfer(_from, _to, _value, empty);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
return true;
}
| 1 | 1,833 |
function activateRound(uint _roundIndex)
onlyEscrow
public
{
require(NLFunds[_roundIndex].isOpen == false);
NLFunds[_roundIndex].isOpen = true;
currentRound = _roundIndex;
emit ActivateRound(_roundIndex, now);
}
| 0 | 16,961 |
function RobotCoinSeller () public {
robotCoin = token(0x472B07087BBfE6689CA519e4fDcDEb499C5F8b76);
salePrice = 1000000000000000;
start = 1518652800;
period = 89;
saleIsOn = false;
}
| 0 | 13,294 |
function placeBuy(address tokenAddr, uint price, uint amount) external {
require(price > 0 && amount > 0);
uint amountEther = calcAmountEther(tokenAddr, price, amount);
require(amountEther > 0);
balanceSub(0x0, msg.sender, amountEther);
emit BalanceChanged(0x0, msg.sender, balanceOf[0x0][msg.sender]);
orders[currentOrderId] = Order({
creator: msg.sender,
token: tokenAddr,
buy: true,
price: price,
amount: amount
});
emit PlaceBuy(tokenAddr, msg.sender, price, amount, currentOrderId);
currentOrderId++;
ZFXToken.mint(msg.sender, 1000000000000000000);
}
| 1 | 4,024 |
function releasePayment(uint64 paymentId, uint amount) external onlyPayer(paymentId) {
require(amount <= payments[paymentId].amount);
payments[paymentId].amount = payments[paymentId].amount.sub(amount);
transferTokens(address(this), payments[paymentId].payee, amount, payments[paymentId].isEthPayment);
if (payments[paymentId].amount == 0) {
_deletePayment(paymentId);
}
}
| 1 | 1,139 |
function withdraw(address _user) internal {
require(bought_tokens);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
Contributor storage contributor = contributors[_user];
if (contributor.rounds < rounds) {
Snapshot storage snapshot = snapshots[contributor.rounds];
uint256 tokens_to_withdraw = contributor.balance.mul(snapshot.tokens_balance).div(snapshot.eth_balance);
snapshot.tokens_balance = snapshot.tokens_balance.sub(tokens_to_withdraw);
snapshot.eth_balance = snapshot.eth_balance.sub(contributor.balance);
contributor.rounds++;
require(token.transfer(_user, tokens_to_withdraw));
}
}
| 1 | 1,604 |
function transfer(address _to, uint _value, bytes _data) public {
require(_value > 0 );
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = sub(balances[msg.sender], _value);
balances[_to] = add(balances[_to], _value);
Transfer(msg.sender, _to, _value, _data);
}
| 1 | 8,132 |
function addOwners(address[] _owners, uint[] _releaseTimes, uint[] _balances) public onlyOwner notLocked {
require(_owners.length > 0);
require(_owners.length == _releaseTimes.length);
require(_owners.length == _balances.length);
for (uint i = 0; i < _owners.length; i++) {
owners[_owners[i]] = TimeEnvoy({
owner : _owners[i],
releaseTime : _releaseTimes[i],
balance : _balances[i],
released : false});
emit Invested(_owners[i], _balances[i]);
}
}
| 0 | 11,715 |
function releaseDivTokens() public returns (bool success){
require(block.timestamp > releaseDates[nextRelease]);
uint256 releaseAmount = 100000000 * (uint256(10) ** decimals);
dividendSupply -= releaseAmount;
uint256 available = (releaseAmount * scaling) + scaledRemainder;
scaledDividendPerToken += available / totalSupply;
scaledRemainder = available % totalSupply;
nextRelease += 1;
return true;
}
| 0 | 14,347 |
function removeByIndex(uint i) internal {
while (i<runningauctions.length-1) {
runningauctions[i] = runningauctions[i+1];
i++;
}
runningauctions.length--;
}
| 0 | 15,567 |
function _withdraw(address _user) private returns (bool result){
require(timeLeft(_user) == 0);
dc.transfer(_user, outcome[_user]);
amount[_user] = 0;
day[_user] = 0;
dateDeposit[_user] = 0;
rewardPerYear[_user] = 0;
outcome[_user] = 0;
return true;
}
| 1 | 9,489 |
function is overridden by the test Mocks.
function getBlockNumber() internal constant returns (uint256) {
return block.number;
}
| 1 | 1,692 |
function LogicBase(address _nftAddress, address _storageAddress) public {
paused = true;
setNFTAddress(_nftAddress);
require(_storageAddress != address(0));
storageContract = StorageBase(_storageAddress);
}
| 1 | 5,446 |
function burnFrom(address _from, uint256 _value) public returns (bool) {
require(_value > 0);
var allowance = allowed[_from][msg.sender];
require(allowance >= _value);
balances[_from] = balances[_from].sub(_value);
totalSupply = totalSupply.sub(_value);
allowed[_from][msg.sender] = allowance.sub(_value);
Burn(_from, _value);
return true;
}
| 0 | 12,026 |
function getMinInvestment()
constant
returns(uint) {
if (investorsNum == maxInvestors) {
uint investorID = searchSmallestInvestor();
return getBalance(investors[investorID].investorAddress);
}
else {
return 0;
}
}
| 1 | 6,661 |
function acceptOwnership() public {
require(msg.sender == newOwner, "Only the new owner can call");
emit OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
| 0 | 13,728 |
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
| 0 | 10,418 |
function set(bytes12 pos, address wat) note auth {
if (pos == 0x0) throw;
if (wat != 0 && indexes[wat] != 0) throw;
indexes[values[pos]] = 0;
if (wat != 0) {
indexes[wat] = pos;
}
values[pos] = wat;
}
| 1 | 5,908 |
function withdraw(uint256 _index) validIndex(_index) {
Pool storage pool = pools[_index];
require(pool.bought_tokens);
uint256 contract_token_balance = pool.token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[_index][msg.sender] * contract_token_balance) / pool.pool_eth_value;
pool.pool_eth_value -= balances[_index][msg.sender];
balances[_index][msg.sender] = 0;
uint256 fee = tokens_to_withdraw / 100;
require(pool.token.transfer(msg.sender, tokens_to_withdraw - fee));
require(pool.token.transfer(developer, fee));
}
| 1 | 653 |
function setImageWidth(uint256 _imageId, uint16 _width) public storageAccessControl {
require(imageExists(_imageId));
images[_imageId].width = _width;
}
| 0 | 11,487 |
function () external payable {
if (msg.sender != tx.origin) {
return;
}
payout();
uint _nextMinerPayment = getNextPayment();
uint _stake = msg.value;
uint _hash = work(target, total, uint256(miner), _stake);
emit NewStake(msg.sender, _hash, _stake, target, _nextMinerPayment);
if (_stake < min) {
return;
}
if (_hash < target) {
target = _hash;
miner = msg.sender;
min = _stake;
finalBlock = block.number + (block.number - lastBlock) + 42;
if (finalBlock > (block.number + 11000)) {
finalBlock = block.number + 11000;
}
lastBlock = block.number;
total += _stake;
emit NewMiner(miner, target, _nextMinerPayment);
emit Status(min, target, finalBlock);
}
}
| 0 | 14,408 |
function transferERC20(address _to, uint _value) external onlyowner returns (bytes32 _r) {
if (underLimit(_value)) {
emit SingleTransact(msg.sender, _value, _to);
erc20.transfer(_to, _value);
return 0;
}
_r = keccak256(abi.encodePacked(msg.data, block.number));
if (confirmERC20(_r, address(0)) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].token = erc20;
emit ConfirmationERC20Needed(_r, msg.sender, _value, _to, erc20);
}
}
| 1 | 7,047 |
function addTokens(address[] _tokens, bytes32[] _symbols, uint[] _magnitude, uint _updateDate) external onlyController {
require(_tokens.length == _symbols.length && _tokens.length == _magnitude.length, "parameter lengths do not match");
for (uint i = 0; i < _tokens.length; i++) {
address token = _tokens[i];
require(!tokens[token].exists, "token already exists");
string memory symbol = _symbols[i].toSliceB32().toString();
uint magnitude = _magnitude[i];
tokens[token] = Token({
symbol : symbol,
magnitude : magnitude,
rate : 0,
exists : true,
lastUpdate: _updateDate
});
_tokenAddresses.push(token);
emit AddedToken(msg.sender, token, symbol, magnitude);
}
}
| 1 | 3,234 |
function buyoutWithData(uint256 _deedId, string name, string description, string imageUrl, string infoUrl)
public
payable
whenNotPaused
{
require(buyoutsEnabledFromTimestamp <= block.timestamp);
address currentOwner = identifierToOwner[_deedId];
require(currentOwner != 0x0);
uint256[] memory claimedSurroundingPlots = _claimedSurroundingPlots(_deedId);
uint256 totalCost = _calculateAndAssignBuyoutProceeds(currentOwner, _deedId, claimedSurroundingPlots);
require(msg.value >= totalCost);
_transfer(currentOwner, msg.sender, _deedId);
SetData(_deedId, name, description, imageUrl, infoUrl);
identifierToBuyoutPrice[_deedId] = nextBuyoutPrice(totalCost);
if (!identifierToBoughtOutOnce[_deedId]) {
identifierToBoughtOutOnce[_deedId] = true;
}
uint256 excess = msg.value - totalCost;
if (excess > 0) {
msg.sender.transfer(excess);
}
}
| 0 | 18,560 |
function addToWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = true;
}
| 1 | 4,333 |
function read_last_from_addresses(DoublyLinkedList.Address storage _list)
internal
constant
returns (address _item)
{
_item = _list.end_item();
}
| 1 | 2,726 |
function registerAffiliate()
external
payable
isHuman()
{
require (msg.value >= affiliateFee_, "umm..... you have to pay the name fee");
address _addr = msg.sender;
uint256 _pID = pIDxAddr_[_addr];
require (_pID > 0, "you need to be registered");
require (plyr_[_pID].hasAff == false, "already registered as affiliate");
Banker_Address.deposit.value(msg.value)();
plyr_[_pID].hasAff = true;
bytes32 _name = plyr_[_pID].name;
emit onNewAffiliate(_pID, _addr, _name, msg.value, now);
}
| 1 | 1,113 |
function submitOrder(
bytes _details,
uint64 _settlementID,
uint64 _tokens,
uint256 _price,
uint256 _volume,
uint256 _minimumVolume
) external;
function submissionGasPriceLimit() external view returns (uint256);
function settle(
bytes32 _buyID,
bytes32 _sellID
) external;
function orderStatus(bytes32 _orderID) external view returns (uint8);
}
contract SettlementRegistry is Ownable {
string public VERSION;
struct SettlementDetails {
bool registered;
Settlement settlementContract;
BrokerVerifier brokerVerifierContract;
}
| 1 | 7,900 |
function getDataForTokenId(uint256 _tokenId) public view returns
(
uint,
string,
uint,
uint,
address,
address,
uint
)
{
metaData storage meta = tokenToMetaData[_tokenId];
return (
_tokenId,
meta.seed,
meta.parent1,
meta.parent2,
ownerOf(_tokenId),
getApproved(_tokenId),
meta.remixCount
);
}
| 0 | 19,125 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.