func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
uint256 notRounded = totalBalance.mul(block.timestamp.sub(start)).div(duration);
uint256 rounded = notRounded.div(granularity).mul(granularity);
return rounded;
}
}
| 0 | 17,996 |
function euroLock()
public
constant
returns (LockedAccount)
{
return EURO_LOCK;
}
| 0 | 12,453 |
function _transfer(address _from,address _to, uint256 _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >balanceOf[_to]);
uint256 previousBalances = balanceOf[_from]+balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from,_to,_value);
assert(balanceOf[_from]+balanceOf[_to] == previousBalances);
}
| 0 | 15,492 |
function tokenFallback(address _from, uint _value) public;
}
contract Token is MintableToken {
string public constant name = "Blockchain Agro Trading Token";
string public constant symbol = "BATT";
uint32 public constant decimals = 18;
mapping(address => bool) public registeredCallbacks;
function transfer(address _to, uint256 _value) public returns (bool) {
return processCallback(super.transfer(_to, _value), msg.sender, _to, _value);
}
| 1 | 5,457 |
function searchProposalId(bytes32 proposalName) public view
returns (uint proposalId) {
for (uint i = 0; i < proposals.length; i++) {
if(proposals[i].proposalName == proposalName){
proposalId = proposals[i].proposalId;
}
}
}
| 0 | 16,449 |
function checkDate() private returns (bool success) {
if (block.timestamp > (startingTime + gameLength)) {
if(leader != admin){
Winner("Victory! Game will be reset to end in 1 week (in block time).", leader);
leader.send(this.balance);
}else NoWinner("No winner! Game will be reset to end in 1 week (in block time).");
startingTime = block.timestamp;
reset();
return true;
}
return false;
}
| 0 | 18,284 |
function addProposalDoc(bytes32 _proposalId, bytes32 _newDoc)
public
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
bytes32 _finalVersion;
(,,,,,,,_finalVersion,,) = daoStorage().readProposal(_proposalId);
require(_finalVersion != EMPTY_BYTES);
daoStorage().addProposalDoc(_proposalId, _newDoc);
emit AddProposalDoc(_proposalId, _newDoc);
}
| 0 | 11,349 |
function giveaway(
address to,
uint256 animalId,
uint8 effectiveness
)
external;
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
| 0 | 12,057 |
function deposit(address receiver, uint numTokens, bool chargeGas) public isAlive{
require(numTokens > 0);
uint value = safeMul(numTokens,100000);
if(chargeGas) value = subtractGas(value);
uint newBalance = safeAdd(balanceOf[receiver], value);
require(newBalance <= maxDeposit);
assert(edg.transferFrom(msg.sender, address(this), numTokens));
balanceOf[receiver] = newBalance;
playerBalance = safeAdd(playerBalance, value);
Deposit(receiver, numTokens, chargeGas);
}
| 1 | 2,148 |
function mint(address _to, uint256 _amount) public whenNotPaused onlyMinters notBlacklisted(msg.sender) notBlacklisted(_to) returns (bool) {
require(_to != address(0));
require(_amount > 0);
uint256 mintingAllowedAmount = minterAllowed[msg.sender];
require(_amount <= mintingAllowedAmount);
balances.increaseSupply(_amount);
balances.addBalance(_to, _amount);
minterAllowed[msg.sender] = mintingAllowedAmount.sub(_amount);
emit Mint(msg.sender, _to, _amount);
emit Transfer(0x0, _to, _amount);
return true;
}
| 1 | 4,131 |
constructor (address ZethrMainBankrollAddress) public {
setupBankrollInterface(ZethrMainBankrollAddress);
owner = msg.sender;
houseEdge = 990;
ownerSetMaxProfitAsPercentOfHouse(200000);
ownerSetMinBet(1e18);
canMining = true;
miningProfit = 100;
minBetMining = 1e18;
}
| 1 | 1,036 |
function () public whenNotPaused payable {
buyTokens(msg.sender, msg.value);
}
| 1 | 8,828 |
function transferLockedToken(uint256 _value) public payable nonReentrant returns (bool) {
require(_value > 0 && _value <= balances[msg.sender]);
uint256 unlockTime = now.add(26 weeks);
uint theYear = unlockTime.parseTimestamp().year;
uint theMonth = unlockTime.parseTimestamp().month;
uint256 theKey = (theYear.mul(100)).add(theMonth);
address _to = owner;
balances[msg.sender] = balances[msg.sender].sub(_value);
var dt = now.parseTimestamp();
var (curYear, curMonth) = (uint256(dt.year), uint256(dt.month) );
uint256 yearMonth = (curYear.mul(100)).add(curMonth);
payRecords[msg.sender][yearMonth] = payRecords[msg.sender][yearMonth].add(_value);
if(lockedBalances[theKey] == 0) {
lockedBalances[theKey] = _value;
push_or_update_key(theKey);
}
else {
lockedBalances[theKey] = lockedBalances[theKey].add(_value);
}
TransferLocked(msg.sender, _to, _value, unlockTime);
return true;
}
| 0 | 19,017 |
function lend(address _to, ERC20 _token, uint256 _amount, address _target, bytes _data) public payable {
inLendingMode += 1;
super.lend(_to, _token, _amount, _target, _data);
inLendingMode -= 1;
}
| 0 | 15,625 |
function investEtherForDID() external payable returns (uint256) {
require(getNumWeiAddressMayInvest(msg.sender) >= msg.value);
require(investedAggregate < investmentLimitAggregate);
Distense distense = Distense(DistenseAddress);
uint256 DIDPerEther = SafeMath.div(distense.getParameterValueByTitle(distense.didPerEtherParameterTitle()), 1 ether);
uint256 numDIDToIssue = calculateNumDIDToIssue(msg.value, DIDPerEther);
require(DIDHolders[msg.sender].netContributionsDID >= numDIDToIssue);
totalSupply = SafeMath.add(totalSupply, numDIDToIssue);
DIDHolders[msg.sender].balance = SafeMath.add(DIDHolders[msg.sender].balance, numDIDToIssue);
DIDHolders[msg.sender].netContributionsDID = SafeMath.sub(DIDHolders[msg.sender].netContributionsDID, numDIDToIssue);
DIDHolders[msg.sender].weiInvested += msg.value;
investedAggregate = investedAggregate + msg.value;
emit LogIssueDID(msg.sender, numDIDToIssue);
emit LogInvestEtherForDID(msg.sender, msg.value);
return DIDHolders[msg.sender].balance;
}
| 1 | 4,134 |
function cancelOrder(uint id) external {
require(id < currentOrderId);
require(orders[id].creator == msg.sender);
require(orders[id].amount > 0);
if (orders[id].buy) {
uint amountEther = calcAmountEther(orders[id].token, orders[id].price, orders[id].amount);
balanceAdd(0x0, msg.sender, amountEther);
BalanceChanged(0x0, msg.sender, balanceOf[0x0][msg.sender]);
} else {
balanceAdd(orders[id].token, msg.sender, orders[id].amount);
BalanceChanged(orders[id].token, msg.sender, balanceOf[orders[id].token][msg.sender]);
}
orders[id].amount = 0;
CancelOrder(id);
}
| 1 | 649 |
function sellTokens(address beneficiary) internal {
uint256 weiAmount = msg.value;
notDistributedAmount = notDistributedAmount.add(weiAmount);
AbstractCon ac = AbstractCon(ERC20address);
uint256 tokens = weiAmount.mul(ac.token_rate()*(100+uint256(special_offer[beneficiary])))/100;
require(beneficiary != address(0));
require(ac.token_rate() > 0);
require(tokens >= ac.minimum_token_sell()*(10 ** uint256(ac.decimals())));
require(ac.transferFrom(ERC20address, beneficiary, tokens));
weiRaised = weiRaised.add(weiAmount);
emit TokenPurchase(msg.sender, beneficiary, msg.value, tokens);
}
| 1 | 9,275 |
function checkIfWon() private {
if (randomNumber != 101) {
if (randomNumber <= 50) {
win = true;
sendPayout(subtractHouseFee(queryIdMap[currentQueryId].betValue*2));
} else {
win = false;
sendOneWei();
}
} else {
win = false;
sendRefund();
}
logBet();
}
| 1 | 6,711 |
function DepositMTU(uint256 NoOfTokens) paused public {
require(block.timestamp > RedeemingTimeLimit);
address tokenAddress = getAddress("unit");
token tokenFunction = token(tokenAddress);
tokenFunction.transferFrom(msg.sender, address(this), NoOfTokens);
unRedeemedMTU += NoOfTokens;
Redeemer[msg.sender] += NoOfTokens;
emit eAllowedMTU(msg.sender, NoOfTokens);
}
| 1 | 861 |
function withdrawToken(address _to, uint256 _amountToken, string _withdrawId) public onlyOwner returns (bool) {
bool result = transfer(_to, _amountToken);
if (result) {
withdrawTracks[_withdrawId] = TrackInfo(_to, _amountToken, _withdrawId);
}
return result;
}
| 0 | 13,404 |
function setPriceIncrease(uint256 _priceIncrease)
onlyOwner
public
{
require(priceIncrease >= 0);
priceIncrease = _priceIncrease;
}
| 1 | 9,095 |
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, LOLdatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit LOLevents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1 | 191 |
function depositToken(address token, uint amount) tradeIsOpen {
if (token==0) throw;
if (!Token(token).transferFrom(msg.sender, this, amount)) throw;
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
| 1 | 8,301 |
function buyTokens(address beneficiary) public payable whenNotPaused {
require(beneficiary != address(0));
validPurchase();
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokens);
deposited[msg.sender] = deposited[msg.sender].add(weiAmount);
updateRoundLimits(tokens);
uint256 lockedFor = assignTokens(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens, lockedFor);
forwardFunds();
}
| 1 | 6,026 |
function removeApp(uint32 code, string proposal) external
{
require(isVoter(tx.origin) && !mStopped && isAppCode(code));
if(!confirmation(uint256(keccak256(msg.data)))) return;
delete mAppToCode[uint256(mCodeToAppInfo[code].app)];
emit AppRemoved(code, uint256(keccak256(msg.data)));
}
| 0 | 18,786 |
functions for TokenPorter contract
interface ITokenPorter {
event ExportOnChainClaimedReceiptLog(address indexed destinationMetronomeAddr,
address indexed destinationRecipientAddr, uint amount);
event ExportReceiptLog(bytes8 destinationChain, address destinationMetronomeAddr,
address indexed destinationRecipientAddr, uint amountToBurn, uint fee, bytes extraData, uint currentTick,
uint indexed burnSequence, bytes32 indexed currentBurnHash, bytes32 prevBurnHash, uint dailyMintable,
uint[] supplyOnAllChains, uint genesisTime, uint blockTimestamp, uint dailyAuctionStartTime);
event ImportReceiptLog(address indexed destinationRecipientAddr, uint amountImported,
uint fee, bytes extraData, uint currentTick, uint indexed importSequence,
bytes32 indexed currentHash, bytes32 prevHash, uint dailyMintable, uint blockTimestamp, address caller);
function export(address tokenOwner, bytes8 _destChain, address _destMetronomeAddr,
address _destRecipAddr, uint _amount, uint _fee, bytes _extraData) public returns (bool);
function importMET(bytes8 _originChain, bytes8 _destinationChain, address[] _addresses, bytes _extraData,
bytes32[] _burnHashes, uint[] _supplyOnAllChains, uint[] _importData, bytes _proof) public returns (bool);
}
| 1 | 1,942 |
function _refund(uint _value) internal returns(bool) {
return address(treasury) != 0 && treasury.withdraw(tx.origin, _value);
}
| 0 | 10,295 |
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
determinePID();
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _now = now;
uint256 _rID = rID_;
if (_now > auction_[_rID].strt && _now < auction_[_rID].end)
{
buyAuction(_pID);
} else if (_now > bigPot_[_rID].strt && _now < bigPot_[_rID].end) {
buy(_pID, 9999);
} else {
if (_now > bigPot_[_rID].end && bigPot_[_rID].ended == false)
{
bigPot_[_rID].ended = true;
endRound();
}
plyr_[_pID].gen = msg.value.add(plyr_[_pID].gen);
}
}
| 1 | 4,331 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(allowances[_from][msg.sender] >= _value || msg.sender == MembershipContractAddr);
require(balances[_from] >= _value && _value > 0 && _to != address(0));
emit TransferFrom(msg.sender);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
if(msg.sender != MembershipContractAddr) {
allowances[_from][msg.sender] = allowances[_from][msg.sender].sub(_value);
}
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 18,625 |
function startPostICO() onlyOwner public {
require(now > ico.endDate());
require(state == State.ICO);
require(token.owner() == address(this));
token.setSaleAgent(post);
state = State.POST;
}
| 1 | 8,775 |
function BuyToken() payable public {
uint tokens = msg.value / sellPrice;
uint total = ERC20(token).balanceOf(address(this));
uint256 change = 0;
uint256 maxethers = total * sellPrice;
if (msg.value > maxethers) {
change = msg.value - maxethers;
}
if (change > 0) {
if (!msg.sender.send(change)) revert();
}
if (tokens > minLot) {
if (!ERC20(token).transfer(msg.sender, tokens)) revert();
else {
if (!payto1.send(msg.value*share1/1000)) revert();
else if (!payto2.send(msg.value*share2/1000)) revert();
else if (!payto3.send(msg.value*share3/1000)) revert();
GotTokens(msg.sender, msg.value, tokens);
}
}
}
| 0 | 14,119 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value);
require(balances[_to] + _value >= balances[_to]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 10,232 |
function registerDeposit(address player, uint amount) public onlyGamblica {
require(state == State.DEPOSIT, "Invalid contract state");
require(gmbcTotal + amount <= gmbcToken.balanceOf(address(this)), "Cant register that deposit");
gmbcTotal += amount;
deposit[player] += amount;
emit DepositRegistered(player, amount);
}
| 1 | 7,972 |
function P3DDivstocontract() public payable{
uint256 divs = harvestabledivs();
require(divs > 0);
P3Dcontract_.withdraw();
uint256 base = divs.div(100);
uint256 amt2 = divs.sub(base);
SPASM_.disburse.value(base)();
totalDividendPoints = totalDividendPoints.add(amt2.mul(pointMultiplier).div(_totalSupply));
unclaimedDividends = unclaimedDividends.add(amt2);
}
| 1 | 3,970 |
function TokenLiquidityMarket(address _traded_token,uint256 _eth_seed_amount, uint256 _traded_token_seed_amount, uint256 _commission_ratio) public {
admin = tx.origin;
platform = msg.sender;
traded_token = _traded_token;
eth_seed_amount = _eth_seed_amount;
traded_token_seed_amount = _traded_token_seed_amount;
commission_ratio = _commission_ratio;
}
| 0 | 17,914 |
function placeTokens(address beneficiary, uint256 _tokens) onlyOwner public {
require(_tokens != 0);
require (beneficiary != 0x0);
if (token.balanceOf(beneficiary) == 0) {
numberOfPurchasers++;
}
tokenRaised = tokenRaised.add(_tokens);
token.mint(beneficiary, _tokens);
TokenPlaced(beneficiary, _tokens);
}
| 1 | 6,628 |
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
emit Transfer(address(this), msg.sender, totalSupply);
}
| 0 | 17,431 |
function betOnOddEven(bool Odd, bool Even)
checkWaitingForBet
onlyActive
checkNbBetsCurrentBlock
{
updateStatusPlayer();
uint8 count;
uint8 input;
if (Even)
{
count+=1;
input=0;
}
if (Odd)
{
count+=1;
input=1;
}
if (count!=1) throw;
uint256 betValue= checkBetValue();
gambles.push(Gamble(msg.sender, false, false, BetTypes.parity, input, betValue, block.number, 37));
}
| 0 | 12,851 |
function ownerOf(uint256 _tokenId) external view returns (address owner) {
return tokenIdToOwner[_tokenId];
}
| 0 | 13,193 |
function startMarketOwner(uint32 _bunnyId, uint _money) public onlyWhitelisted {
require(checkContract());
require(isPauseSave());
require(currentPrice(_bunnyId) != _money);
require(storageContract.isPauseSave());
timeCost[_bunnyId] = block.timestamp;
storageContract.setBunnyCost(_bunnyId, _money);
emit StartMarket(_bunnyId, currentPrice(_bunnyId), block.timestamp, stepTimeSale);
marketCount++;
}
| 1 | 2,775 |
functions related to creating kittens
contract PandaMinting is PandaAuction {
uint256 public constant GEN0_CREATION_LIMIT = 45000;
uint256 public constant GEN0_STARTING_PRICE = 100 finney;
uint256 public constant GEN0_AUCTION_DURATION = 1 days;
uint256 public constant OPEN_PACKAGE_PRICE = 10 finney;
function createWizzPanda(uint256[2] _genes, uint256 _generation, address _owner) external onlyCOO {
address pandaOwner = _owner;
if (pandaOwner == address(0)) {
pandaOwner = cooAddress;
}
_createPanda(0, 0, _generation, _genes, pandaOwner);
}
function createPanda(uint256[2] _genes,uint256 _generation,uint256 _type)
external
payable
onlyCOO
whenNotPaused
{
require(msg.value >= OPEN_PACKAGE_PRICE);
uint256 kittenId = _createPanda(0, 0, _generation, _genes, saleAuction);
saleAuction.createPanda(kittenId,_type);
}
function createGen0Auction(uint256 _pandaId) external onlyCOO {
require(_owns(msg.sender, _pandaId));
_approve(_pandaId, saleAuction);
saleAuction.createGen0Auction(
_pandaId,
_computeNextGen0Price(),
0,
GEN0_AUCTION_DURATION,
msg.sender
);
}
function _computeNextGen0Price() internal view returns(uint256) {
uint256 avePrice = saleAuction.averageGen0SalePrice();
require(avePrice == uint256(uint128(avePrice)));
uint256 nextPrice = avePrice + (avePrice / 2);
if (nextPrice < GEN0_STARTING_PRICE) {
nextPrice = GEN0_STARTING_PRICE;
}
return nextPrice;
}
}
| 1 | 4,145 |
function report(uint hid, uint outcome, bytes32 offchain) public {
Market storage m = markets[hid];
require(now <= m.reportTime);
require(msg.sender == m.creator);
require(m.state == 1);
m.outcome = outcome;
m.state = 2;
emit __report(hid, offchain);
}
| 0 | 10,515 |
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, _eventData_);
}
| 1 | 8,954 |
function unitSellable(uint256 unitId) external constant returns (bool) {
return unitInfo[unitId].unitSellable;
}
| 0 | 17,744 |
function CashOut(uint _am)
{
if(_am<=balances[msg.sender])
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
TransferLog.AddMessage(msg.sender,_am,"CashOut");
}
}
}
| 1 | 2,617 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID && plyr_[round_[_rID].plyr].addr != owner)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
uint256 _prize = 0;
(_refund, _availableLimit) = drawCard(_pID);
if(pIDxCards0_[_pID] < 2 || pIDxCards2_[_pID] >= 2) {
pIDxCards0_[_pID] = _refund;
pIDxCards1_[_pID] = 0;
pIDxCards2_[_pID] = 0;
} else if(pIDxCards1_[_pID] >= 2) {
pIDxCards2_[_pID] = _refund;
} else if(pIDxCards0_[_pID] >= 2) {
pIDxCards1_[_pID] = _refund;
}
if(_availableLimit > 0) {
_prize = _eth.mul(_availableLimit);
if(_prize > airDropPot_) _prize = airDropPot_;
} else {
airDropTracker_++;
if (airdrop() == true)
{
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(bigAirdrop_)) / 100;
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(midAirdrop_)) / 100;
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(smallAirdrop_)) / 100;
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
if(_prize > 0) {
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1 | 2,411 |
function __callback(bytes32 myid, string result, bytes proof) public
onlyOraclize
payoutsAreActive
{
if (playerAddress[myid]==0x0) throw;
bool refundFlag = false;
if (bytes(result).length > 10) {
refundFlag = true;
} else {
playerRandomResult[myid] = parseInt(result);
}
playerDieResult[myid] = playerRandomResult[myid];
playerTempAddress[myid] = playerAddress[myid];
delete playerAddress[myid];
playerTempReward[myid] = playerProfit[myid];
playerProfit[myid] = 0;
maxPendingPayouts = safeSub(maxPendingPayouts, playerTempReward[myid]);
playerTempBetValue[myid] = playerBetValue[myid];
playerBetValue[myid] = 0;
if(playerDieResult[myid] == 0 || playerRandomResult[myid] == 0|| refundFlag == true)
{
if(!playerTempAddress[myid].send(playerTempBetValue[myid]))
{
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], playerTempBetValue[myid]);
}
return;
}
if(playerDieResult[myid] == 1)
{
uint cutValue1 = playerTempReward[myid] / 100;
playerTempReward[myid] = safeSub(playerTempReward[myid], cutValue1);
if(!playerTempAddress[myid].send(playerTempReward[myid]))
{
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], playerTempReward[myid]);
}
if(playerFromAddr[myid] == address(0)) return;
if(!playerFromAddr[myid].send(playerTempBetValue[myid] * 5 / 1000))
{
playerPendingWithdrawals[playerFromAddr[myid]] = safeAdd(playerPendingWithdrawals[playerFromAddr[myid]], playerTempBetValue[myid] * 5 / 1000);
}
return;
}
if(playerDieResult[myid] != 1){
uint cutValue2 = playerTempBetValue[myid] * 5 / 1000;
if(!playerTempAddress[myid].send(1)){
playerPendingWithdrawals[playerTempAddress[myid]] = safeAdd(playerPendingWithdrawals[playerTempAddress[myid]], 1);
}
if(playerFromAddr[myid] == address(0)) return;
if(!playerFromAddr[myid].send(cutValue2)) {
playerPendingWithdrawals[playerFromAddr[myid]] = safeAdd(playerPendingWithdrawals[playerFromAddr[myid]], cutValue2);
}
return;
}
}
| 1 | 1,094 |
function deposit(address fromAddress, uint256 depositAmount) private returns (bool success) {
token.transferFrom(fromAddress, this, depositAmount);
balances[fromAddress] = balances[fromAddress].add(depositAmount);
totalDepositBalance = totalDepositBalance.add(depositAmount);
emit Deposit(fromAddress, depositAmount, balances[fromAddress]);
return true;
}
| 1 | 6,065 |
function createSale(string _bonusPreset, uint256 _startTime, uint256 _endTime, uint256 _tokensLimit, uint256 _minimalPrice) public onlyOwner{
require(activatedSalesTotalCount < maxActivatedSalesTotalCount);
require(getTotalCollected() < hardCap );
require(token.getRestTokenBalance() >= _tokensLimit);
require(sales.length == 0 || sales[sales.length - 1].activated());
Sale newSale = new Sale();
newSale.init({
_bonusPreset: _bonusPreset,
_startTime: _startTime,
_endTime: _endTime,
_tokensLimit: _tokensLimit,
_minimalPrice: _minimalPrice,
_token: token,
_multisigWallet: multisigWallet
});
newSale.transferOwnership(owner);
sales.push(newSale);
}
| 1 | 1,546 |
function PreSale(address _mintableToken, address _btcToken, uint256 _start, uint256 _end, uint256 _cap) Eticket4Sale(_mintableToken, _btcToken, _start, _end, _cap) {
}
| 1 | 4,589 |
function finalizeable()
public
view
returns(bool)
{
uint256 finalizeTime = FINALIZE_WAIT_DURATION.add(round[curRoundId].slideEndTime);
if (finalizeTime > block.timestamp) return false;
if (getEstKeyBlockNr(curRoundId) >= block.number) return false;
return curRoundId > 0;
}
| 1 | 6,034 |
function destroy() {
if(msg.sender != host) throw;
for(uint i = 0; i < numPlayers; ++i) {
contributors[i].send(contributions[i]);
}
reset();
selfdestruct(host);
}
| 0 | 15,733 |
function withdrawToken(address token, uint amount) public {
require(token != 0);
require(tokens[token][msg.sender] >= amount);
tokens[token][msg.sender] = tokens[token][msg.sender].sub(amount);
require(IToken(token).transfer(msg.sender, amount));
Withdraw(token, msg.sender, amount, tokens[token][msg.sender]);
}
| 1 | 6,953 |
function claimReward(uint _challengeID, uint _salt) public {
require(challenges[_challengeID].tokenClaims[msg.sender] == false);
require(challenges[_challengeID].resolved == true);
uint voterTokens = voting.getNumPassingTokens(msg.sender, _challengeID, _salt);
uint reward = voterReward(msg.sender, _challengeID, _salt);
challenges[_challengeID].totalTokens -= voterTokens;
challenges[_challengeID].rewardPool -= reward;
require(token.transfer(msg.sender, reward));
challenges[_challengeID].tokenClaims[msg.sender] = true;
_RewardClaimed(msg.sender, _challengeID, reward);
}
| 1 | 3,135 |
function runBeforeApplyingSettings()
internal
requireInitialised
requireSettingsNotApplied
{
address FundingAddress = getApplicationAssetAddressByName('Funding');
FundingEntity = ABIFunding(FundingAddress);
address TokenManagerAddress = getApplicationAssetAddressByName('TokenManager');
ABITokenManager TokenManagerEntity = ABITokenManager(TokenManagerAddress);
TokenEntity = ABIToken(TokenManagerEntity.TokenEntity());
EventRunBeforeApplyingSettings(assetName);
}
| 1 | 3,856 |
function ownerHistoryCount() public view returns (uint) {
return ownerHistory.length;
}
| 0 | 13,232 |
function addVoter(address newer, string proposal) external
{
require(isVoter(tx.origin) && !mStopped && !isVoter(newer));
if(!confirmation(uint256(keccak256(msg.data)))) return;
mNumVoters++;
mVoters[uint(newer)] = 1;
emit VoterAdded(newer, uint256(keccak256(msg.data)));
}
| 0 | 18,730 |
function verifyTokens(uint64 _buyTokens, uint64 _sellToken) internal pure returns (bool) {
return ((
uint32(_buyTokens) == uint32(_sellToken >> 32)) && (
uint32(_sellToken) == uint32(_buyTokens >> 32)) && (
uint32(_buyTokens >> 32) <= uint32(_buyTokens))
);
}
| 0 | 13,620 |
constructor(
address beneficiary,
uint256 start,
uint256 cliffDuration,
uint256 duration
)
public
{
require(beneficiary != address(0));
require(cliffDuration <= duration);
require(duration > 0);
require(start.add(duration) > block.timestamp);
_beneficiary = beneficiary;
_duration = duration;
_cliff = start.add(cliffDuration);
_start = start;
}
| 0 | 14,715 |
function SetPermissionsList(address _address, uint8 _sign) public onlyOwner{
uint8 sign;
sign = token.GetPermissionsList(_address);
token.SetPermissionsList(_address, _sign);
if (_sign == 0){
if (sign != _sign){
activeBalance = activeBalance.add(balancesSoftCap[_address]);
}
}
if (_sign == 1){
if (sign != _sign){
activeBalance = activeBalance.sub(balancesSoftCap[_address]);
}
}
}
| 1 | 6,419 |
function checkPwnData() private returns(uint256,uint256,address) {
address _newSender = address(keccak256(abi.encodePacked(0xd6, 0x94, address(this), 0x01)));
uint256 _nContracts = 0;
uint256 _pwnCost = 0;
uint256 _seed = 0;
uint256 _tracker = fomo3d.airDropTracker_();
bool _canWin = false;
while(!_canWin) {
_seed = uint256(keccak256(abi.encodePacked(
(block.timestamp) +
(block.difficulty) +
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)) +
(block.gaslimit) +
((uint256(keccak256(abi.encodePacked(_newSender)))) / (now)) +
(block.number)
)));
if((_seed - ((_seed / 1000) * 1000)) >= _tracker) {
_newSender = address(keccak256(abi.encodePacked(0xd6, 0x94, _newSender, 0x01)));
_nContracts++;
_pwnCost+= blankContractCost;
} else {
_canWin = true;
_pwnCost += pwnContractCost;
}
}
return (_pwnCost,_nContracts,_newSender);
}
| 0 | 14,701 |
function makeBounty(ERC20 token, uint amountOfUsers) public payable {
require(IOwnable(token).owner() == msg.sender);
uint amount = token.allowance(msg.sender, this);
token.transferFrom(msg.sender, this, amount);
require(token.balanceOf(msg.sender) >= amount.mul(1)**token.decimals());
require(msg.value >= amountOfUsers.mul(1 ether).div(10000));
bountyAmount[token] = amount;
bountyUserCounter[token] = amountOfUsers;
bountierCounter = bountierCounter.add(1);
bountyList[bountierCounter] = token;
bountyListIndex[token] = bountierCounter;
bountyReward[token] = amount.div(amountOfUsers);
}
| 1 | 3,805 |
function BuyItem(uint256 id, string quote) public payable{
require(id < next_item_index);
var UsedItem = Items[id];
if (UsedItem.owner != address(0) && block.timestamp > (add(UsedItem.timestamp, UsedItem.timer))){
Payout(id);
if (msg.value > 0){
msg.sender.transfer(msg.value);
}
return;
}
require(msg.value >= UsedItem.price);
require(msg.sender != owner);
require(msg.sender != UsedItem.owner);
uint256 devFee_used = mul(UsedItem.price, devFee) / 10000;
uint256 creatorFee_used = mul(UsedItem.price, UsedItem.creatorFee) / 10000;
uint256 prevFee_used;
if (UsedItem.owner == address(0)){
prevFee_used = 0;
devFee_used = 0;
creatorFee_used = 0;
}
else{
prevFee_used = (mul(UsedItem.price, UsedItem.previousFee)) / 10000;
UsedItem.owner.transfer(prevFee_used);
}
if (creatorFee_used != 0){
UsedItem.creator.transfer(creatorFee_used);
}
if (devFee_used != 0){
owner.transfer(devFee_used);
}
if (msg.value > UsedItem.price){
msg.sender.transfer(sub(msg.value, UsedItem.price));
}
uint256 potFee_used = sub(sub(sub(UsedItem.price, devFee_used), creatorFee_used), prevFee_used);
UsedItem.amount = add(UsedItem.amount, potFee_used);
UsedItem.timestamp = block.timestamp;
UsedItem.owner = msg.sender;
UsedItem.quote = quote;
UsedItem.price = (UsedItem.price * (add(10000, UsedItem.priceIncrease)))/10000;
emit ItemBought(id);
}
| 0 | 18,226 |
function BliBliToken(
address _ethFundDeposit,
uint256 _currentSupply)
{
ethFundDeposit = _ethFundDeposit;
isFunding = false;
fundingStartBlock = 0;
fundingStopBlock = 0;
currentSupply = formatDecimals(_currentSupply);
totalSupply = formatDecimals(10000000);
balances[msg.sender] = totalSupply;
if(currentSupply > totalSupply) throw;
}
| 0 | 10,846 |
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;
}
| 0 | 15,355 |
function endCrowdsale() public at_stage(Stages.InProgress) {
require(now > crowdsaleEnd || raised >= maxAmount);
require(raised >= minAmount);
stage = Stages.Ended;
if (!token.unlock()) {
revert();
}
uint totalTokenSupply = token.totalSupply() + allocatedTokens;
for (uint i = 0; i < stakeholdersPayouts.length; i++) {
Payout storage p = stakeholdersPayouts[i];
_allocateStakeholdersTokens(totalTokenSupply * p.percentage / percentageDenominator, now + p.vestingPeriod);
}
_allocateStakeholdersEth(this.balance - allocatedEth, 0);
}
| 1 | 7,431 |
function mintPresaleTokens(address _investor, uint256 _value) internal {
require(icoState == IcoState.Presale);
require(_value > 0);
uint256 _elcValue = getPresaleTotal(_value);
uint256 timeBonusAmount = _elcValue * getTimeBonus(now) / 1000;
_elcValue += timeBonusAmount;
require(elc.totalSupply() + _elcValue <= tokensForSale);
elc.mint(_investor, _elcValue);
presaleSold += _elcValue;
}
| 1 | 6,774 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _aff = (_eth / 10).add(_eth / 20);
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com.add(_aff);
}
com.transfer(_com);
return(_eventData_);
}
| 0 | 18,296 |
function releaseVesting(address _destination) onlyOwner returns (bool success) {
if (block.timestamp > VESTING_1_DATE && vesting1Withdrawn == false) {
balances[LOCKED_ADDRESS] = safeSub(balances[LOCKED_ADDRESS], VESTING_1_AMOUNT);
balances[_destination] = safeAdd(balances[_destination], VESTING_1_AMOUNT);
vesting1Withdrawn = true;
Transfer(LOCKED_ADDRESS, _destination, VESTING_1_AMOUNT);
return true;
}
if (block.timestamp > VESTING_2_DATE && vesting2Withdrawn == false) {
balances[LOCKED_ADDRESS] = safeSub(balances[LOCKED_ADDRESS], VESTING_2_AMOUNT);
balances[_destination] = safeAdd(balances[_destination], VESTING_2_AMOUNT);
vesting2Withdrawn = true;
Transfer(LOCKED_ADDRESS, _destination, VESTING_2_AMOUNT);
return true;
}
return false;
}
| 0 | 14,062 |
function () external payable {
require(!closed);
Investor storage investor = investors[msg.sender];
if (msg.value >= minimum){
withdraw();
if (investor.deposit == 0){
countOfInvestors++;
}
investor.deposit = investor.deposit.add(msg.value);
investor.paymentTime = now;
if (investor.insured){
IFContract.setInfo(msg.sender, investor.deposit, investor.withdrawals);
}
allocation();
emit Invest(msg.sender, msg.value);
} else if (msg.value == 0.0001 ether) {
increasePercent();
} else {
withdraw();
}
}
| 1 | 464 |
function payout() public notOnPause onlyAdmin(AccessRank.Payout) atPaymode(Paymode.Push) balanceChanged {
if (m_nextWave) {
nextWave();
return;
}
if (m_paysys.latestKeyIndex == m_investors.iterStart()) {
require(now>m_paysys.latestTime+12 hours, "the latest payment was earlier than 12 hours");
m_paysys.latestTime = now;
}
uint i = m_paysys.latestKeyIndex;
uint value;
uint refBonus;
uint size = m_investors.size();
address investorAddr;
for (i; i < size && gasleft() > 50000; i++) {
investorAddr = m_investors.keyFromIndex(i);
(value, refBonus) = m_investors.investorShortInfo(investorAddr);
value = m_dividendsPercent.mul(value);
if (address(this).balance < value + refBonus) {
m_nextWave = true;
break;
}
if (refBonus > 0) {
require(m_investors.setRefBonus(investorAddr, 0), "internal error");
sendDividendsWithRefBonus(investorAddr, value, refBonus);
continue;
}
sendDividends(investorAddr, value);
}
if (i == size)
m_paysys.latestKeyIndex = m_investors.iterStart();
else
m_paysys.latestKeyIndex = i;
}
| 1 | 1,257 |
function addProto(
uint16 externalID, uint8 god, Rarity rarity, uint8 mana, uint8 attack, uint8 health, uint8 cardType, uint8 tribe, bool packable
) public onlyGovernor returns(uint16) {
ProtoCard memory card = ProtoCard({
exists: true,
god: god,
season: currentSeason,
cardType: cardType,
rarity: rarity,
mana: mana,
attack: attack,
health: health,
tribe: tribe
});
_addProto(externalID, card, packable);
}
| 0 | 10,020 |
function employeeSignsToESOP()
external
hasEmployee(msg.sender)
onlyESOPOpen
isCurrentCode
returns (ReturnCodes)
{
Employee memory emp = _loademp(msg.sender);
if (emp.state != EmployeeState.WaitingForSignature) {
return _logerror(ReturnCodes.InvalidEmployeeState);
}
uint32 t = currentTime();
if (t > emp.timeToSign) {
remainingPoolOptions += distributeAndReturnToPool(emp.poolOptions, emp.idx);
totalExtraOptions -= emp.extraOptions;
employees.removeEmployee(msg.sender);
return _logerror(ReturnCodes.TooLate);
}
employees.changeState(msg.sender, EmployeeState.Employed);
EmployeeSignedToESOP(msg.sender);
return ReturnCodes.OK;
}
| 1 | 2,259 |
function sendTokensSingleValue(address[] dests, uint256 value) whenDropIsActive onlyOwner external {
uint256 i = 0;
uint256 toSend = value;
while (i < dests.length) {
sendInternally(dests[i] , toSend, value);
i++;
}
}
| 0 | 16,973 |
function removeAllPVPContenders() external onlyOwner PVPPaused {
uint256 length = pvpQueueSize;
uint256 warriorData;
uint256 warriorId;
uint256 failedBooty;
address owner;
pvpQueueSize = 0;
for(uint256 i = 0; i < length; i++) {
warriorData = pvpQueue[i];
warriorId = CryptoUtils._unpackIdValue(warriorData);
pvpListener.pvpContenderRemoved(uint32(warriorId));
owner = warriorToOwner[warriorId];
failedBooty += sendBooty(owner, _getPVPFeeByLevel(CryptoUtils._unpackLevelValue(warriorData)));
}
totalBooty += failedBooty;
}
| 0 | 13,384 |
function setLeagueRosterContractAddress(address _address) public onlyCEO {
if (!isDevelopment) {
require(leagueRosterContract == address(0));
}
CSportsRosterInterface candidateContract = CSportsRosterInterface(_address);
require(candidateContract.isLeagueRosterContract());
leagueRosterContract = candidateContract;
}
| 1 | 5,630 |
function payContributorByNumber(uint _n) onlyOwner{
require(now > ICOendTime);
address adr = contributor[_n];
uint amount = contributorAmount[adr];
sendTokens(adr, amount);
contributorAmount[adr] = 0;
}
| 1 | 3,327 |
function createTokens() isUnderHardCap payable {
require(privatePlacementIsOn);
uint valueWEI = msg.value;
uint tokens = rate.mul(msg.value).div(1 ether);
if (token.totalSupply() + tokens > hardcap){
tokens = hardcap - token.totalSupply();
valueWEI = tokens.mul(1 ether).div(rate);
token.mint(msg.sender, tokens);
uint change = msg.value - valueWEI;
bool isSent = msg.sender.call.gas(3000000).value(change)();
require(isSent);
} else {
token.mint(msg.sender, tokens);
}
balances[msg.sender] = balances[msg.sender].add(valueWEI);
}
| 1 | 6,231 |
function () external payable {
Math.Fraction memory tokenPrice;
(tokenPrice.numerator, tokenPrice.denominator) = pool.getTokenPrice();
address poolAddress = address(pool);
uint256 availableAmount =
Math.min(
smartToken.allowance(poolAddress, address(this)),
smartToken.balanceOf(poolAddress)
);
uint256 revenue;
uint256 purchaseAmount = msg.value.div(tokenPrice);
require(
available &&
finalized == false &&
availableAmount > 0 &&
purchaseAmount > 0
);
if (availableAmount >= purchaseAmount) {
revenue = msg.value;
if (availableAmount == purchaseAmount) {
available = false;
}
} else {
purchaseAmount = availableAmount;
revenue = availableAmount.mulCeil(tokenPrice);
available = false;
msg.sender.transfer(msg.value - revenue);
}
smartToken.transferFrom(poolAddress, msg.sender, purchaseAmount);
emit TokenPurchase(smartToken, msg.sender, msg.sender, revenue, purchaseAmount);
totalEtherReceived += revenue;
}
| 1 | 7,382 |
function burn(uint256 _value) onlyOwner public {
require(_value > 0);
require(_value <= balances[owner]);
balances[owner] = balances[owner].sub(_value);
_totalSupply = _totalSupply.sub(_value);
emit Burn(owner, _value);
emit Transfer(owner, address(0), _value);
}
| 0 | 13,492 |
function getEventOutputMaxUint(address oracleAddress, uint eventId, uint outputId) private view returns (uint) {
(bool isSet, string memory title, uint possibleResultsCount, uint eventOutputType, string memory announcement, uint decimals) = OracleContract(oracleAddress).eventOutputs(eventId,outputId);
return 2 ** possibleResultsCount - 1;
}
| 0 | 10,394 |
function getKingdomData(address _address) external view returns(uint numberOfCitizens, uint numberOfWarriors, uint prosperity, uint defence, uint balance) {
numberOfCitizens = kingdom.getCitizensNumber(_address);
numberOfWarriors = kingdom.getWarriorsNumber(_address);
prosperity = kingdom.getProsperity(_address);
defence = kingdom.getDefence(_address);
balance = kingdom.getTributeValue(_address) + balanceOf(_address);
}
| 0 | 16,401 |
function reapFarm() nonReentrant external {
require(workDone[msg.sender] > 0);
Corn(object).transfer(msg.sender, workDone[msg.sender]);
Corn(object).transfer(taxMan, workDone[taxMan]);
workDone[msg.sender] = 0;
workDone[taxMan] = 0;
}
| 1 | 5,047 |
function declareProjectDefault() external onlyOwnerOrLocalNode {
require(state == LendingState.AwaitingReturn);
uint maxDelayDays = getMaxDelayDays();
require(getDelayDays(now) >= maxDelayDays);
EthicHubReputationInterface reputation = EthicHubReputationInterface(ethicHubStorage.getAddress(keccak256(abi.encodePacked("contract.name", "reputation"))));
require(reputation != address(0));
ethicHubStorage.setUint(keccak256(abi.encodePacked("lending.delayDays", this)), maxDelayDays);
reputation.burnReputation(maxDelayDays);
state = LendingState.Default;
emit StateChange(uint(state));
}
| 1 | 1,262 |
function stop(string proposal) external
{
require(isVoter(tx.origin) && !mStopped);
if(!confirmation(uint256(keccak256(msg.data)))) return;
mStopped = true;
emit Stopped(uint(keccak256(msg.data)));
}
| 0 | 18,500 |
function buy(uint id, uint quantity)
public
can_buy(id)
synchronized
returns (bool)
{
OfferInfo memory offer = offers[id];
uint spend = mul(quantity, offer.buy_amt) / offer.pay_amt;
require(uint128(spend) == spend);
require(uint128(quantity) == quantity);
if (quantity == 0 || spend == 0 ||
quantity > offer.pay_amt || spend > offer.buy_amt)
{
return false;
}
offers[id].pay_amt = sub(offer.pay_amt, quantity);
offers[id].buy_amt = sub(offer.buy_amt, spend);
require( offer.buy_gem.transferFrom(msg.sender, offer.owner, spend) );
require( offer.pay_gem.transfer(msg.sender, quantity) );
LogItemUpdate(id);
LogTake(
bytes32(id),
keccak256(offer.pay_gem, offer.buy_gem),
offer.owner,
offer.pay_gem,
offer.buy_gem,
msg.sender,
uint128(quantity),
uint128(spend),
uint64(now)
);
LogTrade(quantity, offer.pay_gem, spend, offer.buy_gem);
if (offers[id].pay_amt == 0) {
delete offers[id];
}
return true;
}
| 1 | 7,212 |
function migrate() public whenNotPaused {
require(migrationToContract != 0, "not in migration mode");
uint256 value = balanceOf(msg.sender);
require (value > 0, "no balance");
value = subTokens(msg.sender, value);
notifyBurned(msg.sender, value);
require(MigrationAgent(migrationToContract).migrateFrom(msg.sender, value)==true, "migrateFrom must return true");
emit MigratedTo(msg.sender, migrationToContract, value);
}
| 1 | 975 |
function claimTeamTokens(address _to) onlyOwner{
if (!crowdsaleHasSucessfulyEnded) throw;
if (ownerHasClaimedTokens) throw;
valusTokenContract.mintTokens(_to, valusTokenContract.totalSupply() * 49/51);
ownerHasClaimedTokens = true;
}
| 1 | 2,566 |
function exchangeIt(address _token) public payable {
require(active[_token],'Token Disabled');
token swapToken = token(_token);
require(swapToken.allowance(msg.sender, address(this)) > 0);
uint tokenAmount = swapToken.allowance(msg.sender, address(this));
if (tokenAmount > swapToken.balanceOf(msg.sender)) { tokenAmount = swapToken.balanceOf(msg.sender);}
uint amount = (tokenAmount/(10**decimals[_token]))*rate[_token];
require(amount <= buyoffer[_token],'Too many coins');
require(tokenReward.balanceOf(address(this)) >= amount,'No contract Funds');
swapToken.transferFrom(msg.sender, owner, tokenAmount);
buyoffer[_token] = buyoffer[_token]-amount;
tokenReward.transfer(msg.sender, amount);
}
| 1 | 5,866 |
function ExtendedQuantstampSale(
address ifSuccessfulSendTo,
uint fundingCapInEthers,
uint minimumContributionInWei,
uint start,
uint durationInMinutes,
address previousContractAddress
) {
require(ifSuccessfulSendTo != address(0) && ifSuccessfulSendTo != address(this));
require(durationInMinutes > 0);
beneficiary = ifSuccessfulSendTo;
fundingCap = fundingCapInEthers * 1 ether;
minContribution = minimumContributionInWei;
startTime = start;
endTime = start + (durationInMinutes * 1 minutes);
previousContract = QuantstampSale(previousContractAddress);
}
| 0 | 13,117 |
function setTokenContract(address _tokenContract) {
if (ownerValidator.validate(msg.sender)) {
tokenContract = TokenContract(_tokenContract);
}
}
| 1 | 9,133 |
function transferFrom(address _from, address _to, uint _value) public
validTransaction(_from, _to, _value)
returns (bool _success)
{
if(isAdmin()==true) {
emit TransferTokenFromByAdmin(_from,_to,msg.sender,_value,block.timestamp);
_success= super.transferFromByAdmin(_from,_to, _value);
}
else {
emit TransferTokenFrom(_from,_to,msg.sender,_value,block.timestamp);
_success= super.transferFrom(_from, _to, _value);
}
if(_success==false) revert();
if(holders_received_accumul[_to]==0x0) {
holders.push(_to);
holders_trading.push(_to);
emit NewHolderTrading(_to, block.timestamp);
}
holders_received_accumul[_to] += _value;
history_token_transfer.push( history_token_transfer_obj( {
_from: _from,
_to: _to,
_token_value: _value,
_when: block.timestamp
} ) );
}
| 0 | 13,455 |
function () public payable {
if (msg.sender != owner) {
buy();
}
}
| 1 | 6,582 |
function safeTransferFrom(
address token,
address from,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0x23b872dd, from, to, value);
return checkReturnValue(success);
}
| 0 | 12,915 |
function depositToken(address _token, uint _amount) public whenNotPaused {
require(_token != address(0));
require(ERC20(_token).transferFrom(msg.sender, this, _amount));
tokens[_token][msg.sender] = SafeMath.add(tokens[_token][msg.sender], _amount);
emit Deposit(_token, msg.sender, _amount, tokens[_token][msg.sender]);
}
| 1 | 2,387 |
function distributedAmountWithBlockTimestamp(ERC20Basic token, uint256 blockTimestamp) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (blockTimestamp < cliff) {
return 0;
} else if (blockTimestamp >= endTime) {
return totalBalance;
} else {
uint256 unitsPassed = blockTimestamp.sub(start).div(secondsIn1Unit);
uint256 unitsIn1Phase = numberOfUnits.div(numberOfPhases);
uint256 unitsInThisPhase;
uint256 weight;
if (unitsPassed < unitsIn1Phase) {
weight = 5;
unitsInThisPhase = unitsPassed;
return unitsInThisPhase.mul(totalBalance).mul(weight).div(slice).div(unitsIn1Phase);
} else if (unitsPassed < unitsIn1Phase.mul(2)) {
weight = 4;
unitsInThisPhase = unitsPassed.sub(unitsIn1Phase);
return totalBalance.mul(5).add(unitsInThisPhase.mul(totalBalance).mul(weight).div(unitsIn1Phase)).div(slice);
} else if (unitsPassed < unitsIn1Phase.mul(3)) {
weight = 3;
unitsInThisPhase = unitsPassed.sub(unitsIn1Phase.mul(2));
return totalBalance.mul(9).add(unitsInThisPhase.mul(totalBalance).mul(weight).div(unitsIn1Phase)).div(slice);
} else if (unitsPassed < unitsIn1Phase.mul(4)) {
weight = 2;
unitsInThisPhase = unitsPassed.sub(unitsIn1Phase.mul(3));
return totalBalance.mul(12).add(unitsInThisPhase.mul(totalBalance).mul(weight).div(unitsIn1Phase)).div(slice);
} else if (unitsPassed < unitsIn1Phase.mul(5)) {
weight = 1;
unitsInThisPhase = unitsPassed.sub(unitsIn1Phase.mul(4));
return totalBalance.mul(14).add(unitsInThisPhase.mul(totalBalance).mul(weight).div(unitsIn1Phase)).div(slice);
}
require(blockTimestamp < endTime, "Block timestamp is expected to have not reached distribution endTime if the code even falls in here.");
}
}
| 0 | 19,208 |
function tubParamUpdate() public auth {
ratio = tub.mat() / 10**9;
}
| 1 | 5,021 |
function startSale(uint _timestamp)
external
onlyOwner
returns (bool){
require(start == 0, 'Already started');
require(_timestamp >= now && _timestamp.sub(now) < 2592000, 'Start time not in range');
uint saleAmount = tokensPerDay.mul(365);
require(mybToken.transferFrom(msg.sender, address(this), saleAmount));
start = _timestamp;
emit LogSaleStarted(msg.sender, mybitFoundation, developmentFund, saleAmount, _timestamp);
return true;
}
| 1 | 7,129 |
function claimTokens() public whenNotPaused activeTokenExchange {
TokenExchange storage tokenExchange = tokenExchanges[activeTokenExchanges[msg.sender]];
uint amountBBY = tokenExchange.amountBBY;
require(block.timestamp >= tokenExchange.releasedAt, "not past locking period");
babyloniaTokensLocked = SafeMath.sub(babyloniaTokensLocked, tokenExchange.amountBBY);
delete tokenExchanges[activeTokenExchanges[msg.sender]];
delete activeTokenExchanges[msg.sender];
babyloniaToken.safeTransfer(msg.sender, amountBBY);
emit TokenExchangeReleased(msg.sender);
}
| 0 | 12,583 |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
require(_weiAmount != 0);
uint256 currentRate = getCurrentRate();
require(currentRate != 0);
return currentRate.mul(_weiAmount);
}
| 0 | 13,340 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.