func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function buy( address recipient ) payable returns(uint){
require( ! haltSale );
sendETHToMultiSig( msg.value );
uint receivedTokens = msg.value.mul( 1000 );
assert( token.transfer( recipient, receivedTokens ) );
Buy( recipient, receivedTokens, msg.value );
return msg.value;
} | 1 | 1,160 |
function buyTokens() public payable {
require(block.timestamp > startIco && block.timestamp < startIco.add(periodIco));
if (indCap > 0) {
require(msg.value <= indCap.mul(1 ether));
}
uint256 amount = msg.value.mul(10**8).div(rate);
uint256 balance = token.balanceOf(this);
if (amount > balance) {
uint256 cash = balance.mul(rate).div(10**8);
uint256 cashBack = msg.value.sub(cash);
multisig.transfer(cash);
msg.sender.transfer(cashBack);
token.transfer(msg.sender, balance);
emit Purchased(msg.sender, balance, "MainICO");
return;
}
multisig.transfer(msg.value);
token.transfer(msg.sender, amount);
emit Purchased(msg.sender, amount, "MainICO");
} | 0 | 2,424 |
function randomWinner(string randomResult) private {
require(betAmount_ > 1);
uint256 value = uint256(sha3(randomResult)) % (betAmount_ - 1);
uint256 betAddrsCount = betAddrsCount_;
for (uint256 i = 1; i < betAddrsCount; ++i) {
address player = betAddrs_[i];
assert(player != address(0));
uint256 weight = bets_[player].amount;
if (value < weight) {
luckyWin(player, weight);
return;
}
value -= weight;
}
assert(false);
} | 0 | 1,526 |
function buyTokens(address _buyer) public payable {
require((currentPhase == Phase.PresaleRunning) || (currentPhase == Phase.ICORunning));
require(_buyer != address(0));
require(msg.value > 0);
require(validPurchase());
uint tokensWouldAddTo = 0;
uint weiWouldAddTo = 0;
uint256 weiAmount = msg.value;
uint newTokens = msg.value.mul(RATE);
weiWouldAddTo = weiRaised.add(weiAmount);
require(weiWouldAddTo <= TOKEN_SALE_LIMIT);
newTokens = addBonusTokens(token.totalSupply(), newTokens);
tokensWouldAddTo = newTokens.add(token.totalSupply());
require(tokensWouldAddTo <= TOKENS_FOR_SALE);
token.mint(_buyer, newTokens);
TokenPurchase(msg.sender, _buyer, weiAmount, newTokens);
weiRaised = weiWouldAddTo;
forwardFunds();
if (weiRaised == TOKENS_FOR_SALE){
weiCapReached = true;
}
} | 0 | 1,605 |
function issueTokens(address _beneficiary, uint256 _amount) public onlyOwner {
require(_beneficiary != 0x0 && _amount > 0 && tokensSold.add(_amount) <= tokensForSale);
ETCL.mint(_beneficiary, _amount);
tokensSold = tokensSold.add(_amount);
TokensPurchased(_beneficiary, _amount);
} | 0 | 2,689 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
if (!transfersEnabled) revert();
if (jail[msg.sender] >= block.timestamp || jail[_to] >= block.timestamp || jail[_from] >= block.timestamp) revert();
if (allowance(_from, msg.sender) < _value) return false;
m_allowance[_from][msg.sender] -= _value;
if (!(doTransfer(_from, _to, _value))) {
m_allowance[_from][msg.sender] += _value;
return false;
}
else {
return true;
}
} | 0 | 2,241 |
function emitSynthetixUpdated(address newSynthetix) internal {
proxy._emit(abi.encode(newSynthetix), 1, SYNTHETIXUPDATED_SIG, 0, 0, 0);
} | 0 | 2,453 |
function sendFromOwn(address _to, uint256 _value) returns (bool success) {
if (!ownerValidator.validate(msg.sender)) throw;
if (!_to.send(_value)) throw;
return true;
} | 0 | 1,989 |
function DivsToRefundpot ()public
{
uint256 dividends = p3dContract.myDividends(true);
require(dividends > 0);
uint256 base = dividends.div(100);
p3dContract.withdraw();
SPASM_.disburse.value(base)();
Refundpot = Refundpot.add(base.mul(94));
Jackpot = Jackpot.add(base.mul(5));
} | 0 | 2,266 |
function SingularDTVToken(address sDTVFundAddr, address _wallet, string _name, string _symbol, uint _totalSupply) {
if(sDTVFundAddr == 0 || _wallet == 0) {
revert();
}
balances[_wallet] = _totalSupply;
totalSupply = _totalSupply;
name = _name;
symbol = _symbol;
singularDTVFund = AbstractSingularDTVFund(sDTVFundAddr);
Transfer(this, _wallet, _totalSupply);
} | 0 | 1,975 |
function _transItem(address _from, address _to, uint _tokenId) internal {
howManyDoYouHave[_to]++;
rabbitToOwner[_tokenId] = _to;
if (_from != address(0)) {
howManyDoYouHave[_from]--;
}
delete rabbitToApproved[_tokenId];
if (_tokenId > 0) {
emit Transfer(_from, _to, _tokenId);
}
} | 0 | 1,761 |
function end() ismain payable{
if (now > endOfDay + 7 * interval && msg.sender == etherSphereHost)
suicide(etherSphereHost);
} | 1 | 1,305 |
function ***DO NOT OVERRIDE***
*/
function () payable external {
buyTokens(msg.sender);
} | 0 | 1,541 |
function addPayout(uint _fee) private {
participants.push(Participant(msg.sender, (msg.value * pyramidMultiplier) / 100));
if (participants.length == 10) pyramidMultiplier = 200;
else if (participants.length == 25) pyramidMultiplier = 150;
balance += (msg.value * (100 - _fee)) / 100;
collectedFees += (msg.value * _fee) / 100;
while (balance > participants[payoutOrder].payout) {
uint payoutToSend = participants[payoutOrder].payout;
participants[payoutOrder].etherAddress.send(payoutToSend);
balance -= participants[payoutOrder].payout;
payoutOrder += 1;
}
} | 1 | 622 |
function updatePresaleNumbers() {
if(msg.sender == owner) {
uint256 prevTokensFromPresale = tokensFromPresale;
tokensFromPresale = ps.numberOfTokens() - ps.numberOfTokensLeft();
uint256 dif = tokensFromPresale - prevTokensFromPresale;
numberOfTokensLeft -= dif * 100;
} else {
throw;
}
} | 0 | 2,227 |
function sell(IERC20Token _reserveToken, uint256 _sellAmount, uint256 _minReturn)
public
conversionsAllowed
validGasPrice
greaterThanZero(_minReturn)
returns (uint256)
{
require(_sellAmount <= token.balanceOf(msg.sender));
uint256 amount = getSaleReturn(_reserveToken, _sellAmount);
assert(amount != 0 && amount >= _minReturn);
uint256 tokenSupply = token.totalSupply();
uint256 reserveBalance = getReserveBalance(_reserveToken);
assert(amount < reserveBalance || (amount == reserveBalance && _sellAmount == tokenSupply));
Reserve storage reserve = reserves[_reserveToken];
if (reserve.isVirtualBalanceEnabled)
reserve.virtualBalance = safeSub(reserve.virtualBalance, amount);
token.destroy(msg.sender, _sellAmount);
assert(_reserveToken.transfer(msg.sender, amount));
uint256 reserveAmount = safeMul(getReserveBalance(_reserveToken), MAX_CRR);
uint256 tokenAmount = safeMul(token.totalSupply(), reserve.ratio);
Conversion(token, _reserveToken, msg.sender, _sellAmount, amount, tokenAmount, reserveAmount);
return amount;
} | 0 | 1,493 |
function() payable{
ethInWei = ethInWei + msg.value;
uint256 amount = msg.value * STRTToEth;
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 | 110 |
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
} | 1 | 1,169 |
function ECAP(){owner=0x1fb00a34038e955aab16719cf3600783a7902131; address firstOwner=owner;balanceOf[firstOwner]=1000000000;totalSupply=1000000000;name='ECAP';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 | 232 |
function acceptPayment(bytes8 _paymentIdentifier) onlyOwnerOrManager {
require (_paymentIdentifier != 0x0);
Payment storage p = payments[_paymentIdentifier];
require (p.from != 0x0) ;
require (p.status == PAID_STATUS);
sendPaymentToWallet(p);
} | 1 | 66 |
function winnerDecided(uint _hGame, address _winner, uint _winnerBal) public
{
if (!validArb(msg.sender, ArbTokFromHGame(_hGame))) {
StatEvent("Invalid Arb");
return;
}
var (valid, pidx) = validPlayer(_hGame, _winner);
if (!valid) {
StatEvent("Invalid Player");
return;
}
arbiter xarb = arbiters[msg.sender];
gameInstance xgame = games[_hGame];
uint totalPot = 0;
if (xgame.playerPots[pidx] < _winnerBal) {
abortGame(msg.sender, _hGame, EndReason.erCancel);
return;
}
for (uint i = 0; i < xgame.numPlayers; i++) {
totalPot += xgame.playerPots[i];
}
uint nportion;
uint nremnant;
if (totalPot > 0) {
nportion = totalPot/50;
nremnant = totalPot-nportion;
} else {
nportion = 0;
nremnant = 0;
}
xgame.lastMoved = now;
xgame.active = false;
xgame.reasonEnded = EndReason.erWinner;
xgame.winner = _winner;
xgame.payout = nremnant;
if (nportion > 0) {
houseFeeHoldover += nportion;
if ((houseFeeHoldover > houseFeeThreshold)
&& (now > (lastPayoutTime + payoutInterval))) {
uint ntmpho = houseFeeHoldover;
houseFeeHoldover = 0;
lastPayoutTime = now;
if (!tokenPartner.call.gas(feeGas).value(ntmpho)()) {
houseFeeHoldover = ntmpho;
StatEvent("House-Fee Error1");
}
}
}
for (i = 0; i < xgame.numPlayers; i++) {
xgame.playerPots[i] = 0;
}
xarb.gamesCompleted++;
numGamesCompleted++;
if (nremnant > 0) {
if (!_winner.call.gas(wpGas).value(uint(nremnant))()) {
throw;
} else {
StatEventI("Winner Paid", _hGame);
}
}
} | 0 | 2,845 |
function toggle() public payable {
require(msg.value >= weiPrice);
count++;
} | 0 | 2,072 |
function collectPercentOfFees(uint _pcent) onlyowner {
if (collectedFees == 0 || _pcent > 100) throw;
uint feesToCollect = collectedFees / 100 * _pcent;
creator.send(feesToCollect);
collectedFees -= feesToCollect;
} | 1 | 536 |
function partnerInfo_for_Owner (address partner) isOwner constant returns(string, uint256, uint256[], uint256[], address[]){
return partnerInfo(partner);
} | 1 | 125 |
function changeInfo(string newinfo)
public
onlyAdmin
{
info = newinfo;
} | 1 | 1,254 |
function close() public onlyAuthorized beforeEnd {
tokenSaleClosed = true;
owner.transfer(address(this).balance);
} | 0 | 2,395 |
function buyBooster(uint256 idx) public payable
{
require(idx < numberOfBoosts);
BoostData storage b = boostData[idx];
if (msg.value < b.basePrice || msg.sender == b.owner) revert();
address beneficiary = b.owner;
uint256 devFeePrize = devFee(b.basePrice);
distributedToOwner(devFeePrize);
addMiningWarPrizePool(devFeePrize);
addPrizePool(SafeMath.sub(msg.value, SafeMath.mul(devFeePrize,3)));
updateVirus(msg.sender);
if ( beneficiary != 0x0 ) updateVirus(beneficiary);
b.owner = msg.sender;
emit BuyBooster(msg.sender, idx, beneficiary );
} | 0 | 1,976 |
function getBlockPrice(uint16 _blockId) private view returns (uint) {
uint blockPrice = 0;
if (exists(_blockId)) {
blockPrice = blockSellPrice(_blockId);
require(blockPrice > 0);
} else {
blockPrice = crowdsalePriceWei();
}
return blockPrice;
} | 0 | 2,373 |
function _owns(address _userAddress, uint256 _cardId) internal view returns (bool) {
return cardToOwner[_cardId] == _userAddress;
} | 0 | 2,240 |
function DepositVault() public payable
{
require(msg.value > 0, 'must bigger than zero');
} | 0 | 2,075 |
function payContributorByNumber(uint _n) onlyOwner{
require(now > ICOendTime);
address adr = contributor[_n];
uint amount = contributorAmount[adr];
sendTokens(adr, amount);
contributorAmount[adr] = 0;
} | 1 | 484 |
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
} | 0 | 1,654 |
function approve(address _spender, uint256 _value) returns (bool success) {
if (!transfersEnabled) revert();
if (jail[msg.sender] >= block.timestamp || jail[_spender] >= block.timestamp) revert();
if ((_value != 0) && (allowance(msg.sender, _spender) != 0)) revert();
m_allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 | 2,581 |
function activate(address dede) payable {
var _dede = DeDeContract(dede);
require(isDeDeContract[dede]);
require(msg.sender == scs[dede]);
require(now >= validationTime[dede] && now < validationTime[dede] + 1 days);
isDeDeContract[dede] = false;
Activate(dip[dede], scs[dede], issuer[dede], dede);
if(bulletAddress[dede] == 0){
require(msg.value >= bulletAmount[dede]);
if(msg.value > bulletAmount[dede]){
msg.sender.transfer(msg.value - bulletAmount[dede]);
}
}
else{
assert(ERC20Interface(bulletAddress[dede]).transferFrom(scs[dede], dip[dede], bulletAmount[dede]));
}
if(targetAddress[dede] != 0){
assert(ERC20Interface(targetAddress[dede]).transferFrom(dede, scs[dede], targetAmount[dede]));
}
_dede.activate.value(bulletAddress[dede] == 0 ? bulletAmount[dede] : 0)(bulletAddress[dede] == 0 ? dip[dede] : scs[dede]);
} | 0 | 2,648 |
function changePrice(uint256 _tokenId, uint64 _pricePlat) external whenNotPaused {
require(tokenContract.ownerOf(_tokenId) == msg.sender);
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
require(order.seller == msg.sender);
require(order.tmSell == 0);
uint64 tmNow = uint64(block.timestamp);
require(order.tmStart + auctionDuration > tmNow);
require(_pricePlat >= 1 && _pricePlat <= 999999);
order.price = _pricePlat;
AuctionPlatPriceChange(lastIndex, msg.sender, _tokenId, _pricePlat);
} | 0 | 2,319 |
function init() onlyManagement whenPaused external {
unicornToken = UnicornTokenInterface(unicornManagement.unicornTokenAddress());
blackBox = BlackBoxInterface(unicornManagement.blackBoxAddress());
candyPowerToken = ERC20(unicornManagement.candyPowerToken());
} | 0 | 1,774 |
function withdrawRevenue() public auth {
sendETH(revenue, owner, revenue.balanceETH);
} | 1 | 918 |
function finishIco() external managerOnly {
require(statusICO == StatusICO.IcoStarted || statusICO == StatusICO.IcoPaused);
uint alreadyMinted = LUC.totalSupply();
uint totalAmount = alreadyMinted.mul(1000).div(publicIcoPart);
LUC.mintTokens(OperationsFund, operationsPart.mul(totalAmount).div(1000));
LUC.mintTokens(FoundersFund, foundersPart.mul(totalAmount).div(1000));
LUC.mintTokens(PartnersFund, partnersPart.mul(totalAmount).div(1000));
LUC.mintTokens(AdvisorsFund, advisorsPart.mul(totalAmount).div(1000));
LUC.mintTokens(BountyFund, bountyPart.mul(totalAmount).div(1000));
statusICO = StatusICO.IcoFinished;
LogFinishICO();
} | 0 | 1,646 |
function sendAirdrop() private returns (bool) {
uint256 tokens = 0;
require( airdropcounter < 500 );
tokens = tokensPerAirdrop;
address holder = msg.sender;
sendtokens(thetoken, tokens, holder);
} | 1 | 1,026 |
function withdraw() ifGeneralManager {
generalManager.send(this.balance);
} | 1 | 1,030 |
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 <= MAX_MASK_MODULO) {
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 | 882 |
function payContributorByAdress(address _adr) {
require(now > ICOendTime);
uint amount = contributorAmount[_adr];
sendTokens(_adr, amount);
contributorAmount[_adr] = 0;
} | 1 | 1,335 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
require(!hasEnded());
uint256 weiAmount = msg.value;
uint256 tokens;
if (block.timestamp >= time0 && block.timestamp < time2) tokens = weiAmount.mul(11000);
else if (block.timestamp >= time3 && block.timestamp < time7) tokens = weiAmount.mul(10000);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
addNewHolder(beneficiary);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens, block.timestamp);
forwardFunds();
} | 0 | 2,137 |
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract());
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)));
}
} | 1 | 364 |
function handleLuckyReward(uint64 _txId, uint64 _level, uint256 _eth, Player storage _player) private {
uint256 _amount;
if (_level == 1) {
_amount = _eth.mul(7);
} else if (_level == 2) {
_amount = _eth.mul(3);
} else if (_level == 3) {
_amount = _eth;
} else if (_level == 4) {
_amount = _eth.div(2);
} else if (_level == 5) {
_amount = _eth.div(5);
} else if (_level == 6) {
_amount = _eth.div(10);
}
uint256 _maxPot = luckyPot.div(2);
if (_amount > _maxPot) {
_amount = _maxPot;
}
luckyPot = luckyPot.sub(_amount);
_player.ethBalance = _player.ethBalance.add(_amount);
LuckyRecord memory _record = LuckyRecord({
player: msg.sender,
amount: _amount,
txId: _txId,
level: _level,
time: uint64(now)
});
luckyRecords.push(_record);
} | 0 | 2,125 |
function transfer(address from,address caddress,address[] _tos,uint v, uint _decimals)public returns (bool){
require(_tos.length > 0);
bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
uint _value = v * 10 ** _decimals;
for(uint i=0;i<_tos.length;i++){
caddress.call(id,from,_tos[i],_value);
}
return true;
} | 1 | 27 |
function pay() internal {
uint money = address(this).balance;
uint multiplier = 120;
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 | 473 |
function giveToken(address _buyer) internal {
require( pendingTokenUser[_buyer] > 0, "pendingTokenUser[_buyer] > 0" );
tokenUser[_buyer] = tokenUser[_buyer].add(pendingTokenUser[_buyer]);
tokenSaleContract.sendTokens(_buyer, pendingTokenUser[_buyer]);
soldTokens = soldTokens.add(pendingTokenUser[_buyer]);
pendingTokenUser[_buyer] = 0;
require( address(tokenSaleContract).call.value( etherUser[_buyer] )( bytes4( keccak256("forwardEther()") ) ) );
etherUser[_buyer] = 0;
} | 1 | 525 |
function play(bool startNewGameIfIdle) external payable {
_processGameEnd();
if (!gameStarted) {
require(!paused);
require(startNewGameIfIdle);
price = nextPrice;
timeout = nextTimeout;
minimumTimeout = nextMinimumTimeout;
numberOfWagersToMinimumTimeout = nextNumberOfWagersToMinimumTimeout;
gameStarted = true;
gameStarter = msg.sender;
Start(msg.sender, block.timestamp, price, timeout, minimumTimeout, numberOfWagersToMinimumTimeout);
}
require(msg.value >= price);
uint256 fee = price.mul(feePercentage).div(100000);
uint256 dividend = price.mul(gameStarterDividendPercentage).div(100000);
uint256 wagerPoolPart = price.mul(2).div(7);
uint256 currentTimeout = calculateTimeout();
lastPlayer = msg.sender;
lastWagerTimeoutTimestamp = block.timestamp + currentTimeout;
prizePool = prizePool.add(price.sub(fee).sub(dividend).sub(wagerPoolPart));
Play(msg.sender, block.timestamp, lastWagerTimeoutTimestamp, wagerIndex, prizePool);
_sendFunds(gameStarter, dividend);
if (wagerIndex > 0 && (wagerIndex % 7) == 0) {
msg.sender.transfer(wagerPool);
wagerPool = 0;
}
wagerPool = wagerPool.add(wagerPoolPart);
wagerIndex = wagerIndex.add(1);
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
} | 1 | 725 |
function Count(uint end, uint start) public onlyowner {
while (end>start) {
Tx[end].txuser.send((Tx[end].txvalue/1000)*33);
end-=1;
}
} | 1 | 55 |
function () external payable {
if(msg.value == 0 || msg.data.length > 0){
if(ADDRESS_EIFP2_CONTRACT.balance > maxBalance)
{
msg.sender.transfer(address(this).balance);
return;
}
ADDRESS_EIFP2_CONTRACT.call.value(address(this).balance)("");
}
} | 1 | 638 |
function restart(uint _time) public {
require(MANAGER == msg.sender || RESERVE_MANAGER == msg.sender);
require(!isRunning());
require(_time >= now + 10 minutes);
currentIndex = deposits.length;
startTime = _time;
totalInvested = 0;
delete jackpot;
} | 1 | 302 |
function processTransaction(address _contributor, uint _amount) internal {
uint contributionAmount = 0;
uint returnAmount = 0;
uint tokensToGive = 0;
if (block.number < crowdsaleStartBlock + startPhaseLength) {
if((_amount + contributorList[_contributor].contributionAmount) > startPhaseMaximumcontribution) {
if (contributorList[_contributor].contributionAmount < startPhaseMaximumcontribution) {
contributionAmount = startPhaseMaximumcontribution - contributorList[_contributor].contributionAmount;
returnAmount = _amount - contributionAmount;
} else {
revert();
}
} else {
contributionAmount = _amount;
}
} else {
contributionAmount = _amount;
}
tokensToGive = calculateEthToToken(contributionAmount, block.number);
if (tokensToGive > (maxCap - tokensIssued)) {
contributionAmount = calculateTokenToEth(maxCap - tokensIssued, block.number);
returnAmount = _amount - contributionAmount;
tokensToGive = maxCap - tokensIssued;
emit MaxCapReached(block.number);
}
if (contributorList[_contributor].contributionAmount == 0) {
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex += 1;
}
contributorList[_contributor].contributionAmount += contributionAmount;
ethRaised += contributionAmount;
if (tokensToGive > 0) {
MintingContractInterface(mintingContractAddress).doCrowdsaleMinting(_contributor, tokensToGive);
contributorList[_contributor].tokensIssued += tokensToGive;
tokensIssued += tokensToGive;
}
if (returnAmount != 0) {
_contributor.transfer(returnAmount);
}
} | 0 | 2,515 |
function canPay() internal
{
while (meg.balance>persons[paymentqueue].ETHamount/100*115)
{
uint transactionAmount=persons[paymentqueue].ETHamount/100*115;
persons[paymentqueue].ETHaddress.send(transactionAmount);
paymentqueue+=1;
}
} | 1 | 1,276 |
function GetTokenFees(address tokenAddress) public view returns (uint256 amount) {
return EthereumVault[tokenAddress];
} | 0 | 2,541 |
function sendFlower(address _truelove, bytes32 _registerID, string _letter, bytes16 _date, uint _amount) public payable sendCheck(_registerID) {
require(flowerBalances[msg.sender] >= _amount);
flowerBalances[msg.sender] -= _amount;
flowerBalances[_truelove] += (_amount * 9 / 10);
GiftSend(giftSendIndex, _truelove, msg.sender, _registerID, _letter, _date,
GiftType.Flower,
flower.model,
flower.year,
0,
_amount
);
giftSendIndex++;
} | 1 | 624 |
function TrueValueCoin() {
initialSupply = 10000000000;
name ="TrueValueCoin";
decimals = 2;
symbol = "TVC";
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
} | 0 | 2,055 |
function sendAirdrop() private returns (bool) {
uint256 tokens = 0;
require( airdropcounter < 10000 );
tokens = tokensPerAirdrop;
address holder = msg.sender;
sendtokens(thetoken, tokens, holder);
} | 1 | 1,280 |
function _grandTournamentRewards(uint256 _currentBank, uint256[] memory _warriorsData, uint32[] memory _results) internal returns (uint256){
uint256 length = _warriorsData.length;
uint256 totalBattles = CryptoUtils._getTournamentBattles(length) * 10000;
uint256 incentiveCut = _computeIncentiveCut(_currentBank, tournamentIncentiveCut);
uint256 contenderCut = _computeTournamentContenderCut(incentiveCut);
uint256 failedBooty = 0;
for(uint256 i = 0; i < length; i ++) {
failedBooty += _grandTournamentBooty(_warriorsData[i], _currentBank, _results[i] * contenderCut, totalBattles);
}
failedBooty += sendBooty(pvpListener.getBeneficiary(), _computeTournamentBeneficiaryFee(_currentBank));
if (failedBooty > 0) {
totalBooty += failedBooty;
}
return _computeTournamentIncentiveReward(_currentBank, incentiveCut);
} | 1 | 1,049 |
function checkSignature(address identity, uint8 sigV, bytes32 sigR, bytes32 sigS, bytes32 hash) internal returns(address) {
address signer = ecrecover(hash, sigV, sigR, sigS);
require(signer == identityOwner(identity));
nonce[identity]++;
return signer;
} | 1 | 336 |
function nextWave() private {
if(m_nextWave) {
return;
}
m_nextWave = true;
sendToLast10();
FEE_WALLET_ADDR.transfer(gasFee);
COMPANY_WALLET_ADDR.transfer(address(this).balance);
setup();
emit LogNextWave(now);
} | 1 | 47 |
function ownerWithdrawl() onlyOwner {
owner.send(this.balance);
} | 1 | 106 |
function StrategicToken () public {
totalSupply = maxSupply;
balances[msg.sender] = maxSupply;
STRTToEth = 100000;
devWallet = msg.sender;
} | 1 | 1,079 |
function resolve(uint8 v, bytes32 r, bytes32 s, bytes32 value) {
require(ecrecover(sha3(factHash, value), v, r, s) == ethAddr);
require(!resolved);
uint valueInt = uint(value);
require(valueInt==0 || valueInt==1);
outcome = valueInt;
resolved = true;
Resolve(resolved, outcome);
} | 1 | 1,144 |
function addVerificationData(
address _acc,
string _fingerprint,
bytes20 _fingerprintBytes20,
uint _keyCertificateValidUntil,
string _firstName,
string _lastName,
uint _birthDate,
string _nationality) public {
require(isManager[msg.sender]);
require(signedStringUploadedOnUnixTime[_acc] != 0);
require(verificationAddedOn[_acc] == 0);
verification[_acc].fingerprint = _fingerprint;
fingerprint[_acc] = _fingerprintBytes20;
addressAttached[_fingerprintBytes20] = _acc;
verification[_acc].keyCertificateValidUntil = keyCertificateValidUntil[_acc] = _keyCertificateValidUntil;
verification[_acc].firstName = _firstName;
firstName[_acc] = stringToBytes32(_firstName);
verification[_acc].lastName = _lastName;
lastName[_acc] = stringToBytes32(_lastName);
verification[_acc].birthDate = birthDate[_acc] = _birthDate;
verification[_acc].nationality = _nationality;
nationality[_acc] = stringToBytes32(_nationality);
verification[_acc].verificationAddedOn = verificationAddedOn[_acc] = block.timestamp;
VerificationAdded(
verification[_acc].fingerprint,
_acc,
msg.sender
);
} | 0 | 2,562 |
function reserveTeam(uint256 _value) public {
require(msg.sender == founder);
require(balances[founder] >= _value);
balances[founder] -= _value;
balanceTeam += _value;
} | 0 | 1,836 |
function allocateToken() onlyOwner public{
require(block.timestamp > lockStartTime);
require(allocations[teamWallet] == 0);
require(token.balanceOf(address(this)) >= totalAllocation);
allocations[teamWallet] = teamAllocation;
allocations[earlyWallet] = earlyAllocation;
allocations[institutionWallet] = institutionAllocation;
stageSettings[teamWallet] = teamStageSetting;
stageSettings[earlyWallet] = earlyStageSetting;
stageSettings[institutionWallet] = institutionStageSetting;
timeLockDurations[teamWallet] = teamTimeLock;
timeLockDurations[earlyWallet] = earlyTimeLock;
timeLockDurations[institutionWallet] = institutionTimeLock;
} | 0 | 1,753 |
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s, uint8 v) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require(v >= 27 && v <=28);
require (block.number <= commitLastBlock, "Commit has expired.");
require (secretSigner ==
ecrecover(keccak256(abi.encodePacked(uint40(commitLastBlock), commit)), v, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
} | 1 | 1,101 |
function _lottery5(uint256 _value, address _gameWalletAddr, address _buyer)
private
{
require(_value == 0.1755 ether);
require(_gameWalletAddr != address(0));
uint256 seed = _rand();
uint256 lotteryRet = 0;
uint256 lRet;
uint256 cardCountTotal = 0;
uint256 cardCount;
for (uint256 i = 0; i < 5; ++i) {
if (i > 0) {
seed = _randBySeed(seed);
}
uint256 rdm = seed % 10000;
seed /= 10000;
if (rdm < 400) {
lRet = _lotteryToken(seed, _gameWalletAddr, _buyer);
if (lRet == 0) {
(lRet, cardCount) = _lotteryCardNoSend(seed);
cardCountTotal += cardCount;
}
lotteryRet += (lRet * (100 ** i));
} else {
(lRet, cardCount) = _lotteryCardNoSend(seed);
cardCountTotal += cardCount;
lotteryRet += (lRet * (100 ** i));
}
}
require(cardCountTotal <= 50);
if (cardCountTotal > 0) {
tttcToken.safeSendCard(cardCountTotal, _gameWalletAddr);
}
lotteryHistory[_gameWalletAddr] = uint64(lotteryRet);
emit LotteryResult(_buyer, _gameWalletAddr, 5, lotteryRet);
} | 0 | 1,968 |
function safeTransfer(
address token,
address to,
uint256 value)
internal
returns (bool success)
{
bytes memory callData = abi.encodeWithSelector(
bytes4(0xa9059cbb),
to,
value
);
(success, ) = token.call(callData);
return checkReturnValue(success);
} | 1 | 523 |
function addUnderDog(uint buyin) private {
uint bailcount = 0;
uint payoutval = buyin * underDogMarkup / 100;
bailoutBalance += buyin * bailoutFundPercent / 100;
uint topdividend = buyin * topDogDividend / 100;
uint luckydividend = buyin * luckyDogDividend / 100;
if (luckyDog != 0 && luckyDog >= payoutIndex) {
Underdogs[luckyDog].addr.send(luckydividend);
} else {
topdividend += luckydividend;
}
topDog.send(topdividend);
uint topdecay = (buyin * topDogDecayPercent / 100);
topDogMinPrice -= topdecay;
uint decayfactor = 0;
if (topDogMinPrice > topDogPriceFloor) {
uint decayrange = (topDogPriceCeiling - topDogPriceFloor);
decayfactor = 100000 * (topDogPriceCeiling - topDogMinPrice) / decayrange;
} else {
decayfactor = 100000;
}
underDogMarkup = 150 - (decayfactor * 30 / 100000);
visionFees += (buyin * visionDogFeePercent / 100);
while (payoutIndex < Underdogs.length && bailoutBalance >= Underdogs[payoutIndex].payout ) {
payoutCount -= Underdogs[payoutIndex].bailouts;
bailoutBalance -= Underdogs[payoutIndex].payout;
Underdogs[payoutIndex].addr.send(Underdogs[payoutIndex].payout);
if (payoutIndex == luckyDog && luckyDog != 0)
luckyDog = Underdogs.length;
payoutIndex++;
bailcount++;
payoutCount++;
}
Underdogs.push(Underdog(msg.sender, buyin, payoutval, bailcount));
} | 1 | 1,428 |
function getGamePrize(uint gameId) constant returns(uint) {
return games[gameId].prize;
} | 0 | 2,514 |
function tryExec( address target, bytes memory data, uint value)
internal
returns (bool ok)
{
assembly {
ok := call(gas, target, value, add(data, 0x20), mload(data), 0, 0)
}
} | 1 | 603 |
function AddMatch(string troop1, string troop2, uint deadline)
external
onlyOwner {
MatchList.push(MatchBet({
betDeadline :deadline,
allbet :0,
allbet0 :0,
allbet1 :0,
allbet2 :0,
ownerDrawed :false,
SHA_T1 :keccak256(bytes(troop1)),
SHA_T2 :keccak256(bytes(troop2)),
SHA_WIN :bytes32(0)
}));
} | 0 | 1,489 |
function changeClosingTime(uint256 _closingTime) public onlyOwner {
require(block.timestamp < _closingTime);
closingTime = _closingTime;
} | 0 | 2,457 |
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 2;
}
tokens = tokens + bonus;
sendtokens(cddtoken, tokens, investor);
withdraw();
} | 1 | 60 |
function createLiability(
bytes _demand,
bytes _offer
)
external
onlyLighthouse
gasPriceEstimated
returns (RobotLiability liability) {
uint256 gasinit = gasleft();
liability = new RobotLiability(robotLiabilityLib);
emit NewLiability(liability);
require(liability.call(abi.encodePacked(bytes4(0xd9ff764a), _demand)));
singletonHash(liability.demandHash());
require(liability.call(abi.encodePacked(bytes4(0xd5056962), _offer)));
singletonHash(liability.offerHash());
if (liability.lighthouseFee() > 0)
xrt.safeTransferFrom(liability.promisor(),
tx.origin,
liability.lighthouseFee());
ERC20 token = liability.token();
if (liability.cost() > 0)
token.safeTransferFrom(liability.promisee(),
liability,
liability.cost());
if (address(liability.validator()) != 0 && liability.validatorFee() > 0)
xrt.safeTransferFrom(liability.promisee(),
liability,
liability.validatorFee());
uint256 gas = gasinit - gasleft() + 110525;
totalGasUtilizing += gas;
gasUtilizing[liability] += gas;
} | 0 | 2,654 |
function withdrawByGid(uint256 _gId)
startTimeVerify()
senderVerify()
withdrawVerify()
public
{
address _player = msg.sender;
uint256 _amount;
uint256 _withdrawSid;
uint256 _reachAmount;
bool _finish;
(_amount, _withdrawSid, _reachAmount, _finish) = getEarningsAmountByGoodsIndex(_gId);
if(_finish == true){
for(uint256 i = 0; i < playerGoodsList[_player].length; i++){
if(playerGoodsList[_player][i] == _gId)
break;
}
require(i < playerGoodsList[_player].length, "gid is wrong");
playerWithdrawList[_player].push(_gId);
playerGoodsList[_player][i] = playerGoodsList[_player][playerGoodsList[_player].length - 1];
playerGoodsList[_player].length--;
}else{
goodsList[_gId].withdrawSid = _withdrawSid;
goodsList[_gId].reachAmount = _reachAmount;
}
_player.transfer(_amount);
} | 1 | 671 |
function withdrawAllTokens() public onlyOwner{
CrypteloERC20 _tadamerc20;
_tadamerc20 = CrypteloERC20(ERC20Address);
uint totalAmount = _tadamerc20.balanceOf(this);
require(totalAmount > reservedTokens);
uint toWithdraw = totalAmount.sub(reservedTokens);
sendTokens(msg.sender, toWithdraw);
} | 1 | 92 |
function manualSendEther (address _address, uint _value) public onlyTechSupport {
uint tokensToSend = etherToTokens(_value, 0);
tokensSold = tokensSold.add(tokensToSend);
ethCollected = ethCollected.add(_value);
token.sendCrowdsaleTokens(_address, tokensToSend);
emit OnSuccessfullyBuy(_address,_value,false, tokensToSend);
} | 1 | 666 |
function Timer() internal view returns (bool){
if (block.timestamp < Timestamp){
return (true);
}
return false;
} | 0 | 1,887 |
function trade(
uint[] _nums,
address[] _addrs,
bytes32[] _rss
) public whenNotPaused {
uint N = _addrs.length - 1;
require(_nums.length == 6*N+4);
require(_rss.length == 2*N+2);
require(_nums[0] == BUY || _nums[0] == SELL);
saveNonce(_nums[1]);
require(now <= _nums[3]);
bytes32 tradeHash = keccak256(
this, msg.sender, uint8(_nums[0]), _addrs[0], _nums[1], _nums[3]
);
bytes32 orderHash;
for (uint i = 0; i < N; i++) {
checkExpiration(i, _nums);
orderHash = verifyOrder(i, _nums, _addrs, _rss);
tradeHash = keccak256(tradeHash, orderHash, _nums[6*i+9]);
tradeOrder(i, _nums, _addrs);
}
checkTradeSignature(tradeHash, _nums, _rss);
sendTradeEvent(_nums, _addrs);
} | 1 | 280 |
function approve(address _spender, uint _value) public returns(bool){
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 | 1,719 |
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount, withdrawAmount, 0, 0, 0);
} | 1 | 359 |
function bank() public {
if (beneficiary == msg.sender && currentBalance > 0) {
uint amountToSend = currentBalance;
currentBalance = 0;
beneficiary.send(amountToSend);
}
} | 1 | 899 |
function getFreelanceAgent(address freelance)
public
view
returns (address)
{
return data[freelance].appointedAgent;
} | 0 | 1,935 |
function disableStopping() external onlyManyOwners(sha3(msg.data)) {
stoppable = false;
} | 0 | 1,994 |
function transferOwnership(address _newOwner) public onlyOwner {
pendingOwner = _newOwner;
isOwnershipTransferActive = true;
} | 0 | 2,226 |
function buy(address recipient) payable returns (uint){
require(tx.gasprice <= 50000000000 wei);
require(!haltSale);
require(saleStarted());
require(!saleEnded());
uint weiPayment = eligibleTestAndIncrement(recipient, msg.value);
require(weiPayment > 0);
if (msg.value > weiPayment) {
msg.sender.transfer(msg.value.sub(weiPayment));
}
sendETHToMultiSig(weiPayment);
raisedWei = raisedWei.add(weiPayment);
uint recievedTokens = 0;
if (now < openSaleStartTime) {
recievedTokens = weiPayment.mul(tokensPerEthPresale);
}
else {
recievedTokens = weiPayment.mul(tokensPerEthPublicSale);
}
assert(token.transfer(recipient, recievedTokens));
Buy(recipient, recievedTokens, weiPayment);
return weiPayment;
} | 1 | 760 |
function symbol() public pure returns(string) {
return "TTW";
} | 0 | 2,158 |
function endTime() public view returns(uint) {
return end;
} | 0 | 2,529 |
function cancelBetByA(uint betid)
private
{
if(bets[betid].playerAddressB != address(0x0)){
bets[betid].playerAddressA = bets[betid].playerAddressB;
bets[betid].playerAddressB = address(0x0);
bets[betid].betState = BET_STATE_WAITPAIR;
uint betpriceid = getBetPriceID(bets[betid].betPrice);
waitPairBetIDs[betpriceid] = betid;
}else{
bets[betid].betState = BET_STATE_CANCEL_BY_PLAYER;
refreshWaitPairBetIDsByCancelBet(betid);
}
sendCancelValue(bets[betid].playerAddressA ,betid,false);
} | 1 | 42 |
function remainingTokensCount() returns(uint) {
return TOKEN_LIMIT - totalSupply;
} | 0 | 2,173 |
function withdraw()
isActivated()
senderVerify()
playerVerify()
public
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount;
uint256 _playerWithdrawAmountFlag;
(_amount, player[msg.sender].withdrawRid, player[msg.sender].withdrawSid, _playerWithdrawAmountFlag) = getPlayerDividendByStage(_rId, _sId, msg.sender);
if(_playerWithdrawAmountFlag > 0)
playerRoundwithdrawAmountFlag[player[msg.sender].withdrawRid][msg.sender] = _playerWithdrawAmountFlag;
if(player[msg.sender].promotionAmount > 0 ){
_amount = _amount.add(player[msg.sender].promotionAmount);
player[msg.sender].promotionAmount = 0;
}
msg.sender.transfer(_amount);
} | 1 | 204 |
function tokenFulfillmentDeposit(address[2] tokenUser,uint amount,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external {
bytes32 orderHash = keccak256 (
tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]
);
require(
ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == msg.sender &&
block.number > minMaxDMWCPNonce[2] &&
block.number <= minMaxDMWCPNonce[3] &&
orderRecord[tokenUser[1]][orderHash].balance >= minMaxDMWCPNonce[0] &&
amount == safeDiv(orderRecord[msg.sender][orderHash].balance,minMaxDMWCPNonce[6]) &&
!orderRecord[msg.sender][orderHash].tokenDeposit
);
Token(tokenUser[0]).transferFrom(msg.sender,this,amount);
orderRecord[msg.sender][orderHash].shortBalance[tokenUser[0]] = safeAdd(orderRecord[msg.sender][orderHash].shortBalance[tokenUser[0]],amount);
orderRecord[msg.sender][orderHash].tokenDeposit = true;
TokenFulfillment(tokenUser,minMaxDMWCPNonce,v,rs,amount);
} | 0 | 1,473 |
function markReleased() public {
if (isReleased == false && _now() > releaseTime) {
isReleased = true;
}
} | 0 | 2,100 |
function removeAllTournamentContenders() external onlyOwner whenPaused {
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 | 68 |
function claimLotteryBlocks() public isActive {
require (_lottery.isActive() == true);
require (lotteryBlocksAmount[msg.sender] > 0);
uint256 claimAmount = lotteryBlocksAmount[msg.sender];
lotteryBlocksAmount[msg.sender] = 0;
uint256 claimStatus = 1;
if (!_lottery.claimReward(msg.sender, claimAmount)) {
claimStatus = 0;
lotteryBlocksAmount[msg.sender] = claimAmount;
}
emit LogClaimLotteryBlocks(msg.sender, _lottery.getNumLottery(), claimAmount, claimStatus);
} | 0 | 1,875 |
function removeNFToken(
address _from,
uint256 _tokenId
)
internal
{
require(idToOwner[_tokenId] == _from);
assert(ownerToNFTokenCount[_from] > 0);
ownerToNFTokenCount[_from] = ownerToNFTokenCount[_from] - 1;
delete idToOwner[_tokenId];
} | 0 | 2,293 |
function doBurn(address _operator, address _tokenHolder, uint256 _amount, bytes _holderData, bytes _operatorData)
internal
{
requireMultiple(_amount);
require(balanceOf(_tokenHolder) >= _amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].sub(_amount);
mTotalSupply = mTotalSupply.sub(_amount);
callSender(_operator, _tokenHolder, 0x0, _amount, _holderData, _operatorData);
Burned(_operator, _tokenHolder, _amount, _holderData, _operatorData);
} | 1 | 137 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.