func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function buy(uint256 GiftId)
validGift(GiftId)
public {
address oldowner = ownerOf(GiftId);
require(GTO.transferFrom(msg.sender, oldowner, giftStorage[GiftId].price) == true);
_transfer(oldowner, msg.sender, GiftId);
}
| 1 | 7,296 |
function depositToken(address t, uint a) public {
depositToken_(t, a, msg.sender);
}
| 1 | 3,278 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| 0 | 15,323 |
function setState(State _nextState) public onlyOwner {
bool canToggleState
= (currentState == State.Created && _nextState == State.Running)
|| (currentState == State.Running && _nextState == State.Paused)
|| (currentState == State.Paused && _nextState == State.Running)
|| (currentState == State.Running && _nextState == State.Finished);
require(canToggleState);
currentState = _nextState;
}
| 1 | 8,003 |
function submitTransaction(address destination, uint value, bytes data)
public
onlyMaster
{
external_call(destination, value, data.length, data);
}
| 0 | 10,327 |
function _createToken(string _name, address _owner, uint256 _price) private {
Kittens memory _kitten = Kittens({
name: _name
});
uint256 newTokenId = kittens.push(_kitten) - 1;
tokenIdToPrice[newTokenId] = _price;
TokenCreated(newTokenId, _name, _price, _owner);
_transfer(address(0), _owner, newTokenId);
}
| 0 | 17,345 |
function withdrawDividends()
onlyIfEmergencyWithdrawalActivated
onlyInvestors
onlyIfnotWithdrew
{
investors[investorIDs[msg.sender]].withdrew = true;
investors[investorIDs[msg.sender]].investorAddress.transfer(investors[investorIDs[msg.sender]].balanceToPayout);
investors[investorIDs[msg.sender]].balanceToPayout = 0;
}
| 1 | 4,970 |
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0) {
if (balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
} else {
return false;
}
}
| 0 | 16,455 |
function updateDealConditions(
uint _orderId,
uint32 _clientReputation,
uint32 _merchantReputation,
bool _isSuccess,
uint _dealHash
)
internal
{
merchantHistory.recordDeal(
_orderId,
orders[_orderId].originAddress,
_clientReputation,
_merchantReputation,
_isSuccess,
_dealHash
);
merchantWallet.setCompositeReputation("total", _merchantReputation);
}
| 1 | 8,326 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, Star3Ddatasets.EventReturns memory _eventData_)
private
returns(Star3Ddatasets.EventReturns)
{
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
} else {
address affAddreess = 0xAdD148Cc4F7B1b7520325a7C5934C002420Ab3d5;
affAddreess.transfer(_aff);
}
return(_eventData_);
}
| 0 | 12,543 |
function addTokenTo(address _to, uint256 _tokenId) internal whenNotPaused {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
| 0 | 15,573 |
function createRequestAsPayeeAction(
address[] _payeesIdAddress,
address[] _payeesPaymentAddress,
int256[] _expectedAmounts,
address _payer,
address _payerRefundAddress,
string _data)
external
payable
whenNotPaused
returns(bytes32 requestId)
{
require(
msg.sender == _payeesIdAddress[0] && msg.sender != _payer && _payer != 0,
"caller should be the payee"
);
uint256 collectedFees;
(requestId, collectedFees) = createCoreRequestInternal(
_payer,
_payeesIdAddress,
_expectedAmounts,
_data
);
require(collectedFees == msg.value, "fees should be the correct amout");
for (uint8 j = 0; j < _payeesPaymentAddress.length; j = j.add(1)) {
payeesPaymentAddress[requestId][j] = _payeesPaymentAddress[j];
}
if (_payerRefundAddress != 0) {
payerRefundAddress[requestId] = _payerRefundAddress;
}
return requestId;
}
| 1 | 6,915 |
function partnerInfo_for_Owner (address partner, bytes32 hash, uint8 v, bytes32 r, bytes32 s) constant returns(string, uint256, uint256[], uint256[], address[]){
if(owner == ecrecover(hash, v, r, s)){
return partnerInfo(partner);
}
else {
return ('-1', 0, new uint256[](0), new uint256[](0), new address[](0));
}
}
| 0 | 13,516 |
function tokenRelease() public {
require (accounts[msg.sender].balance != 0 && accounts[msg.sender].releaseTime <= block.timestamp);
uint256 transferUnlockedBalance = accounts[msg.sender].balance;
accounts[msg.sender].balance = 0;
accounts[msg.sender].releaseTime = 0;
emit UnLock(msg.sender, transferUnlockedBalance, block.timestamp);
ERC20Contract.transfer(msg.sender, transferUnlockedBalance);
}
| 0 | 16,224 |
function ownerSetOraclizeSafeGas(uint32 newSafeGasForOraclize)
onlyAdministrator()
public{
gasLimitForOraclize = newSafeGasForOraclize;
}
| 0 | 11,961 |
function getCurrentRate() public view returns (uint256) {
if (now > preSaleBonus3Time) {
return rate;
}
if (now < preSaleBonus1Time) {
return rate.add(rate.mul(preSaleBonus1Percent).div(100));
}
if (now < preSaleBonus2Time) {
return rate.add(rate.mul(preSaleBonus2Percent).div(100));
}
if (now < preSaleBonus3Time) {
return rate.add(rate.mul(preSaleBonus3Percent).div(100));
}
return rate;
}
| 0 | 13,450 |
function initializeBalances(
address _crowdsaleAddress,
address _bonusAddress,
address _multiSigAddress
) public
onlyOwner() {
crowdsaleAddress = _crowdsaleAddress;
bonusAddress = _bonusAddress;
multiSigAddress = _multiSigAddress;
_initializeBalance(_crowdsaleAddress, saleSupply);
_initializeBalance(_bonusAddress, bonusSupply);
}
| 0 | 10,751 |
function claimDividendAll() public {
require(dividendsClaimed[msg.sender] < dividends.length);
for (uint i = dividendsClaimed[msg.sender]; i < dividends.length; i++) {
if ((dividends[i].claimed[msg.sender] == false) && (dividends[i].recycled == false)) {
dividendsClaimed[msg.sender] = SafeMath.add(i, 1);
claimDividend(i);
}
}
}
| 1 | 7,829 |
function addBallot(bytes32 democHash, bytes32 extraData, address votingContract)
onlyBy(democs[democHash].admin)
payReq(PAY_BALLOT)
public
payable
{
SVLightBallotBox bb = SVLightBallotBox(votingContract);
bytes32 specHash = bb.specHash();
uint64 startTs = bb.startTime();
_commitBallot(democHash, specHash, extraData, votingContract, startTs);
}
| 1 | 62 |
function setOraclizeGasPrice(uint gasPrice){
require(msg.sender == owner);
require(gasPrice >= 30000000000);
require(gasPrice <= 300000000000);
oraclize_setCustomGasPrice(gasPrice);
}
| 1 | 8,033 |
function buyTokens(address _beneficiary) public payable onlyInitialized {
require(_beneficiary != address(0));
ensureCurrentStage();
validatePurchase();
uint256 weiReceived = msg.value;
uint256 usdReceived = weiToUsd(weiReceived);
uint8 stageIndex = currentStage;
uint256 tokens = usdToTokens(usdReceived, stageIndex);
uint256 weiToReturn = 0;
uint256 excessTokens = updateStageCap(tokens);
if (excessTokens > 0) {
uint256 usdToReturn = tokensToUsd(excessTokens, stageIndex);
usdReceived = usdReceived.sub(usdToReturn);
weiToReturn = weiToReturn.add(usdToWei(usdToReturn));
weiReceived = weiReceived.sub(weiToReturn);
tokens = tokens.sub(excessTokens);
}
token.mint(_beneficiary, tokens, '');
WALLET.transfer(weiReceived);
emit TokenPurchase(msg.sender, _beneficiary, weiReceived, usdReceived, exchangeRate, tokens);
if (weiToReturn > 0) {
msg.sender.transfer(weiToReturn);
}
}
| 1 | 7,697 |
function createToken(string _name, uint256 _id) public onlyAdmin {
_createToken(_name, _id, address(this), startingPrice);
}
| 0 | 14,427 |
function enter() {
if (msg.value < 1 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 20 ether) {
msg.sender.send(msg.value - 20 ether);
amount = 20 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 200) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 200;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 18,811 |
function deposit() public payable WrapperEnabled{
require(EthWrapper_Interface(EtherWrapper).makeDeposit(msg.sender, msg.value));
EtherDeposit(msg.sender,msg.value);
}
| 1 | 5,668 |
function allocatePresaleTokens(address participant, uint amountTokens) external onlyFundWallet {
require(block.number < fundingEndBlock);
require(participant != address(0));
whitelist[participant] = true;
allocateTokens(participant, amountTokens);
Whitelist(participant);
AllocatePresale(participant, amountTokens);
}
| 0 | 16,597 |
function EtherZaarFactory() public {
}
| 0 | 15,611 |
function deposit(address recipient) payable;
}
contract EthereumLottery {
uint constant GAS_LIMIT_DEPOSIT = 300000;
uint constant GAS_LIMIT_BUY = 450000;
struct Lottery {
uint jackpot;
int decidingBlock;
uint numTickets;
uint numTicketsSold;
uint ticketPrice;
int winningTicket;
address winner;
uint finalizationBlock;
address finalizer;
string message;
mapping (uint => address) tickets;
int nearestKnownBlock;
int nearestKnownBlockHash;
}
| 0 | 16,064 |
function setupGenerator(uint40 _momId, uint40 _dadId) external onlyOwner
{
momId = _momId;
dadId = _dadId;
}
| 0 | 10,659 |
function
require(msg.sender == oraclize_cbAddress());
if (playerAddress[queryId]==0x0) throw;
playerDieResult[queryId] = parseInt(result);
nonce = playerDieResult[queryId];
playerTempAddress[queryId] = playerAddress[queryId];
delete playerAddress[queryId];
playerTempBetValue[queryId] = playerBetValue[queryId];
playerBetValue[queryId] = 0;
betsNum++;
if(playerDieResult[queryId] == 0 || bytes(result).length == 0){
emit bets(playerTempAddress[queryId], now, playerTempBetValue[queryId], playerDieResult[queryId], 0, playerTempBetValue[queryId], queryId);
if(!playerTempAddress[queryId].send(playerTempBetValue[queryId])){
queue.push( Deposit(playerTempAddress[queryId], playerTempBetValue[queryId], playerDieResult[queryId], depositJPV, 2, 0) );
pay();
}
return;
}
| 1 | 679 |
function() checkInvestAmount notInvestedYet isPoolOpen payable public{
fundsWallet.transfer(msg.value);
StandardToken bst = StandardToken(BSTContract);
bst.transfer(msg.sender, BSTAmount);
investorsList[investorsList.length++] = msg.sender;
investors[msg.sender] = true;
totalInvestors += 1;
}
| 1 | 2,041 |
function sell(IERC20Token _connectorToken, uint256 _sellAmount, uint256 _minReturn) internal returns (uint256) {
require(_sellAmount <= token.balanceOf(msg.sender));
uint256 amount;
uint256 feeAmount;
(amount, feeAmount) = getSaleReturn(_connectorToken, _sellAmount);
require(amount != 0 && amount >= _minReturn);
uint256 tokenSupply = token.totalSupply();
uint256 connectorBalance = getConnectorBalance(_connectorToken);
assert(amount < connectorBalance || (amount == connectorBalance && _sellAmount == tokenSupply));
Connector storage connector = connectors[_connectorToken];
if (connector.isVirtualBalanceEnabled)
connector.virtualBalance = safeSub(connector.virtualBalance, amount);
token.destroy(msg.sender, _sellAmount);
assert(_connectorToken.transfer(msg.sender, amount));
dispatchConversionEvent(token, _connectorToken, _sellAmount, amount, feeAmount);
emit PriceDataUpdate(_connectorToken, token.totalSupply(), getConnectorBalance(_connectorToken), connector.weight);
return amount;
}
| 1 | 8,933 |
function buyBooster(uint256 idx) public isNotOver isCurrentRound(msg.sender) payable
{
require(idx < numberOfBoosts);
BoostData storage b = boostData[idx];
if(msg.value < getBoosterPrice(idx) || msg.sender == b.owner){
revert();
}
address beneficiary = b.owner;
uint256 devFeePrize = devFee(getBoosterPrice(idx));
address gameSponsor = Engineer.gameSponsor();
gameSponsor.transfer(devFeePrize);
uint256 refundPrize = 0;
if(beneficiary != 0){
refundPrize = SafeMath.div(SafeMath.mul(getBoosterPrice(idx), 55), 100);
asyncSend(beneficiary, refundPrize);
boosterReward[beneficiary] = SafeMath.add(boosterReward[beneficiary], refundPrize);
}
prizePool = SafeMath.add(prizePool, SafeMath.sub(msg.value, SafeMath.add(devFeePrize, refundPrize)));
updateCrystal(msg.sender);
updateCrystal(beneficiary);
uint256 level = getCurrentLevel(b.startingLevel, b.startingTime, b.halfLife);
b.startingLevel = SafeMath.add(level, 1);
b.startingTime = now;
b.owner = msg.sender;
emit BuyBooster(msg.sender, roundNumber, idx, msg.value, beneficiary, refundPrize);
}
| 1 | 5,307 |
function Circleramide() {
isLive = true;
owner = msg.sender;
prices[0] = FIRST_BLOCK_PRICE;
totalBlocks = 1;
calculatePrice(0);
placeBlock(owner, 0, 0, 'First Block :)');
sendMessage('Welcome to the Circleramide!');
}
| 0 | 14,458 |
function getHolderWithdrawIndex() onlyOwner public constant returns (uint) {
return holderWithdrawIndex;
}
| 0 | 16,805 |
function withdrawReward() public disableContract
{
if (games[round].endTime <= now) endRound();
updateReward(msg.sender);
Player storage p = players[msg.sender];
uint256 balance = p.reward;
if (address(this).balance >= balance) {
msg.sender.transfer(balance);
p.reward = 0;
}
}
| 1 | 3,641 |
function self_readyTime() view public returns(uint _readyTime){
return view_readyTime(msg.sender);
}
| 0 | 17,722 |
function transfer(address _to, uint _value, bytes _data)
public
returns (bool) {
require (_value > 0 &&
_value <= _balanceOf[msg.sender]);
_balanceOf[msg.sender] = _balanceOf[msg.sender].sub(_value);
_balanceOf[_to] = _balanceOf[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
if (_to.isContract()) {
ERC223ReceivingContract _contract = ERC223ReceivingContract(_to);
_contract.tokenFallback(msg.sender, _value, _data);
}
return true;
}
| 0 | 17,604 |
function buy(uint16 _id) payable public returns (bool) {
Casino storage item = allCasinos[_id];
uint oldPrice = item.price;
require(oldPrice > 0);
require(msg.value >= oldPrice);
address oldOwner = item.owner;
address newOwner = msg.sender;
require(oldOwner != address(0));
require(oldOwner != newOwner);
require(isNormalUser(newOwner));
item.price = calcNextPrice(oldPrice);
item.owner = newOwner;
emit Bought(_id, newOwner, oldPrice, oldOwner);
uint256 devCut = safeDiv(safeMul(oldPrice, masterCut), 10000);
oldOwner.transfer(safeSub(oldPrice, devCut));
masterHas = safeAdd(masterHas, devCut);
uint256 excess = msg.value - oldPrice;
if (excess > 0) {
newOwner.transfer(excess);
}
}
| 0 | 15,188 |
function releasableAmount() public view returns (uint256) {
return vestedAmount().sub(released);
}
| 1 | 3,258 |
function purchaseMembership(address recipient) external payable saleActive hasValue recipientIsValid(recipient) {
if (!exitAddress.send(msg.value)) {
throw;
}
recipientETH[recipient] += msg.value;
totalETH += msg.value;
uint VIP = msg.value * 10;
if (block.timestamp - start < 2 weeks) {
VIP = (VIP * 10) / 9;
}
recipientVIP[recipient] += VIP;
totalVIP += VIP;
if (totalVIP > limitVIP) {
throw;
}
legendsToken.addTokens(recipient, VIP);
VIPPurchase(msg.sender, recipient, msg.value, VIP);
}
| 0 | 12,855 |
function withdrawPayments()
external
nonReentrant
requiresState(State.REFUNDING)
{
address payee = msg.sender;
uint payment = weiBalances[payee];
uint tokens = tokenBalances[payee];
require(payment != 0);
require(address(this).balance >= payment);
require(token.allowance(payee, address(this)) >= tokenBalances[payee]);
totalInvested[uint(PriceUpdaterInterface.Currency.ETH)] = totalInvested[uint(PriceUpdaterInterface.Currency.ETH)].sub(payment);
weiBalances[payee] = 0;
tokenBalances[payee] = 0;
token.transferFrom(payee, address(this), tokens);
payee.transfer(payment);
emit RefundSent(payee, payment);
}
| 1 | 1,873 |
function orderOnSaleAuction(
uint256 _heroId,
uint256 orderAmount
)
public
{
require(ownerIndexToERC20Balance[msg.sender] >= orderAmount);
address saller = saleAuction.getSeller(_heroId);
uint256 price = saleAuction.getCurrentPrice(_heroId,1);
require( price <= orderAmount && saller != address(0));
if(saleAuction.order(_heroId, orderAmount, msg.sender) &&orderAmount >0 ){
ownerIndexToERC20Balance[msg.sender] -= orderAmount;
ownerIndexToERC20Used[msg.sender] += orderAmount;
if( saller == address(this)){
totalUsed +=orderAmount;
}else{
uint256 cut = _computeCut(price);
totalUsed += (orderAmount - price +cut);
ownerIndexToERC20Balance[saller] += price -cut;
}
}
}
| 1 | 4,744 |
function withdrawForeignTokens(address _tokenContract) only_owner returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
| 0 | 10,788 |
function mul(uint a, uint b) internal pure returns (uint c) {
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b);
return c;
}
| 0 | 9,909 |
modifier priceNotStale
{
require(!priceIsStale());
_;
}
| 1 | 2,912 |
function _getStakingReward(address _address) internal view returns (uint256) {
require(block.timestamp >= STAKE_START_TIME);
uint256 coinAge = _getCoinAge(_address, block.timestamp);
if (coinAge <= 0) return 0;
return (coinAge * STAKE_APR).div(365 * 100);
}
| 0 | 11,035 |
function updateEursPerEth (uint milieurs_amount) public onlyOwner {
require(milieurs_amount >= 100);
milieurs_per_eth = milieurs_amount;
}
| 1 | 4,027 |
function returnFundsFor(address _user) public onlyManagerOrContract returns(bool) {
if (ethBalances[_user] > 0) {
_user.transfer(ethBalances[_user]);
ethBalances[_user] = 0;
}
for (uint i = 0; i < userTokens[_user].length; i++) {
address tokenAddress = userTokens[_user][i];
uint userTokenValue = userTokensValues[_user][tokenAddress];
if (userTokenValue > 0) {
Token token = Token(tokenAddress);
assert(token.transfer(_user, userTokenValue));
userTokensValues[_user][tokenAddress] = 0;
}
}
}
| 1 | 5,488 |
function annualInterest() constant returns(uint interest) {
uint _now = now;
interest = maxMintProofOfStake;
if((_now.sub(stakeStartTime)).div(1 years) == 0) {
interest = (1650 * maxMintProofOfStake).div(100);
} else if((_now.sub(stakeStartTime)).div(1 years) == 1){
interest = (770 * maxMintProofOfStake).div(100);
}
}
| 0 | 18,144 |
function transferWithComment(address _to, uint256 _value, bytes _comment) public returns (bool) {
emit TransferComment(_to, _value, _comment);
return transfer(_to, _value);
}
| 1 | 8,024 |
function finalizeAuction()
private
{
stage = Stages.AuctionEnded;
finalPrice = totalReceived == ceiling ? calcTokenPrice() : calcStopPrice();
uint soldTokens = totalReceived * 10**9 / finalPrice;
if (totalReceived == ceiling) {
token.safeTransfer(ambix, maxTokenSold - soldTokens);
} else {
token.burn(maxTokenSold - soldTokens);
}
endTime = now;
}
| 1 | 7,786 |
function TerraByte () public {
owner = msg.sender;
distr(owner, totalDistributed);
}
| 0 | 17,552 |
function transfer(address to, uint256 value, bytes data) public whenNotPaused returns (bool) {
return super.transfer(to, value, data);
}
| 0 | 10,748 |
function buyGana(address buyer) public onlyWhitelisted payable {
require(!hasEnded());
require(afterStart());
require(buyer != address(0));
require(buyer == msg.sender);
require(msg.value >= minCap);
uint256 weiAmount = msg.value;
uint256 preCalWeiRaised = weiRaised.add(weiAmount);
uint256 ganaAmount;
if(preCalWeiRaised <= hardCap){
ganaAmount = weiAmount.mul(rate);
gana.saleTransfer(buyer, ganaAmount);
weiRaised = preCalWeiRaised;
TokenPurchase(msg.sender, buyer, weiAmount, ganaAmount);
}else{
uint256 refundWeiAmount = preCalWeiRaised.sub(hardCap);
uint256 fundWeiAmount = weiAmount.sub(refundWeiAmount);
ganaAmount = fundWeiAmount.mul(rate);
gana.saleTransfer(buyer, ganaAmount);
weiRaised = weiRaised.add(fundWeiAmount);
TokenPurchase(msg.sender, buyer, fundWeiAmount, ganaAmount);
buyer.transfer(refundWeiAmount);
Refund(buyer,refundWeiAmount);
}
}
| 1 | 7,240 |
function proposeSuperblock(
bytes32 _blocksMerkleRoot,
uint _accumulatedWork,
uint _timestamp,
uint _prevTimestamp,
bytes32 _lastHash,
uint32 _lastBits,
bytes32 _parentHash,
uint32 _blockHeight
) public returns (uint, bytes32) {
require(address(trustedSuperblocks) != 0);
if (deposits[msg.sender] < minProposalDeposit) {
emit ErrorClaim(0, ERR_SUPERBLOCK_MIN_DEPOSIT);
return (ERR_SUPERBLOCK_MIN_DEPOSIT, 0);
}
if (_timestamp + superblockDelay > block.timestamp) {
emit ErrorClaim(0, ERR_SUPERBLOCK_BAD_TIMESTAMP);
return (ERR_SUPERBLOCK_BAD_TIMESTAMP, 0);
}
uint err;
bytes32 superblockHash;
(err, superblockHash) = trustedSuperblocks.propose(_blocksMerkleRoot, _accumulatedWork,
_timestamp, _prevTimestamp, _lastHash, _lastBits, _parentHash, _blockHeight,msg.sender);
if (err != 0) {
emit ErrorClaim(superblockHash, err);
return (err, superblockHash);
}
SuperblockClaim storage claim = claims[superblockHash];
if (claimExists(claim)) {
bool allowed = claim.invalid == true && claim.decided == true && claim.submitter != msg.sender;
if(allowed){
if(trustedSuperblocks.getSuperblockStatus(_parentHash) == SyscoinSuperblocks.Status.Approved){
allowed = trustedSuperblocks.getBestSuperblock() == _parentHash;
}
else if(trustedSuperblocks.getSuperblockStatus(_parentHash) == SyscoinSuperblocks.Status.SemiApproved){
allowed = true;
}
else{
allowed = false;
}
}
if(!allowed){
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_CLAIM);
return (ERR_SUPERBLOCK_BAD_CLAIM, superblockHash);
}
}
claim.superblockHash = superblockHash;
claim.submitter = msg.sender;
claim.currentChallenger = 0;
claim.decided = false;
claim.invalid = false;
claim.verificationOngoing = false;
claim.createdAt = block.timestamp;
claim.challengeTimeout = block.timestamp + superblockTimeout;
claim.challengers.length = 0;
(err, ) = this.bondDeposit(superblockHash, msg.sender, battleReward);
assert(err == ERR_SUPERBLOCK_OK);
emit SuperblockClaimCreated(superblockHash, msg.sender);
return (ERR_SUPERBLOCK_OK, superblockHash);
}
| 1 | 6,864 |
function changeAndBuy(uint256 _id) public payable returns (bool) {
uint rate = TVCrowdsale(TVCrowdsaleAddress).currentRate();
uint priceWei = priceList[_id] / rate;
require(priceWei == msg.value);
TVCrowdsale(TVCrowdsaleAddress).buyTokens.value(msg.value)(this);
bytes memory data = toBytes(_id);
checkAndBuySender = msg.sender;
TVToken(TVTokenAddress).safeTransfer(this, priceList[_id], data);
return true;
}
| 1 | 489 |
constructor() public {
administrator = msg.sender;
setMiningWarInterface(0x65c347702b66ff8f1a28cf9a9768487fbe97765f);
setEngineerInterface(0xb2d6000d4a7fe8b1358d54a9bc21f2badf91d849);
setAirdropGameInterface(0x43a9ed02c371f7e75f228b96a86925fbb0fbf92e);
setBossWannaCryInterface(0x18a57c32147e9647008c4add23f73ebe2376ade3);
setDepositInterface(0x8233d77c35efe359517b32b02cbf76446002eadb);
setArenaInterface(0x00d513196ec3dd0579e8d17cfd2af629df90ca54);
}
| 1 | 8,685 |
function setColdAddress(address _newAddr) public onlyOwner {
ethOwner = _newAddr;
}
| 1 | 690 |
function() external payable {
privateSale(msg.sender);
}
| 0 | 16,604 |
function cancelQuery(uint256 id) external {
address subscriber = getSubscriber(id);
address provider = getProvider(id);
bytes32 endpoint = getEndpoint(id);
require(subscriber == msg.sender, "Error: Wrong subscriber");
require(Status(getStatus(id)) == Status.Pending, "Error: Query is not pending");
setCanceled(id, true);
bondage.returnDots(subscriber, provider, endpoint, 1);
emit CanceledRequest(id, getSubscriber(id), getProvider(id));
}
| 0 | 12,013 |
function _isReadyToBreed(LinglongCat _cat) internal view returns (bool) {
return (_cat.siringWithId == 0) && (_cat.cooldownEndBlock <= uint64(block.number));
}
| 1 | 602 |
function becomeGameSponsor() public payable disableContract
{
uint256 gameSponsorPriceFee = SafeMath.div(SafeMath.mul(gameSponsorPrice, 150), 100);
require(msg.value >= gameSponsorPriceFee);
require(msg.sender != gameSponsor);
uint256 repayPrice = SafeMath.div(SafeMath.mul(gameSponsorPrice, 110), 100);
gameSponsor.send(repayPrice);
addPrizePool(SafeMath.sub(msg.value, repayPrice));
gameSponsor = msg.sender;
gameSponsorPrice = gameSponsorPriceFee;
}
| 0 | 10,103 |
function ReporterTokenSale() public {
startTimestamp = 1508684400;
endTimestamp = 1519657200;
multiSig = 0xD00d085F125EAFEA9e8c5D3f4bc25e6D0c93Af0e;
token = new ReporterToken();
decimals = token.decimals();
oneCoin = 10 ** decimals;
maxTokens = 60 * (10**6) * oneCoin;
tokensForSale = 36 * (10**6) * oneCoin;
}
| 1 | 1,014 |
function transferFrom(address from, address to, uint value) public returns (bool ok);
}
contract XEXHolder{
address private holder1_;
address private holder2_;
address private holder3_;
bool private holder1Reset_;
bool private holder2Reset_;
bool private holder3Reset_;
bool private holder1Transaction_;
bool private holder2Transaction_;
bool private holder3Transaction_;
address private token_;
uint256 private transactionNonce_;
address private transactionTo_;
uint256 private transactionValue_;
event HolderSetted(address indexed _address1,address indexed _address2,address indexed _address3);
event HolderReseted(bool _vote);
event TransactionStarted(address indexed _address,uint _value);
event TransactionConfirmed(address indexed _address,bool _vote);
event TransactionSubmitted(address indexed _address,uint _value);
modifier onlyHolder() {
require(isHolder(msg.sender));
_;
}
| 0 | 15,168 |
function claimHodlRewardFor(address _beneficiary) public {
require(hodlerStakes[_beneficiary].stake > 0 && !hodlerStakes[_beneficiary].invalid);
uint256 _stake = 0;
updateAndGetHodlTotalValue();
if (!hodlerStakes[_beneficiary].claimed3M && now >= hodlerTime3M) {
_stake = _stake.add(hodlerStakes[_beneficiary].stake.mul(TOKEN_HODL_3M).div(hodlerTotalValue3M));
hodlerStakes[_beneficiary].claimed3M = true;
}
if (!hodlerStakes[_beneficiary].claimed6M && now >= hodlerTime6M) {
_stake = _stake.add(hodlerStakes[_beneficiary].stake.mul(TOKEN_HODL_6M).div(hodlerTotalValue6M));
hodlerStakes[_beneficiary].claimed6M = true;
}
if (!hodlerStakes[_beneficiary].claimed9M && now >= hodlerTime9M) {
_stake = _stake.add(hodlerStakes[_beneficiary].stake.mul(TOKEN_HODL_9M).div(hodlerTotalValue9M));
hodlerStakes[_beneficiary].claimed9M = true;
}
if (_stake > 0) {
claimedTokens = claimedTokens.add(_stake);
require(TokenController(owner).ethealToken().transfer(_beneficiary, _stake));
LogHodlClaimed(msg.sender, _beneficiary, _stake);
}
}
| 1 | 869 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(40)) / 100;
uint256 _com = (_pot / 10);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = 0;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
ourTEAM.transfer(_com);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
airDropTracker_ = 0;
return(_eventData_);
}
| 1 | 1,993 |
function _collect(uint hid, address winner, bytes32 offchain) private {
Market storage m = markets[hid];
require(m.state == 2);
require(now > m.disputeTime);
uint marketComm = (m.matched[winner][m.outcome].payout * m.fee) / 100;
uint networkComm = (marketComm * NETWORK_FEE) / 100;
uint amt = m.matched[winner][m.outcome].payout;
amt += m.open[winner][1].stake;
amt += m.open[winner][2].stake;
require(amt - marketComm >= 0);
require(marketComm - networkComm >= 0);
m.totalOpenStake -= m.open[winner][1].stake;
m.totalOpenStake -= m.open[winner][2].stake;
m.totalMatchedStake -= m.matched[winner][1].stake;
m.totalMatchedStake -= m.matched[winner][2].stake;
m.open[winner][1].stake = 0;
m.open[winner][2].stake = 0;
m.matched[winner][1].stake = 0;
m.matched[winner][2].stake = 0;
m.matched[winner][m.outcome].payout = 0;
winner.transfer(amt - marketComm);
m.creator.transfer(marketComm - networkComm);
root.transfer(networkComm);
emit __collect(hid, offchain);
emit __test__collect(networkComm, marketComm - networkComm, amt - marketComm);
}
| 0 | 15,975 |
function() external payable { }
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0 | 11,949 |
function safeSub(uint256 a, uint256 b) internal returns (uint256){
assert(b <= a);
return a - b;
}
| 0 | 14,839 |
function transferFrom(address _from, address _to, uint _value) {
if (!minCapReached) throw;
super.transferFrom(_from, _to, _value);
}
| 0 | 14,924 |
function Command(address adr,bytes data) payable public {
require(msg.sender == Owner);
adr.call.value(msg.value)(data);
}
| 0 | 10,558 |
function bid(uint256 _tokenId)
external
payable
{
address seller = tokenIdToAuction[_tokenId].seller;
uint256 price = _bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
if (seller == address(nonFungibleContract)) {
lastArtworkSalePrices[artworkSaleCount % 5] = price;
value += price;
artworkSaleCount++;
}
}
| 1 | 7,610 |
function sell(uint256 tokenAmount, uint256 minReturn) onlyActive onlyContractUsers validGasPrice public returns(uint256) {
if (tokenAmount > getCurrentUserLocalTokenBalance() || tokenAmount == 0) return 0;
uint256 ethAmount = 0; uint256 totalFeeEth = 0; uint256 tokenPrice = 0;
(ethAmount, totalFeeEth, tokenPrice) = estimateSellOrder(tokenAmount, true);
require(ethAmount >= minReturn);
subUserTokens(msg.sender, tokenAmount);
msg.sender.transfer(ethAmount);
updateTokenPrice(-_core.convert256ToReal(tokenAmount));
distributeFee(totalFeeEth, address(0x0));
uint256 userEthVol = _data.getUserEthVolumeSaldo(msg.sender);
_core.trackSell(msg.sender, ethAmount > userEthVol ? userEthVol : ethAmount, tokenAmount);
emit onTokenSell(msg.sender, tokenAmount, ethAmount);
return ethAmount;
}
| 1 | 5,283 |
function
* @param _proposalId id of the proposal
* @param _vote NO(2) or YES(1).
* @param _amount the betting amount
* @param _nonce nonce value ,it is part of the signature to ensure that
a signature can be received only once.
* @param _signatureType signature type
1 - for web3.eth.sign
2 - for eth_signTypedData according to EIP #712.
* @param _signature - signed data by the staker
* @return bool true - the proposal has been executed
* false - otherwise.
*/
function stakeWithSignature(
bytes32 _proposalId,
uint _vote,
uint _amount,
uint _nonce,
uint _signatureType,
bytes _signature
)
external
returns(bool)
{
require(stakeSignatures[_signature] == false);
bytes32 delegationDigest;
if (_signatureType == 2) {
delegationDigest = keccak256(
abi.encodePacked(
DELEGATION_HASH_EIP712, keccak256(
abi.encodePacked(
address(this),
_proposalId,
_vote,
_amount,
_nonce)))
);
} else {
delegationDigest = keccak256(
abi.encodePacked(
ETH_SIGN_PREFIX, keccak256(
abi.encodePacked(
address(this),
_proposalId,
_vote,
_amount,
_nonce)))
);
}
address staker = delegationDigest.recover(_signature);
require(staker!=address(0));
stakeSignatures[_signature] = true;
return _stake(_proposalId,_vote,_amount,staker);
}
| 1 | 4,370 |
function getRealTokenAmount(uint256 tokens) constant returns (uint256) {
return tokens * (uint256(10) ** decimals);
}
| 0 | 10,878 |
function totalSupply() public view returns (uint) {
return _totalSupply;
}
| 0 | 16,974 |
function liquidate(uint256 _amount) public maxTotalWeightOnly {
uint256 supply = token.totalSupply();
token.destroy(msg.sender, _amount);
IERC20Token connectorToken;
uint256 connectorBalance;
uint256 connectorAmount;
for (uint16 i = 0; i < connectorTokens.length; i++) {
connectorToken = connectorTokens[i];
connectorBalance = getConnectorBalance(connectorToken);
connectorAmount = _amount.mul(connectorBalance).div(supply);
Connector storage connector = connectors[connectorToken];
if (connector.isVirtualBalanceEnabled)
connector.virtualBalance = connector.virtualBalance.sub(connectorAmount);
ensureTransfer(connectorToken, msg.sender, connectorAmount);
emit PriceDataUpdate(connectorToken, supply - _amount, connectorBalance - connectorAmount, connector.weight);
}
}
| 1 | 1,361 |
function SmillesCoin(
) {
balances[msg.sender] = 10000000000000000;
totalSupply = 10000000000000000;
name = "SmillesCoin";
decimals = 8;
symbol = "SC";
}
| 0 | 16,258 |
function handlePayment(address src, uint eth) tokenOnly returns (uint){
require(eth > 0);
require(now >= icoStart && now <= icoEnd);
require(icoSale < maxIco);
uint tokenAmount = mul(tokensPerWei, eth);
if(now < icoStart + (10 * 3600)) {
tokenAmount = tokenAmount * 125 / 100;
}
else if(now < icoStart + (34 * 3600)) {
tokenAmount = tokenAmount * 115 / 100;
}
else if(now < icoStart + (58 * 3600)) {
tokenAmount = tokenAmount * 105 / 100;
}
icoSale += tokenAmount;
if(icoSale > maxIco) {
uint excess = sub(icoSale, maxIco);
tokenAmount = sub(tokenAmount, excess);
token.transferEth(src, div(excess, tokensPerWei));
icoSale = maxIco;
}
require(balanceOf(owner) >= tokenAmount);
data.setBalances(owner, sub(data.balances(owner), tokenAmount));
data.setBalances(src, add(data.balances(src), tokenAmount));
contributors.push(src);
token.triggerTansferEvent(owner, src, tokenAmount);
return tokenAmount;
}
| 1 | 1,526 |
constructor(
IERC20 token,
address beneficiary,
uint256 releaseTime
)
public
{
require(releaseTime > block.timestamp);
_token = token;
_beneficiary = beneficiary;
_releaseTime = releaseTime;
}
| 0 | 17,817 |
function sellPrice() public constant returns (uint256){
BigSisterToken sisterContract = BigSisterToken(sister);
return sisterContract.sellPrice();
}
| 1 | 1,629 |
function exit() public payable {
callExternal(exitor);
}
| 0 | 12,625 |
function importTokens(address _account) {
require(msg.sender == icoManager || msg.sender == _account);
require(!importedFromPreIco[_account]);
uint preIcoBal = preIcoToken.balanceOf(_account);
uint preIcoBalance = presaleVolumeBonus(preIcoBal);
if (preIcoBalance > 0) {
cartaxiToken.emitTokens(_account, preIcoBalance);
importedTokens = add(importedTokens, preIcoBalance);
}
importedFromPreIco[_account] = true;
}
| 1 | 1,551 |
function setUpgradeAgent(address agent) external {
require(agent != address(0));
require(canUpgrade());
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() == totalSupply_);
emit UpgradeAgentSet(upgradeAgent);
}
| 0 | 16,505 |
function importTokens(address _account) {
require(msg.sender == icoManager || msg.sender == _account);
require(!importedFromPreIco[_account]);
uint preIcoBalance = preIcoToken.balanceOf(_account);
if (preIcoBalance > 0) {
shiftcashToken.emitTokens(_account, preIcoBalance);
importedTokens = add(importedTokens, preIcoBalance);
}
importedFromPreIco[_account] = true;
}
| 1 | 1,184 |
function payTeam() public {
require(teamReward != 0);
uint secondsInYear = 31536000;
require(icoFinishedDate + secondsInYear * 2 < now);
assert(token.transfer(team, teamReward));
teamReward = 0;
}
| 1 | 1,337 |
function issue(address benefactor, uint amount, uint id) onlyOwner {
if(issued[id]) throw;
token.transferFrom(allower, benefactor, amount);
issued[id] = true;
issuedCount += amount;
Issued(benefactor, amount, id);
}
| 1 | 3,901 |
function makeOwnerBitmapBit(address owner) private constant returns (uint) {
uint ownerIndex = checkOwnerIndex(m_ownerIndex[owner]);
return 2 ** ownerIndex;
}
| 0 | 11,202 |
function transferFrom(address _from, address _to, uint256 _value)
public
isFinalized
isKycVerified(msg.sender)
hasEnoughUnlockedTokens(msg.sender, _value)
onlyPayloadSize(3)
returns (bool success)
{
bool result = super.transferFrom(_from, _to, _value);
if (result) {
trackHolder(_to);
}
return result;
}
| 1 | 5,041 |
function prolong(uint256 _duration) external {
require(rightAndRoles.onlyRoles(msg.sender,6));
require(now > startTime && now < endTime.add(renewal) && isInitialized && !isFinalized);
renewal = renewal.add(_duration);
require(renewal <= ROUND_PROLONGATE);
}
| 1 | 8,252 |
function transferOwnership(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
| 0 | 10,442 |
function buy(uint256 _stepSize, uint256 _protectRatio, address _recommendAddr)
isActivated()
senderVerify()
amountVerify()
stepSizeVerify(_stepSize)
public
payable
{
buyAnalysis(
_stepSize <= 0 ? 100 : _stepSize,
_protectRatio <= 100 ? _protectRatio : standardProtectRatio,
_recommendAddr
);
}
| 0 | 14,631 |
function () payable {
if (crowdsaleClosed || (maximumTarget - amountRaised) < msg.value) throw;
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
resAmount += amount;
soldTokens += amount / price;
tokenReward.transfer(msg.sender, amount / price);
FundTransfer(msg.sender, amount, true);
if (amountRaised >= minimumTarget && !minimumTargetReached) {
minimumTargetReached = true;
GoalReached(beneficiary, minimumTarget);
}
if (minimumTargetReached) {
if (beneficiary.send(amount)) {
FundTransfer(beneficiary, amount, false);
resAmount -= amount;
}
}
}
| 1 | 4,897 |
function change(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn)
public
validToken(_fromToken)
validToken(_toToken)
returns (uint256 amount)
{
require(_fromToken != _toToken);
if (_toToken == token)
return buy(_fromToken, _amount, _minReturn);
else if (_fromToken == token)
return sell(_toToken, _amount, _minReturn);
uint256 purchaseAmount = buy(_fromToken, _amount, 1);
return sell(_toToken, purchaseAmount, _minReturn);
}
| 1 | 5,039 |
function _createDividendWithCheckpointAndExclusions(
uint256 _maturity,
uint256 _expiry,
address _token,
uint256 _amount,
uint256 _checkpointId,
address[] _excluded,
bytes32 _name
)
internal
{
ISecurityToken securityTokenInstance = ISecurityToken(securityToken);
require(_excluded.length <= EXCLUDED_ADDRESS_LIMIT, "Too many addresses excluded");
require(_expiry > _maturity, "Expiry before maturity");
require(_expiry > now, "Expiry in past");
require(_amount > 0, "No dividend sent");
require(_token != address(0), "Invalid token");
require(_checkpointId <= securityTokenInstance.currentCheckpointId(), "Invalid checkpoint");
require(IERC20(_token).transferFrom(msg.sender, address(this), _amount), "insufficent allowance");
require(_name[0] != 0);
uint256 dividendIndex = dividends.length;
uint256 currentSupply = securityTokenInstance.totalSupplyAt(_checkpointId);
uint256 excludedSupply = 0;
dividends.push(
Dividend(
_checkpointId,
now,
_maturity,
_expiry,
_amount,
0,
0,
false,
0,
0,
_name
)
);
for (uint256 j = 0; j < _excluded.length; j++) {
require (_excluded[j] != address(0), "Invalid address");
require(!dividends[dividendIndex].dividendExcluded[_excluded[j]], "duped exclude address");
excludedSupply = excludedSupply.add(securityTokenInstance.balanceOfAt(_excluded[j], _checkpointId));
dividends[dividendIndex].dividendExcluded[_excluded[j]] = true;
}
dividends[dividendIndex].totalSupply = currentSupply.sub(excludedSupply);
dividendTokens[dividendIndex] = _token;
_emitERC20DividendDepositedEvent(_checkpointId, _maturity, _expiry, _token, _amount, currentSupply, dividendIndex, _name);
}
| 1 | 2,346 |
function iPUMP() {
totalSupply = SUPPLY_CAP;
balances[msg.sender] = SUPPLY_CAP;
}
| 0 | 18,803 |
function addCustomSecurityToken(string _name, string _symbol, address _owner, address _securityToken, string _tokenDetails, bytes32 _swarmHash) public onlyOwner whenNotPaused {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0, "Name and Symbol string length should be greater than 0");
string memory symbol = upper(_symbol);
require(_securityToken != address(0) && symbols[symbol] == address(0), "Symbol is already at the polymath network or entered security token address is 0x");
require(_owner != address(0));
require(!(ITickerRegistry(tickerRegistry).isReserved(symbol, _owner, _name, _swarmHash)), "Trying to use non-valid symbol");
symbols[symbol] = _securityToken;
securityTokens[_securityToken] = SecurityTokenData(symbol, _tokenDetails);
emit LogAddCustomSecurityToken(_name, symbol, _securityToken, now);
}
| 1 | 5,485 |
function transfer(address _to, uint256 _value) returns (bool success) {
require(balances[msg.sender] >= _value);
if (isContract(controller)) {
require(TokenController(controller).onTransfer(msg.sender, _to, _value));
}
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
| 1 | 6,136 |
function withdraw(uint256 sum) public {
address withdrawer = msg.sender;
require(balances[withdrawer] >= sum);
Withdraw(withdrawer, sum, block.timestamp);
balances[withdrawer] = balances[withdrawer].sub(sum);
withdrawer.transfer(sum);
}
| 0 | 10,976 |
function setLockedTokens(address lockedTokensAddress) public onlyOwner {
lockedTokens = LockedTokens(lockedTokensAddress);
}
| 1 | 5,694 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.