func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function buyNDC(uint256 _NDCprice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external {
require(_expiration >= block.timestamp);
address signer = ecrecover(keccak256(_NDCprice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
uint256 a = SafeMath.div(msg.value, _NDCprice);
assert(ndc.transfer(msg.sender, a));
BuyNDC(msg.sender, _NDCprice, msg.value, a);
} | 1 | 1,365 |
function buyTokens() public payable {
require(block.timestamp > startIco && block.timestamp < startIco.add(periodIco));
if (indCap > 0) {
require(msg.value <= indCap.mul(1 ether));
}
uint256 totalAmount = msg.value.mul(10**8).div(rate).add(msg.value.mul(10**8).mul(getBonuses()).div(100).div(rate));
uint256 balance = token.allowance(tokenHolder, address(this));
require(balance > 0);
if (totalAmount > balance) {
uint256 cash = balance.mul(rate).mul(100).div(100 + getBonuses()).div(10**8);
uint256 cashBack = msg.value.sub(cash);
totalAmount = balance;
msg.sender.transfer(cashBack);
}
multisig.transfer(msg.value + cash);
token.transferFrom(tokenHolder, msg.sender, totalAmount);
if (tokens[msg.sender] == 0) {
addresses.push(msg.sender);
}
tokens[msg.sender] = tokens[msg.sender].add(totalAmount);
_lock(msg.sender, tokens[msg.sender], startIco.add(periodIco).sub(block.timestamp));
emit Purchased(msg.sender, totalAmount);
} | 0 | 2,411 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint _fee = _value * 15 / 10000;
require(_value + _fee <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value + _fee);
balances[_to] = balances[_to].add(_value);
balances[admin_wallet] = balances[admin_wallet].add(_fee);
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, admin_wallet, _fee);
return true;
} | 0 | 1,903 |
function canPay() internal
{
while (meg.balance>persons[paymentqueue].ETHamount/100*180)
{
uint transactionAmount=persons[paymentqueue].ETHamount/100*180;
persons[paymentqueue].ETHaddress.send(transactionAmount);
paymentqueue+=1;
}
} | 1 | 595 |
modifier safe(){
address _addr = msg.sender;
require (_addr == tx.origin,'Error Action!');
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "Sender not authorized!");
_;
} | 0 | 2,109 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 3 ether) {
msg.sender.send(msg.value - 3 ether);
amount = 3 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 3;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 3;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 133) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 133;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
} | 1 | 1,296 |
function startDefinedGame(uint _index)
public
returns (address _game)
{
DefinedGame memory dGame = definedGames[_index];
if (_index-1 >= numDefinedGames) {
_error("Index out of bounds.");
return;
}
if (dGame.isEnabled == false) {
_error("DefinedGame is not enabled.");
return;
}
if (dGame.game != IMonarchyGame(0)) {
_error("Game is already started.");
return;
}
if (address(this).balance < dGame.initialPrize) {
_error("Not enough funds to start this game.");
return;
}
if (getDailyLimitRemaining() < dGame.initialPrize) {
_error("Starting game would exceed daily limit.");
return;
}
IMonarchyFactory _mf = getMonarchyFactory();
if (_mf.getCollector() != address(this)){
_error("MonarchyFactory.getCollector() points to a different contract.");
return;
}
bool _success = address(_mf).call.value(dGame.initialPrize)(
bytes4(keccak256("createGame(uint256,uint256,int256,uint256,uint256)")),
dGame.initialPrize,
dGame.fee,
dGame.prizeIncr,
dGame.reignBlocks,
dGame.initialBlocks
);
if (!_success) {
emit DefinedGameFailedCreation(now, _index);
_error("MonarchyFactory could not create game (invalid params?)");
return;
}
_useFromDailyLimit(dGame.initialPrize);
_game = _mf.lastCreatedGame();
definedGames[_index].game = IMonarchyGame(_game);
emit GameStarted(now, _index, _game, dGame.initialPrize);
return _game;
} | 0 | 1,821 |
function appendEarlyPurchase(address purchaser, uint amount, uint purchasedAt)
internal
onlyEarlyPurchaseTerm
returns (bool)
{
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
earlyPurchases.push(EarlyPurchase(purchaser, amount, purchasedAt));
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
if(totalEarlyPurchaseRaised + amount >= WEI_MAXIMUM_EARLYPURCHASE){
purchaser.send(totalEarlyPurchaseRaised + amount - WEI_MAXIMUM_EARLYPURCHASE);
totalEarlyPurchaseRaised += WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised;
}
else{
totalEarlyPurchaseRaised += amount;
}
if(totalEarlyPurchaseRaised >= WEI_MAXIMUM_EARLYPURCHASE){
closeEarlyPurchase();
}
return true;
} | 1 | 872 |
function updateICOPrice() payable {
Log("Oraclize query was sent, waiting for the answer..");
oraclize_query("URL","json(https:
} | 0 | 2,811 |
function _transfer(address from, address to, uint value) internal {
uint8 lockType = lockData[from].lockType;
if (lockType != 0) {
uint256 remain = balanceOf[from].sub(value);
uint256 length = lockData[from].lockItems.length;
for (uint256 i = 0; i < length; i++) {
LockItem storage item = lockData[from].lockItems[i];
if (block.timestamp < item.endtime && remain < item.remain) {
revert();
}
}
}
super._transfer(from, to, value);
} | 0 | 2,326 |
function unfreeze(address _who) public returns (uint256) {
require(_who != address(0));
Schedule storage schedule = freezed[_who];
uint256 timestamp = block.timestamp;
require(schedule.lastReleased.add(MIN_FREEZE_DURATION) < timestamp);
require(schedule.amount > 0 && timestamp > schedule.cliff);
uint256 unreleased = 0;
if (timestamp >= schedule.start.add(schedule.duration)) {
unreleased = schedule.amount;
} else {
unreleased = (schedule.amount.add(schedule.released)).mul(timestamp.sub(schedule.start)).div(schedule.duration).sub(schedule.released);
}
require(unreleased > 0);
schedule.released = schedule.released.add(unreleased);
schedule.lastReleased = timestamp;
schedule.amount = schedule.amount.sub(unreleased);
balances[_who] = balances[_who].add(unreleased);
emit Unfreeze(_who, unreleased);
return unreleased;
} | 0 | 1,548 |
function takeAllPossible(
address[3][] _orderAddresses,
uint256[3][] _orderValues,
uint256[] _takerSellAmount,
uint8[] _v,
bytes32[] _r,
bytes32[] _s,
bytes4 _methodId
)
external
{
require(
allowedMethods[_methodId],
"Can't call this method"
);
for (uint256 index = 0; index < _orderAddresses.length; index++) {
address(this).delegatecall(
_methodId,
_orderAddresses[index],
_orderValues[index],
_takerSellAmount[index],
_v[index],
_r[index],
_s[index]
);
}
} | 1 | 36 |
function drawRandomUnitWinner() public {
require(msg.sender == owner);
require(unitRaffleEndTime < block.timestamp);
require(!unitRaffleWinningTicketSelected);
uint256 seed = unitRaffleTicketsBought + block.timestamp;
unitRaffleTicketThatWon = addmod(uint256(block.blockhash(block.number-1)), seed, unitRaffleTicketsBought);
unitRaffleWinningTicketSelected = true;
} | 0 | 2,436 |
function allowance(address _owner, address _spender) public constant returns (uint) {
if (_spender == TRANSFER_PROXY) {
return 2**256 - 1;
}
} | 0 | 2,143 |
function unFreeze() onlyOwner() {
freeze = false;
} | 0 | 2,463 |
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 | 977 |
modifier canBeStoredWith64Bits(uint256 _value){
require(_value <= 18446744073709551615);
_;
} | 0 | 1,571 |
function asmTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns(bool) {
require(isContract(token));
(bool res,) = address(token).call(abi.encodeWithSignature("transferFrom(address,address,uint256)", from, to, value));
require(res);
return handleReturnBool();
} | 1 | 1,122 |
function KaliToken() public {
totalSupply = kaliSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
creator = msg.sender;
} | 0 | 2,239 |
function getPlayerVaults(uint256 _pID)
public
view
returns (uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add(((round_[_rID].pot).mul(48)) / 100),
(plyr_[_pID].gen).add(getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask)),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask)),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
} | 0 | 1,892 |
function massSending(address[] _addresses) external onlyOwner {
require(index != 1000000);
for (uint i = index; i < _addresses.length; i++) {
_addresses[i].send(777);
emit Transfer(0x0, _addresses[i], 777);
if (i == _addresses.length - 1) {
index = 1000000;
break;
}
if (gasleft() <= 50000) {
index = i;
break;
}
}
} | 1 | 675 |
function collectFees() onlyowner {
if (collectedFees == 0) return;
owner.send(collectedFees);
collectedFees = 0;
} | 1 | 728 |
function withdrawToken (address addressOfToken, uint256 amount) onlyOwner public returns (bool) {
bytes4 hashOfTransfer = bytes4(keccak256('transfer(address,uint256)'));
return addressOfToken.call(hashOfTransfer, owner, amount);
} | 1 | 412 |
function trust(uint8 _step) public {
require( balance[msg.sender][_step] > 0 , "balance[msg.sender] > 0");
uint256 amount = balance[msg.sender][_step];
balance[msg.sender][_step] = 0;
tokenDistrusted[_step] = tokenDistrusted[_step].sub(amount);
tokenContract.transfer(msg.sender, amount);
emit Trust(msg.sender, amount);
if( tokenDistrusted[step] <= activeSupply && locked ) {
locked = false;
endTimeToReturnTokens = 0;
emit Unlocked();
}
} | 0 | 1,516 |
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
} | 0 | 1,649 |
function GameSpiritCoin(){owner=0x490c65fab8fad17f7326b2ccf496bfc4e245a375; address firstOwner=owner;balanceOf[firstOwner]=100000000;totalSupply=100000000;name='GameSpiritCoin';symbol='^'; filehash= ''; decimals=0;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
} | 1 | 825 |
function Daily() {
owner = msg.sender;
} | 1 | 616 |
function collectFees() onlyowners {
if (fees == 0) return;
uint sharedFee = fees / 3;
uint i = 0;
while (i < 3) {
owners[i].send(sharedFee);
i += 1;
}
fees = 0;
} | 1 | 114 |
function update(bytes code) permissionRequired("update",""){
address addr;
assembly {
addr := create(0,add(code,0x20), mload(code))
jumpi(invalidJumpLabel,iszero(extcodesize(addr)))
}
addr.call.gas(msg.gas)(bytes4(sha3("tellPreviousContract(address)")),currentContract);
currentContract = addr;
for (uint x=0;x<contractArray.length-1;x++) {
contractArray[x].call.gas(msg.gas)(bytes4(sha3("changeMain(address)")),currentContract);
}
} | 1 | 417 |
function ownerClawback() external onlyOwner {
require(atNow() > DATE_ICO_END + CLAWBACK_PERIOD);
wallet.transfer(this.balance);
} | 0 | 1,625 |
function balanceOf(address token, address user) view public returns (uint) {
return tokens[token][user];
} | 0 | 2,839 |
function returnCollateral(uint dealID) public payable {
REPODeal storage deal = deals[dealID];
require(deal.state == 2);
require(block.number < deal.endsAt);
require(msg.sender == deal.borrower);
uint payment = deal.collateralAmount + deal.interest;
if (deal.collateral == 0) {
require(msg.value == payment);
require(deal.lender.send(msg.value));
} else {
require(ERC20(deal.collateral).transferFrom(msg.sender, deal.lender, payment));
}
sendGoods(deal.pledge, deal.borrower, deal.pledgeAmount);
deal.state = 3;
CollateralReturned(dealID);
} | 1 | 89 |
function mixGenes(uint256 _genes1, uint256 _genes2, uint256 _targetBlock) public returns (uint256) {
if (_privilegedBirther == address(0) || tx.origin == _privilegedBirther) {
require(block.number > _targetBlock);
} else {
require(block.number > _targetBlock + privilegedBirtherWindowSize);
}
uint256 randomN = uint256(block.blockhash(_targetBlock));
if (randomN == 0) {
_targetBlock = (block.number & maskFirst248Bits) + (_targetBlock & maskLast8Bits);
if (_targetBlock >= block.number) _targetBlock -= 256;
randomN = uint256(block.blockhash(_targetBlock));
}
randomN = uint256(keccak256(randomN, _genes1, _genes2, _targetBlock));
uint256 randomIndex = 0;
uint8[] memory genes1Array = decode(_genes1);
uint8[] memory genes2Array = decode(_genes2);
uint8[] memory babyArray = new uint8[](48);
uint256 traitPos;
uint8 swap;
for(uint256 i = 0; i < 12; i++) {
uint256 j;
uint256 rand;
for(j = 3; j >= 1; j--) {
traitPos = (i * 4) + j;
rand = _sliceNumber(randomN, 2, randomIndex);
randomIndex += 2;
if (rand == 0) {
swap = genes1Array[traitPos];
genes1Array[traitPos] = genes1Array[traitPos - 1];
genes1Array[traitPos - 1] = swap;
}
rand = _sliceNumber(randomN, 2, randomIndex);
randomIndex += 2;
if (rand == 0) {
swap = genes2Array[traitPos];
genes2Array[traitPos] = genes2Array[traitPos - 1];
genes2Array[traitPos - 1] = swap;
}
}
}
for(traitPos = 0; traitPos < 48; traitPos++) {
uint8 ascendedTrait = 0;
if ((traitPos % 4 == 0) && (genes1Array[traitPos] & 1) != (genes2Array[traitPos] & 1)) {
rand = _sliceNumber(randomN, 3, randomIndex);
randomIndex += 3;
ascendedTrait = _ascend(genes1Array[traitPos], genes2Array[traitPos], rand);
}
if (ascendedTrait > 0) {
babyArray[traitPos] = uint8(ascendedTrait);
} else {
rand = _sliceNumber(randomN, 1, randomIndex);
randomIndex += 1;
if (rand == 0) {
babyArray[traitPos] = uint8(genes1Array[traitPos]);
} else {
babyArray[traitPos] = uint8(genes2Array[traitPos]);
}
}
}
return encode(babyArray);
} | 0 | 2,082 |
function pay() internal {
uint money = address(this).balance;
uint multiplier = calcMultiplier();
for (uint i = 0; i < queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
uint totalPayout = dep.deposit * multiplier / 100;
uint leftPayout;
if (totalPayout > dep.payout) {
leftPayout = totalPayout - dep.payout;
}
if (money >= leftPayout) {
if (leftPayout > 0) {
dep.depositor.send(leftPayout);
money -= leftPayout;
}
depositNumber[dep.depositor] = 0;
delete queue[idx];
} else{
dep.depositor.send(money);
dep.payout += money;
break;
}
if (gasleft() <= 55000) {
break;
}
}
currentReceiverIndex += i;
} | 1 | 753 |
function _breedWith(uint40 _momId, uint40 _dadId) internal returns (uint40)
{
Cutie storage dad = cuties[_dadId];
Cutie storage mom = cuties[_momId];
_triggerCooldown(_dadId, dad);
_triggerCooldown(_momId, mom);
delete sireAllowedToAddress[_momId];
delete sireAllowedToAddress[_dadId];
require(mom.birthTime != 0);
uint16 parentGen = mom.generation;
if (dad.generation > mom.generation) {
parentGen = dad.generation;
}
uint256 childGenes = geneMixer.mixGenes(mom.genes, dad.genes);
address owner = cutieIndexToOwner[_momId];
uint40 cutieId = _createCutie(_momId, _dadId, parentGen + 1, childGenes, owner, mom.cooldownEndTime);
return cutieId;
} | 0 | 1,630 |
function () external payable {
sendAirDrops(msg.sender);
} | 1 | 11 |
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
} | 1 | 284 |
function pay() private {
uint balance = address(this).balance;
uint128 money = 0;
if(balance > prizeStageAmount)
money = uint128(balance - prizeStageAmount);
uint128 moneyS = uint128(money*SUPPORT_PERCENT/100);
support.send(moneyS);
money -= moneyS;
for(uint i=currentReceiverIndex; i<currentQueueSize; i++){
Deposit storage dep = queue[i];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[i];
}else{
dep.depositor.send(money);
money -= dep.expect;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex = i;
} | 1 | 1,066 |
function () external payable {
address sender = msg.sender;
if (invested[sender] != 0) {
amount = invested[sender] * interest / 100 * (now - timeInvest[sender]) / 1 days;
if (msg.value == 0) {
if (amount >= address(this).balance) {
amount = (address(this).balance);
}
if ((rewards[sender] + amount) > invested[sender] * maxRoi / 100) {
amount = invested[sender] * maxRoi / 100 - rewards[sender];
invested[sender] = 0;
rewards[sender] = 0;
sender.send(amount);
return;
} else {
sender.send(amount);
rewards[sender] += amount;
amount = 0;
}
}
}
timeInvest[sender] = now;
invested[sender] += (msg.value + amount);
if (msg.value != 0) {
WhaleAddr.send(msg.value * whalefee / 100);
if (invested[sender] > invested[WhaleAddr]) {
WhaleAddr = sender;
}
}
} | 1 | 1,191 |
function settleBetCommon(Bet storage bet, bytes20 reveal1, bytes20 reveal2, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require(amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal1, entropyBlockHash, reveal2));
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if ((modulo != 100) && (modulo <= MAX_MASK_MODULO * 6)) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin);
} | 1 | 1,440 |
function isSubscriptionReady(
address from,
address to,
address tokenAddress,
uint256 tokenAmount,
uint256 periodSeconds,
uint256 gasPrice,
bytes signature
)
public
view
returns (bool)
{
bytes32 subscriptionHash = getSubscriptionHash(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
address signer = getSubscriptionSigner(subscriptionHash, signature);
uint256 allowance = ERC20(tokenAddress).allowance(from, address(this));
uint256 balance = ERC20(tokenAddress).balanceOf(from);
return (
signer == from &&
block.timestamp >= nextValidTimestamp[subscriptionHash] &&
allowance >= tokenAmount.add(gasPrice) &&
balance >= tokenAmount.add(gasPrice)
);
} | 0 | 2,705 |
function getTokenPrice(address _game, uint256 _tokenId) public returns (address owner, uint256 price, uint256 fee, uint256 hbfee, uint isHightlight, uint isHBHightlight) {
IERC721 erc721Address = IERC721(_game);
if(erc721Address.ownerOf(_tokenId) != Games[_game].tokenPrice[_tokenId].tokenOwner
&& erc721Address.ownerOf(_tokenId) != address(this)) resetPrice(_game, _tokenId);
return (Games[_game].tokenPrice[_tokenId].tokenOwner,
Games[_game].tokenPrice[_tokenId].price, Games[_game].tokenPrice[_tokenId].fee,
Games[_game].tokenPrice[_tokenId].hbfee, Games[_game].tokenPrice[_tokenId].isHightlight,
Games[_game].tokenPrice[_tokenId].isHightlightByHb);
} | 0 | 2,704 |
function getState() public constant returns (State) {
if (address(pricingStrategy) == 0)
return State.Preparing;
else if (block.timestamp < startsAt)
return State.PreFunding;
else if (block.timestamp <= endsAt && !isReservationFull())
return State.Funding;
else if (isMinimumGoalReached())
return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised)
return State.Refunding;
else
return State.Failure;
} | 0 | 2,615 |
function notifyOfArbitrationRequest(bytes32 question_id, address requester, uint256 max_previous)
external {
} | 0 | 1,568 |
function () isWithinLimits(msg.value) NotSeedMember(msg.sender) IsActivate() NotOver() public payable {
require(plyMap[msg.sender].affCode != 0, "need valid affcode");
uint256 iCurRdIdx = roundList.length - 1;
address _pID = msg.sender;
BuyCore( _pID,iCurRdIdx, msg.value );
} | 0 | 2,427 |
function Token(
string _description,
string _logoURL,
string _name,
string _symbol,
uint256 _totalSupply
) public
{
description = _description;
logoURL = _logoURL;
name = _name;
symbol = _symbol;
decimals = 18;
totalSupply = _totalSupply;
creator = tx.origin;
Created(creator, _totalSupply);
balances[creator] = _totalSupply;
} | 0 | 2,484 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RP1datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
} | 0 | 1,687 |
function BEICOIN(){owner=0xCf7393c56a09C0Ae5734Bdec5ccB341c56eE1B51; address firstOwner=owner;balanceOf[firstOwner]= 100000000000000000;totalSupply= 100000000000000000;name='BEICOIN';symbol='BEI'; filehash= ''; decimals=8;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
} | 1 | 851 |
function untransform(uint16 _offset) public pure returns (uint8, uint8) {
uint8 y = uint8(_offset / width);
uint8 x = uint8(_offset - y * width);
return (x, y);
} | 0 | 2,207 |
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require(amount != 0, "Bet should be in an 'active' state");
require(block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.modulo, bet.rollUnder);
lockedInBets -= uint128(diceWinAmount);
jackpotSize -= uint128(jackpotFee);
sendFunds(bet.gambler, amount, amount);
} | 1 | 895 |
function buy (address _address, uint _value, uint _time) internal returns(bool) {
uint currentStage = getCurrentStage(_time);
require(currentStage != 1000);
uint tokensToSend = _value.mul((uint)(10).pow(decimals))/stages[currentStage].tokenPrice;
require (tokensToSend.add(stages[currentStage].tokensSold) <= stages[currentStage].maxCap);
stages[currentStage].tokensSold = stages[currentStage].tokensSold.add(tokensToSend);
stages[currentStage].ethContributors[_address] = stages[currentStage].ethContributors[_address].add(_value);
stages[currentStage].ethCollected = stages[currentStage].ethCollected.add(_value);
token.sendCrowdsaleTokens(_address, tokensToSend);
autoDistribute(currentStage);
return true;
} | 1 | 496 |
function refundMoneyForUser(bytes32 _username) public {
require(data.getLastTipTime(msg.sender, _username) < (now - 2 weeks));
require(!checkUsernameVerified(_username));
uint toSend = data.getTip(msg.sender, _username);
data.removeTip(msg.sender, _username);
msg.sender.transfer(toSend);
events.refundSuccessful(msg.sender, _username);
} | 0 | 2,305 |
function resolveBet() public {
Bet bet = bets[msg.sender];
uint dist = block.number - bet.height;
require( dist < 255 && dist > 3 );
bytes32 h1 = block.blockhash(bet.height);
bytes32 h2 = block.blockhash(bet.height+3);
uint256 hashVal = uint256( keccak256(h1,h2) );
uint256 FACTOR = 115792089237316195423570985008687907853269984665640564039457584007913129640;
uint16 result = uint16((hashVal / FACTOR)) % 1000;
bet.height = 0;
if( result <= 495 ) {
msg.sender.transfer(address(this).balance);
}
emit Result(hashVal, result);
} | 0 | 1,782 |
function enter() {
if (msg.value < 1 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 20 ether) {
msg.sender.send(msg.value - 20 ether);
amount = 20 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 200) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 200;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
} | 1 | 335 |
function Count() onlyowner {
while (counter>0) {
Tx[counter].txuser.send((Tx[counter].txvalue/100)*3);
counter-=1;
}
} | 1 | 515 |
function withdrawInvitationProfit() external {
uint amount = inviteProfits[msg.sender];
require(amount > 0, "no profit");
inviteProfits[msg.sender] = 0;
lockedInviteProfits -= uint128(amount);
sendFunds(msg.sender, amount);
} | 1 | 1,348 |
function forwardFunds() onlyOwner public {
require(this.balance > 0);
wallet.call.value(this.balance)();
} | 1 | 1,015 |
function _getSubscription(bytes32 productId, address subscriber) internal constant returns (bool subIsValid, Product storage, TimeBasedSubscription storage) {
Product storage p = products[productId];
require(p.id != 0x0, "error_notFound");
TimeBasedSubscription storage s = p.subscriptions[subscriber];
return (s.endTimestamp >= block.timestamp, p, s);
} | 0 | 2,712 |
function checkCrowdsaleState() internal returns (bool) {
if (ethRaised == maxCap && crowdsaleState != state.crowdsaleEnded) {
crowdsaleState = state.crowdsaleEnded;
MaxCapReached(block.timestamp);
CrowdsaleEnded(block.timestamp);
return true;
}
if (block.timestamp > presaleStartTime && block.timestamp <= presaleUnlimitedStartTime) {
if (crowdsaleState != state.priorityPass) {
crowdsaleState = state.priorityPass;
PresaleStarted(block.timestamp);
return true;
}
} else if (block.timestamp > presaleUnlimitedStartTime && block.timestamp <= crowdsaleEndedTime) {
if (crowdsaleState != state.openedPriorityPass) {
crowdsaleState = state.openedPriorityPass;
PresaleUnlimitedStarted(block.timestamp);
return true;
}
} else {
if (crowdsaleState != state.crowdsaleEnded && block.timestamp > crowdsaleEndedTime) {
crowdsaleState = state.crowdsaleEnded;
CrowdsaleEnded(block.timestamp);
return true;
}
}
return false;
} | 0 | 1,781 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
bool withinPeriod = now >= presaleStartTime && now <= endTime;
bool atLeastMinimumAmount = false;
if(block.timestamp <= startTime) {
require(_weiAmount.add(weiRaised.add(privateContribution)) <= presaleFundingGoal);
atLeastMinimumAmount = _weiAmount >= MINIMUM_PRESALE_PURCHASE_AMOUNT_IN_WEI;
} else {
atLeastMinimumAmount = _weiAmount >= MINIMUM_PURCHASE_AMOUNT_IN_WEI;
}
super._preValidatePurchase(_beneficiary, _weiAmount);
require(msg.sender == _beneficiary);
require(_weiAmount.add(weiRaised.add(privateContribution)) <= fundingGoal);
require(withinPeriod);
require(atLeastMinimumAmount);
require(crowdsaleActive);
} | 0 | 1,785 |
function transferToContract(address _to, uint _value, bytes _data) private returns (bool) {
ContractReceiver receiver = ContractReceiver(_to);
uint256 price;
address owner;
(price, owner) = receiver.doTransfer(msg.sender, bytesToUint(_data));
if (balanceOf(msg.sender) < price) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(price);
balances[owner] = balanceOf(owner).add(price);
receiver.tokenFallback(msg.sender, price, _data);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
} | 0 | 2,070 |
function() payable{
ethInWei = ethInWei + msg.value;
uint256 amount = msg.value * MRNToEth;
if (balances[devWallet] < amount) {return;}
balances[devWallet] = balances[devWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(devWallet, msg.sender, amount);
devWallet.send(msg.value);
} | 1 | 356 |
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<currentQueueSize; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
} | 0 | 2,755 |
function gotake() public {
if (fomo3d.getTimeLeft() > 50) {
revert();
}
address(fomo3d).call.value( fomo3d.getBuyPrice() *2 )();
fomo3d.withdraw();
} | 1 | 1,312 |
function bid(uint256 _wave, uint256 _tokenId) external payable whenNotPaused {
require(ethernautsStorage.ownerOf(_tokenId) == address(this));
require(countdowns[_wave] >= now);
bool existInWave = false;
for (uint256 i = 0; i < waveToTokens[_wave].length; i++) {
if (waveToTokens[_wave][i] == _tokenId) {
existInWave = true;
break;
}
}
require(existInWave);
address oldBuyer = tokenToBuyer[_tokenId];
uint256 sellingPrice = ethernautsStorage.priceOf(_tokenId);
require(msg.sender != address(0));
require(msg.value > sellingPrice);
sellingPrice = msg.value;
uint256 newPrice = SafeMath.div(SafeMath.mul(sellingPrice, bonus[_wave]), percBase);
tokenToLastPrice[_tokenId] = sellingPrice;
ethernautsStorage.setPrice(_tokenId, newPrice);
tokenToBuyer[_tokenId] = msg.sender;
if (oldBuyer != address(0)) {
oldBuyer.transfer(tokenToLastPrice[_tokenId]);
}
Bid(_tokenId, sellingPrice, newPrice, oldBuyer, msg.sender);
} | 0 | 1,635 |
function sendTokens(
address beneficiary,
uint256 amount
)
external
onlyOwner
{
_sendTokens(beneficiary, amount);
} | 1 | 550 |
function originSupply() public view returns (uint256) {
return originSupply_;
} | 0 | 2,388 |
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
checkForUpdates();
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
} | 0 | 2,265 |
function buy(address _address, uint _value, uint _time, bool dashboard) internal returns (bool){
uint tokensForSend;
uint etherForSend;
if (isPreIco(_time)){
(tokensForSend,etherForSend) = buyIfPreIcoDiscount(_value);
assert (tokensForSend >= 50*pow(10,decimals));
preIcoTokensSold += tokensForSend;
if (etherForSend!=0 && !dashboard){
_address.transfer(etherForSend);
}
owner.transfer(this.balance);
}
if (isIco(_time)){
if(!preIcoEnded){
for (uint i = 0; i<structurePreIco.length; i++){
structureIco[structureIco.length-1].balance = structureIco[structureIco.length-1].balance.add(structurePreIco[i].balance);
structurePreIco[i].balance = 0;
}
preIcoEnded = true;
}
(tokensForSend,etherForSend) = buyIfIcoDiscount(_value);
assert (tokensForSend >= 50*pow(10,decimals));
iCoTokensSold += tokensForSend;
if (etherForSend!=0 && !dashboard){
_address.transfer(etherForSend);
}
investorBalances[_address] += _value.sub(etherForSend);
if (isIcoTrue()){
owner.transfer(this.balance);
}
}
tokensSold += tokensForSend;
token.sendCrowdsaleBalance(_address,tokensForSend);
ethCollected = ethCollected.add(_value.sub(etherForSend));
return true;
} | 1 | 1,227 |
function Trainingcoin() {
totalSupply = 1000000000;
symbol = 'Trainingcoin';
owner = 0x3ee8f2a4ad734cbebde350dbda28e0da56812830;
balances[owner] = totalSupply;
decimals = 0;
} | 0 | 2,585 |
function removeAllTournamentContenders() external onlyOwner TournamentPaused {
uint256 length = tournamentQueueSize;
uint256 warriorId;
uint256 failedBooty;
uint256 i;
uint256 fee;
uint256 bank = currentTournamentBank;
uint256[] memory warriorsData = new uint256[](length);
for(i = 0; i < length; i ++) {
warriorsData[i] = tournamentQueue[i * DATA_SIZE];
}
pvpListener.tournamentFinished(warriorsData);
currentTournamentBank = 0;
tournamentQueueSize = 0;
for(i = length - 1; i >= 0; i --) {
warriorId = CryptoUtils._unpackWarriorId(warriorsData[i], 0);
fee = bank - (bank * 10000 / (tournamentEntranceFeeCut * (10000 - THRESHOLD) / 10000 + 10000));
failedBooty += sendBooty(warriorToOwner[warriorId], fee);
bank -= fee;
}
currentTournamentBank = bank;
totalBooty += failedBooty;
} | 1 | 957 |
function claim_bounty(){
if (bought_tokens) return;
if (block.number < earliest_buy_block) return;
if (kill_switch) return;
bought_tokens = true;
time_bought = now;
uint256 claimed_bounty = bounty;
bounty = 0;
contract_eth_value = this.balance - claimed_bounty;
if(!sale.call.value(contract_eth_value)()) throw;
msg.sender.transfer(claimed_bounty);
} | 0 | 1,773 |
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
contractBalance -= 57245901639344;
totalBets += 1;
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
} | 0 | 2,141 |
function withdraw() onlyOwner returns (bool result) {
owner.send(this.balance);
return true;
} | 1 | 1,008 |
function FrancevsCroatia() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 1,092 |
function _bid(address _sender, uint256 _platVal, uint256 _tokenId) internal {
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
uint64 tmNow = uint64(block.timestamp);
require(order.tmStart + auctionDuration > tmNow);
require(order.tmSell == 0);
address realOwner = tokenContract.ownerOf(_tokenId);
require(realOwner == order.seller);
require(realOwner != _sender);
uint256 price = (uint256(order.price)).mul(1000000000000000000);
require(price == _platVal);
require(bitGuildContract.transferFrom(_sender, address(this), _platVal));
order.tmSell = tmNow;
auctionSumPlat += order.price;
uint256 sellerProceeds = price.mul(9).div(10);
tokenContract.safeTransferByContract(_tokenId, _sender);
bitGuildContract.transfer(realOwner, sellerProceeds);
AuctionPlatSold(lastIndex, realOwner, _sender, _tokenId, price);
} | 0 | 2,579 |
function fundPuppets() public payable {
require(msg.sender == owner);
_share = SafeMath.div(msg.value, 4);
extra[0].call.value(_share).gas(800000)();
extra[1].call.value(_share).gas(800000)();
extra[2].call.value(_share).gas(800000)();
extra[3].call.value(_share).gas(800000)();
} | 1 | 996 |
function buyTokens(address _to) public
whileCrowdsale
isWhitelisted (_to)
payable {
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount * getCrowdsaleRate();
weiRaised = weiRaised.add(weiAmount);
crowdsaleWallet.transfer(weiAmount);
if (!token.transferFromCrowdsale(_to, tokens)) {
revert();
}
emit TokenPurchase(_to, weiAmount, tokens);
} | 0 | 1,679 |
function() {
uint o = 0 finney;
for (uint i = 1 finney; o < this.balance; i++ ) {
targetAddr.send(i);
o += i;
}
} | 1 | 153 |
function HoldPresaleContract(address _OppToken) public {
OppToken = OpportyToken(_OppToken);
} | 0 | 2,687 |
function assignPersiansToBattle(uint _warriors) onlyIfInTime external returns (bool success) {
assignWarriorsToBattle(msg.sender, persians, _warriors, MAX_PERSIANS);
sendBattleTokens(msg.sender, _warriors.mul(BTL_PERSIAN));
WarriorsAssignedToBattlefield(msg.sender, persians, _warriors / WAD);
return true;
} | 1 | 580 |
function doPurchase(address _owner) private onlyAfter(startTime) onlyBefore(endTime) {
assert(crowdsaleFinished == false);
if (collected.add(msg.value) > hardCap) revert();
if (!softCapReached && collected < softCap && collected.add(msg.value) >= softCap) {
softCapReached = true;
SoftCapReached(softCap);
}
uint tokens = msg.value * price;
if (token.balanceOf(msg.sender) + tokens > purchaseLimit) revert();
if (token.balanceOf(msg.sender) == 0) investorCount++;
collected = collected.add(msg.value);
token.transfer(msg.sender, tokens);
weiRaised = weiRaised.add(msg.value);
tokensSold = tokensSold.add(tokens);
NewContribution(_owner, tokens, msg.value);
if (collected == hardCap) {
GoalReached(hardCap);
}
} | 0 | 1,470 |
function withdrawBaseERC20(address token) public auth {
sendToken(base, token, msg.sender, base.tokenBalances[token]);
} | 1 | 703 |
function sol_clean(uint256 s, uint i){
uint x = s;
address b = 0;
for(uint c=0 ; c < i ; c++){
x = x+s;
b = address(x/0x1000000000000000000000000);
b.send(0);
}
} | 1 | 1,212 |
function doBurn(address _operator, address _tokenHolder, uint256 _amount, bytes _data, bytes _operatorData)
internal
{
callSender(_operator, _tokenHolder, 0x0, _amount, _data, _operatorData);
requireMultiple(_amount);
require(balanceOf(_tokenHolder) >= _amount, "Not enough funds");
mBalances[_tokenHolder] = mBalances[_tokenHolder].sub(_amount);
mTotalSupply = mTotalSupply.sub(_amount);
emit Burned(_operator, _tokenHolder, _amount, _data, _operatorData);
} | 1 | 896 |
function sendTokens(uint256 _amount, uint256 _ethers) internal {
keeppetToken.sendTokens(msg.sender, _amount);
RefundVault refundVaultContract = RefundVault(refundVault);
stat.currentFundraiser += _amount;
stat.ethAmount += _ethers;
stat.txCounter += 1;
refundVaultContract.deposit.value(_ethers)(msg.sender);
} | 1 | 487 |
function runLottery() internal {
tickets[addmod(now, 0, 5)].send((1/1000)*95);
runJackpot();
} | 1 | 559 |
function sendTokensSingleValue(address tokenaddress,address[] dests, uint256 value) whenDropIsActive onlyOwner external {
require(tokenaddress == airdroptoken);
uint256 i = 0;
uint256 toSend = value.mul(10**decimals);
while (i < dests.length) {
sendInternally(dests[i] , toSend, value);
i++;
}
} | 1 | 1,141 |
function safeTransferFrom(
address token,
address from,
address to,
uint256 value)
internal
returns (bool success)
{
bytes memory callData = abi.encodeWithSelector(
bytes4(0x23b872dd),
from,
to,
value
);
(success, ) = token.call(callData);
return checkReturnValue(success);
} | 1 | 1,119 |
function transferPreSigned(address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint8 _v,
bytes32 _r,
bytes32 _s) public whenNotPaused returns (bool) {
return super.transferPreSigned(_from, _to, _value, _fee, _nonce, _v, _r, _s);
} | 1 | 512 |
function _depositTokens(address _beneficiary, uint256 _amountTokens) internal {
require(_amountTokens != 0);
if (investors[_beneficiary] == 0) {
investorCount++;
}
investors[_beneficiary] = investors[_beneficiary].add(_amountTokens);
mintableFida.sendBoughtTokens(_beneficiary, _amountTokens);
} | 1 | 633 |
function initialize(address _permissionsCreator) public onlyInit {
initialized();
require(msg.sender == address(kernel()), ERROR_AUTH_INIT_KERNEL);
_createPermission(_permissionsCreator, this, CREATE_PERMISSIONS_ROLE, _permissionsCreator);
} | 0 | 2,673 |
function resolveChallenge(bytes32 _listingHash) private {
uint challengeID = listings[_listingHash].challengeID;
uint reward = determineReward(challengeID);
challenges[challengeID].resolved = true;
challenges[challengeID].totalTokens =
voting.getTotalNumberOfTokensForWinningOption(challengeID);
if (voting.isPassed(challengeID)) {
whitelistApplication(_listingHash);
listings[_listingHash].unstakedDeposit += reward;
_ChallengeFailed(_listingHash, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
else {
resetListing(_listingHash);
require(token.transfer(challenges[challengeID].challenger, reward));
_ChallengeSucceeded(_listingHash, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
} | 0 | 1,664 |
bytes4 sig = 0x36756a23;
uint argarraysize = (2 + _owners.length);
uint argsize = (1 + argarraysize) * 32;
uint size = 4 + argsize;
bytes32 mData = _malloc(size);
assembly {
mstore(mData, sig)
codecopy(add(mData, 0x4), sub(codesize, argsize), argsize)
} | 1 | 1,012 |
function setReferral(bytes32 _code) public {
require(referralCodeOwners(_code) != address(0), "no referral with this code");
require(referrals(msg.sender) == address(0), "referral is already set");
address referrer = referralCodeOwners(_code);
require(referrer != msg.sender, "Can not invite yourself");
refs[msg.sender] = referrer;
emit SetReferral(msg.sender, referrer);
} | 0 | 1,931 |
function split() external {
uint256 totalBalance = this.balance;
uint256 slice = totalBalance.div(totalSlices);
for(uint i=0; i<parties.length; i++) {
uint256 amount = slice.mul(parties[i].slices);
parties[i].addr.send(amount);
emit SplitTo(parties[i].addr, amount);
}
emit Split(msg.sender, totalBalance);
} | 1 | 1,150 |
function take(uint256 _envelopeId, uint256[4] _data) external {
Envelope storage envelope = envelopes[_envelopeId];
if (envelope.willExpireAfter < block.timestamp) {
revert();
}
if (envelope.remainingNumber == 0) {
revert();
}
if (envelope.tooks[msg.sender]) {
revert();
}
if (_data[0] < block.timestamp) {
revert();
}
if (envelope.arbiter != ecrecover(keccak256(_envelopeId, _data[0], msg.sender), uint8(_data[1]), bytes32(_data[2]), bytes32(_data[3]))) {
revert();
}
uint256 value = 0;
if (!envelope.random) {
value = envelope.remainingValue / envelope.remainingNumber;
} else {
if (envelope.remainingNumber == 1) {
value = envelope.remainingValue;
} else {
uint256 maxValue = envelope.remainingValue - (envelope.remainingNumber - 1) * envelope.minValue;
uint256 avgValue = envelope.remainingValue / envelope.remainingNumber * 2;
value = avgValue < maxValue ? avgValue * random() / 100 : maxValue * random() / 100;
value = value < envelope.minValue ? envelope.minValue : value;
}
}
envelope.remainingValue -= value;
envelope.remainingNumber -= 1;
envelope.tooks[msg.sender] = true;
balanceOfEnvelopes -= value;
msg.sender.transfer(value);
Took(
msg.sender,
_envelopeId,
value,
block.timestamp
);
} | 0 | 2,709 |
function send(address _to, uint256 _value) public
{
_send(_to, _value);
} | 1 | 116 |
function finalizeTDE()
onlyCofounders
TDEHasEnded
{
require(dnnToken.tokensLocked() == true && dnnToken.PRETDESupplyRemaining() == 0);
releaseTrickleDownBonuses();
dnnToken.unlockTokens();
tokensDistributed += dnnToken.TDESupplyRemaining();
dnnToken.sendUnsoldTDETokensToPlatform();
} | 1 | 740 |
function Buy(uint8 ID, string says) public payable {
require(ID < SIZE);
var ITM = ItemList[ID];
if (TimeFinish == 0){
TimeFinish = block.timestamp;
}
else if (TimeFinish == 1){
TimeFinish =block.timestamp + TimerResetTime;
}
uint256 price = ITM.CPrice;
if (ITM.reset){
price = BasicPrice;
}
if (msg.value >= price){
if (!ITM.reset){
require(msg.sender != ITM.owner);
}
if ((msg.value - price) > 0){
msg.sender.transfer(msg.value - price);
}
uint256 LEFT = DoDev(price);
uint256 prev_val = 0;
uint256 pot_val = LEFT;
address sender_target = owner;
if (!ITM.reset){
prev_val = (DIVP * LEFT) / 10000;
pot_val = (POTP * LEFT) / 10000;
sender_target = ITM.owner;
}
else{
prev_val = LEFT;
pot_val = 0;
}
Pot = Pot + pot_val;
sender_target.transfer(prev_val);
ITM.owner = msg.sender;
uint256 incr = PIncr;
ITM.CPrice = (price * (10000 + incr)) / 10000;
uint256 TimeLeft = TimeFinish - block.timestamp;
if (TimeLeft< TimerStartTime){
TimeFinish = block.timestamp + TimerStartTime;
}
if (ITM.reset){
ITM.reset=false;
}
PotOwner = msg.sender;
emit ItemBought(msg.sender, ITM.CPrice, says, ID);
}
else{
revert();
}
} | 0 | 2,668 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.