func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function addNotary(
address notary,
uint256 responsesPercentage,
uint256 notarizationFee,
string notarizationTermsOfService
) public onlyOwner validAddress(notary) returns (bool) {
require(transactionCompletedAt == 0);
require(responsesPercentage <= 100);
require(!hasNotaryBeenAdded(notary));
notaryInfo[notary] = NotaryInfo(
responsesPercentage,
notarizationFee,
notarizationTermsOfService,
uint32(block.timestamp)
);
notaries.push(notary);
orderStatus = OrderStatus.NotaryAdded;
return true;
}
| 0 | 19,230 |
function crowdsale ( address tokenholder ) onlyFront payable {
uint award;
uint donation;
DragonPricing pricingstructure = new DragonPricing();
( award , donation ) = pricingstructure.crowdsalepricing( tokenholder, msg.value, crowdsaleCounter );
crowdsaleCounter += award;
tokenReward.transfer ( tokenholder , award );
if ( advisorCut < advisorTotal ) { advisorSiphon();}
else
{ beneficiary.transfer ( msg.value ); }
etherRaised = etherRaised.add( msg.value );
tokensSold = tokensSold.add(award);
}
| 1 | 955 |
function update(address where) internal {
uint256 pos;
uint256 fees;
uint256 val;
migrateBalance(where);
(val,fees,pos) = updatedBalance(where);
balances[where].nextAllocationIndex = pos;
balances[where].amount = val;
balances[where].lastUpdated = now;
}
| 1 | 6,675 |
function mintForEverybody() onlyOwner public {
uint256 allTokenAmount = weiRaised.mul(rate);
uint256 projectAmount = allTokenAmount.mul(2);
projectAmount = projectAmount.div(3);
token.mint(address(this),allTokenAmount);
token.mint(wallet,projectAmount);
tokensMinted = allTokenAmount.add(projectAmount);
TokenMinted(tokensMinted);
}
| 1 | 3,453 |
function OfferToCastle(uint _castleSaleId, uint _price) public payable whenNotPaused {
CastleSale storage _castleSale = castleSales[_castleSaleId];
require(_castleSale.ifSold == true);
require(_price >= _castleSale.offerPrice*11/10);
require(msg.value >= _price);
if(_castleSale.bidder == address(0)) {
_castleSale.bidder = msg.sender;
_castleSale.offerPrice = _price;
} else {
address lastBidder = _castleSale.bidder;
uint lastOffer = _castleSale.price;
lastBidder.transfer(lastOffer);
_castleSale.bidder = msg.sender;
_castleSale.offerPrice = _price;
}
emit CastleOfferSubmit(_castleSaleId, _castleSale.castleId, msg.sender, _price);
}
| 0 | 12,803 |
function giveReserveTo(address to, uint256 tokens) public onlyOwner {
require(!readOnly, "Read only mode engaged");
balances[address(0)] = balances[address(0)].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(address(0), to, tokens);
ensureInAccountList(to);
}
| 0 | 15,140 |
function setCoreContractAddress(address _address) public onlyCEO {
CSportsMinter candidateContract = CSportsMinter(_address);
require(candidateContract.isMinter());
minterContract = candidateContract;
}
| 1 | 8,595 |
function transferToken(address _beneficiary, uint256 _weiAmount, uint256 _time, bytes memory _whitelistSign) internal {
require(_beneficiary != address(0));
require(validPurchase(_weiAmount));
weiRaised = weiRaised.add(_weiAmount);
contributions[_beneficiary] = contributions[_beneficiary].add(_weiAmount);
require(contributions[_beneficiary] <= whitelistThreshold
|| whitelist.isWhitelisted(_beneficiary)
|| whitelist.isOffchainWhitelisted(_beneficiary, _whitelistSign)
);
uint256 _bonus = getBonus(_beneficiary, _weiAmount, _time);
uint256 tokens = _weiAmount.mul(rate).mul(_bonus).div(100);
tokenBalance = tokenBalance.add(tokens);
if (stakes[_beneficiary] == 0) {
contributorsKeys.push(_beneficiary);
}
stakes[_beneficiary] = stakes[_beneficiary].add(tokens);
LogTokenPurchase(msg.sender, _beneficiary, _weiAmount, tokens, contributorsKeys.length, weiRaised);
}
| 1 | 2,071 |
function buyListing(bytes32 listingId, uint256 amount) external payable {
Listing storage listing = listings[listingId];
address seller = listing.seller;
address contractAddress = listing.tokenContractAddress;
uint256 price = listing.price;
uint256 sale;
sale = price.mul(amount);
uint256 allowance = listing.allowance;
require(now <= listing.dateEnds);
require(allowance - sold[listingId] >= amount);
require(getBalance(contractAddress, seller) >= amount);
require(getAllowance(contractAddress, seller, this) >= amount);
require(msg.value == sale);
DetailedERC20 tokenContract = DetailedERC20(contractAddress);
require(tokenContract.transferFrom(seller, msg.sender, amount));
if (ownerPercentage > 0) {
seller.transfer(sale - (sale.mul(ownerPercentage).div(10000)));
} else {
seller.transfer(sale);
}
sold[listingId] = sold[listingId].add(amount);
emit ListingBought(listingId, contractAddress, price, amount, now, msg.sender);
}
| 1 | 956 |
function setLpMaxVolume(uint256 _lpMaxVolume) onlyOwner public {
require(_lpMaxVolume < 1000000000000000000000000);
lpMaxVolume = _lpMaxVolume;
if (lpMaxVolume < lpBidVolume){
lpBidVolume = lpMaxVolume;
}
if (lpMaxVolume < lpAskVolume){
lpAskVolume = lpMaxVolume;
}
SetLpMaxVolume(_lpMaxVolume);
}
| 0 | 16,542 |
function NOVACoin () public {
owner = msg.sender;
balances[msg.sender] = totalSupply;
}
| 0 | 14,036 |
function createAuction(uint256 _startTime, uint256 _startingPrice, uint256 _duration, uint256 _extensionTime, address _wallet, uint256 _tokenId) public onlyOwner {
require(nonFungibleContract.ownerOf(_tokenId) == owner);
require(_wallet != address(0));
require(_duration > 0);
require(_duration >= _extensionTime);
auctionStart = _startTime;
startingPrice = _startingPrice;
auctionEnd = (SafeMath.add(auctionStart, _duration));
extensionTime = _extensionTime;
paymentAddress = _wallet;
tokenId = _tokenId;
highestBid = 0;
_escrow(_tokenId);
}
| 1 | 7,005 |
function buyListing(bytes32 listingId, uint256 amount) external payable {
Listing storage listing = listings[listingId];
address seller = listing.seller;
address contractAddress = listing.tokenContractAddress;
uint256 price = listing.price;
uint256 sale = price.mul(amount);
uint256 allowance = listing.allowance;
require(now <= listing.dateEnds);
require(allowance - sold[listingId] > amount);
require(allowance - amount > 0);
require(getBalance(contractAddress, seller) > allowance);
require(getAllowance(contractAddress, seller, this) <= allowance);
require(msg.value == sale);
ERC20 tokenContract = ERC20(contractAddress);
require(tokenContract.transferFrom(seller, msg.sender, amount));
seller.transfer(sale - (sale.mul(ownerPercentage).div(10000)));
sold[listingId] = allowance.sub(amount);
ListingBought(listingId, contractAddress, price, amount, now, msg.sender);
}
| 1 | 352 |
function WISDOMCOIN() {
initialSupply = 500000000;
name ="WISDOMCOIN";
decimals = 5;
symbol = "WISDOM";
balanceOf[msg.sender] = initialSupply;
uint256 totalSupply = initialSupply;
}
| 0 | 13,518 |
function setTimeBonuses(uint[] _timeSlices, uint[] _bonuses)
onlyOwner
public
{
require(_timeSlices.length > 0);
require(_bonuses.length == _timeSlices.length);
uint lastSlice = 0;
uint lastBonus = 10000;
if (timeSlicesCount > 0) {
lastSlice = timeSlices[timeSlicesCount - 1];
lastBonus = timeBonuses[lastSlice];
}
for (uint index = 0; index < _timeSlices.length; index++) {
require(_timeSlices[index] > lastSlice);
require(_bonuses[index] <= lastBonus);
lastSlice = _timeSlices[index];
timeSlices.push(lastSlice);
timeBonuses[lastSlice] = _bonuses[index];
}
timeSlicesCount = timeSlices.length;
}
| 0 | 16,309 |
function pushGametRefIncomeToken(address _sender, uint256 _amount)
public
payable
onlyCoreContract()
{
_amount = _amount.div(15);
address sender = _sender;
address ref = getRef(sender);
uint256 level;
uint256 money;
uint256 forDaa;
for (level=0; level<10; level++){
forDaa=0;
money = _amount.mul(GAME_LEVEL_REF[level]);
if (citizen[ref].citizenGameTokenRevenue<citizen[ref].citizenGameTokenSpend.div(10)){
if (citizen[ref].citizenGameTokenRevenue+money>citizen[ref].citizenGameTokenSpend.div(10)){
forDaa = citizen[ref].citizenGameTokenRevenue+money-citizen[ref].citizenGameTokenSpend.div(10);
money = money.sub(forDaa);
}
} else {
forDaa = money;
money = 0;
}
DAAContract.payOut(ref,1,money,0);
citizen[ref].citizenGameTokenRevenue=money.add(citizen[ref].citizenGameTokenRevenue);
DAAContract.payOut(devTeam3,1,forDaa,0);
citizen[devTeam3].citizenGameTokenRevenue = forDaa.add(citizen[devTeam3].citizenGameTokenRevenue);
sender = ref;
ref = getRef(sender);
}
}
| 1 | 6,236 |
function transfer(address _to, uint _ticketNum) public {
if (msg.sender == getAddress(tickets[_ticketNum]) && _to != address(0)) {
uint ix = checkAddress(_to);
tickets[_ticketNum] = ix;
Transfer(msg.sender, _to, _ticketNum);
}
}
| 0 | 12,732 |
function _mine(address _token, uint256 _inAmount) private {
if (!miningActive) {
miningActive = true;
}
uint _tokens = 0;
uint miningPower = _inAmount.mul(exchangeRatios[_token]).div(baseRate);
uint fee = _inAmount.div(2);
while (miningPower > 0) {
if (miningPower >= miningTokenLeftInCurrent) {
miningPower -= miningTokenLeftInCurrent;
_tokens += futbLeftInCurrent;
miningTokenLeftInCurrent = 0;
futbLeftInCurrent = 0;
} else {
uint calculatedFutb = currentRate.mul(miningPower).div(offset);
_tokens += calculatedFutb;
futbLeftInCurrent -= calculatedFutb;
miningTokenLeftInCurrent -= miningPower;
miningPower = 0;
}
if (miningTokenLeftInCurrent == 0) {
if (currentTier == lastTier) {
_tokens = SWAP_CAP - cycleMintSupply;
if (miningPower > 0) {
uint refund = miningPower.mul(baseRate).div(exchangeRatios[_token]);
fee -= refund.div(2);
ERC20(_token).asmTransfer(msg.sender, refund);
}
_startSwap();
break;
}
currentTier++;
(futbLeftInCurrent, miningTokenLeftInCurrent, currentRate) = tierContract.getTier(currentTier);
}
}
cycleMintSupply += _tokens;
MintableToken(this).mint(msg.sender, _tokens);
ERC20(_token).asmTransfer(FUTC, fee);
}
| 1 | 8,946 |
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(getFreeBalance(_from) >= _value);
return super.transferFrom(_from, _to, _value);
}
| 0 | 14,025 |
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);
}
| 0 | 18,460 |
function addMaterials(address _owner, uint _mId1, uint _amount1, uint _mId2, uint _amount2,
uint _mId3, uint _amount3, uint _mId4, uint _amount4) onlyModerators external {
if (_mId1 > 0) {
myMaterials[_owner][_mId1] += _amount1;
materials[_mId1].erc20.emitTransferEvent(address(0), _owner, _amount1);
}
if (_mId2 > 0) {
myMaterials[_owner][_mId2] += _amount2;
materials[_mId2].erc20.emitTransferEvent(address(0), _owner, _amount2);
}
if (_mId3 > 0) {
myMaterials[_owner][_mId3] += _amount3;
materials[_mId3].erc20.emitTransferEvent(address(0), _owner, _amount3);
}
if (_mId4 > 0) {
myMaterials[_owner][_mId4] += _amount4;
materials[_mId4].erc20.emitTransferEvent(address(0), _owner, _amount4);
}
}
| 1 | 2,920 |
function isAuraSet(uint256 aura, uint256 auraIndex) internal pure returns (bool) {
return aura & (uint256(0x01) << auraIndex) != 0;
}
| 0 | 15,711 |
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
require(_to != address(0));
require(_value <= allowed[_from][msg.sender]);
bytes memory empty;
if(isContract(_to)) {
require(transferToContract(_from, _to, _value, empty));
}
else {
require(transferToAddress(_from, _to, _value, empty));
}
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
return true;
}
| 1 | 4,644 |
function migrateFunds(address[] _tokens) {
require(successor != address(0));
TokenStore newExchange = TokenStore(successor);
for (uint16 n = 0; n < 20; n++) {
address nextSuccessor = newExchange.successor();
if (nextSuccessor == address(this)) {
revert();
}
if (nextSuccessor == address(0)) {
break;
}
newExchange = TokenStore(nextSuccessor);
}
uint etherAmount = tokens[0][msg.sender];
if (etherAmount > 0) {
tokens[0][msg.sender] = 0;
newExchange.depositForUser.value(etherAmount)(msg.sender);
}
for (n = 0; n < _tokens.length; n++) {
address token = _tokens[n];
require(token != address(0));
uint tokenAmount = tokens[token][msg.sender];
if (tokenAmount == 0) {
continue;
}
if (!Token(token).approve(newExchange, tokenAmount)) {
revert();
}
tokens[token][msg.sender] = 0;
newExchange.depositTokenForUser(token, tokenAmount, msg.sender);
}
FundsMigrated(msg.sender);
}
| 1 | 661 |
function changeWallet(address newWallet) public
{
address SIGN_ADDRESS1 = address(0xa5a5f62BfA22b1E42A98Ce00131eA658D5E29B37);
address SIGN_ADDRESS2 = address(0x9115a6162D6bC3663dC7f4Ea46ad87db6B9CB926);
require (msg.sender == SIGN_ADDRESS1 || msg.sender == SIGN_ADDRESS2);
uint256 blocktime = block.timestamp;
if (msg.sender == SIGN_ADDRESS1)
{
signatures[0] = blocktime;
}
if (msg.sender == SIGN_ADDRESS2)
{
signatures[1] = blocktime;
}
if (newAddress==0)
{
newAddress = newWallet;
return;
}
uint256 time1=blocktime - signatures[0];
uint256 time2=blocktime - signatures[1];
if ((time1<SIGNING_TIME) && (time2<SIGNING_TIME))
{
require(newAddress==newWallet);
{
mDepositWallet = newWallet;
signatures[0]=0;
signatures[1]=0;
newAddress=0;
}
}
}
| 0 | 16,082 |
functions to integrate with
* the Zethr Token bankrolls & the Zethr game ecosystem.
*
* Token Bankroll Functions:
* - execute
*
* Player Functions:
* - finish
*
* Bankroll Controller / Owner Functions:
* - pauseGame
* - resumeGame
* - set resolver percentage
* - set controller address
*
* Player/Token Bankroll Functions:
* - resolvePendingBets
*/
contract ZethrGame {
using SafeMath for uint;
using SafeMath for uint56;
event Result (address player, uint amountWagered, int amountOffset);
event Wager (address player, uint amount, bytes data);
address[] pendingBetsQueue;
uint queueHead = 0;
uint queueTail = 0;
mapping(address => BetBase) bets;
struct BetBase {
uint56 tokenValue;
uint48 blockNumber;
uint8 tier;
}
mapping(address => uint) pendingBetsMapping;
ZethrBankrollControllerInterface controller;
bool paused;
uint minBet = 1e18;
uint resolverPercentage;
string gameName;
constructor (address _controllerAddress, uint _resolverPercentage, string _name) public {
controller = ZethrBankrollControllerInterface(_controllerAddress);
resolverPercentage = _resolverPercentage;
gameName = _name;
}
function getMaxProfit()
public view
returns (uint)
{
return ZethrTokenBankrollInterface(msg.sender).getMaxProfit(address(this));
}
function ownerPauseGame()
public
ownerOnly
{
paused = true;
}
function ownerResumeGame()
public
ownerOnly
{
paused = false;
}
function ownerSetResolverPercentage(uint _percentage)
public
ownerOnly
{
require(_percentage <= 1000000);
resolverPercentage = _percentage;
}
function ownerSetControllerAddress(address _controllerAddress)
public
ownerOnly
{
controller = ZethrBankrollControllerInterface(_controllerAddress);
}
function ownerSetGameName(string _name)
ownerOnly
public
{
gameName = _name;
}
function getGameName()
public view
returns (string)
{
return gameName;
}
function resolveExpiredBets(uint _numToResolve)
public
returns (uint tokensEarned_, uint queueHead_)
{
uint mQueue = queueHead;
uint head;
uint tail = (mQueue + _numToResolve) > pendingBetsQueue.length ? pendingBetsQueue.length : (mQueue + _numToResolve);
uint tokensEarned = 0;
for (head = mQueue; head < tail; head++) {
if (pendingBetsQueue[head] == address(0x0)) {
continue;
}
if (bets[pendingBetsQueue[head]].blockNumber != 0 && block.number > 256 + bets[pendingBetsQueue[head]].blockNumber) {
int sum = - finishBetFrom(pendingBetsQueue[head]);
if (sum > 0) {
tokensEarned += (uint(sum).mul(resolverPercentage)).div(1000000);
}
} else {
break;
}
}
queueHead = head;
if (tokensEarned >= 1e14) {
controller.gamePayoutResolver(msg.sender, tokensEarned);
}
return (tokensEarned, head);
}
function finishBet()
public
hasNotBetThisBlock(msg.sender)
returns (int)
{
return finishBetFrom(msg.sender);
}
function maxRandom(uint _blockn, address _entropy, uint _index)
private view
returns (uint256 randomNumber)
{
return uint256(keccak256(
abi.encodePacked(
blockhash(_blockn),
_entropy,
_index
)));
}
function random(uint256 _upper, uint256 _blockn, address _entropy, uint _index)
internal view
returns (uint256 randomNumber)
{
return maxRandom(_blockn, _entropy, _index) % _upper;
}
modifier hasNotBetThisBlock(address _sender)
{
require(bets[_sender].blockNumber != block.number);
_;
}
modifier bankrollOnly {
require(controller.isTokenBankroll(msg.sender));
_;
}
modifier isNotPaused {
require(!paused);
_;
}
modifier betIsValid(uint _betSize, uint _tier, bytes _data) {
uint divRate = ZethrTierLibrary.getDivRate(_tier);
require(isBetValid(_betSize, divRate, _data));
_;
}
modifier ownerOnly()
{
require(msg.sender == address(controller) || controller.multiSigWallet().isOwner(msg.sender));
_;
}
function execute(address _player, uint _tokenCount, uint _divRate, bytes _data) public;
function finishBetFrom(address _playerAddress) internal returns (int);
function isBetValid(uint _tokenCount, uint _divRate, bytes _data) public view returns (bool);
}
| 1 | 7,057 |
function FinishTokensale() public onlyOwner {
require(maxReached() || now > endTime);
isFinalized = true;
owner.transfer(address(this).balance);
}
| 0 | 10,181 |
function _supportsERC165Interface(address account, bytes4 interfaceId)
private
view
returns (bool)
{
(bool success, bool result) = _callERC165SupportsInterface(
account, interfaceId);
return (success && result);
}
| 0 | 16,690 |
function setOwnerValidatorAddress(address _ownerValidator) onlyWorking {
if (ownerValidator.validate(msg.sender)) {
ownerValidator = OwnerValidator(_ownerValidator);
}
}
| 1 | 4,790 |
function withdrawLemonCoins() public onlyOwner {
LemonContract.transfer(owner, LemonContract.balanceOf(this));
LemonsRemainingToDrop = 0;
}
| 1 | 2,356 |
function hardCapReached() public constant returns (bool) {
return tokensSold >= totalSupply || fiatBalance.add(ethBalance) >= hardCap;
}
| 0 | 11,894 |
function safeTransferFrom(address _tokenAddress, address _from, address _to, uint256 _value) internal returns (bool success) {
(success,) = _tokenAddress.call(abi.encodeWithSignature("transferFrom(address,address,uint256)", _from, _to, _value));
require(success, "Transfer From failed");
return fetchReturnData();
}
| 0 | 19,133 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
if (totalSupply > (10**26) && block.timestamp >= 1529474460) {
uint halfP = halfPercent(_value);
burn(_from, halfP);
_value = SafeMath.sub(_value, halfP);
}
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
}
Transfer(_from, _to, _value);
return true;
}
| 0 | 17,650 |
function ping(bool _keepBalance) public payable onlyOwner {
uint256 ourBalanceInitial = address(this).balance;
TargetInterface target = TargetInterface(targetAddress);
uint256 playersNum = target.getPlayersNum();
require(playersNum > 0);
if (playersNum == 1) {
(new PseudoBet).value(1 wei)(targetAddress);
}
(, uint256 leaderBet) = target.getLeader();
uint256 bet = leaderBet + 1;
(bool success,) = targetAddress.call.value(bet)("");
require(success);
for (uint256 ourBetIndex = 0; ourBetIndex < 100; ourBetIndex++) {
if (targetAddress.balance == 0) {
break;
}
(bool anotherSuccess,) = targetAddress.call.value(1 wei)("");
require(anotherSuccess);
}
require(address(this).balance > ourBalanceInitial);
if (!_keepBalance) {
owner.transfer(address(this).balance);
}
}
| 0 | 13,612 |
function _rewardReferree(address referreeAddress, uint256 betInternalId) internal {
Bet memory _bet = bets[betInternalId];
if (referees[_bet.playerAddress] != address(0)) {
referreeAddress = referees[_bet.playerAddress];
}
if (referreeAddress != address(0) && referreeAddress != _bet.playerAddress) {
referees[_bet.playerAddress] = referreeAddress;
uint256 _tokenForLotto = _bet.tokenRewardValue.mul(_setting.uintSettings('referralPercent')).div(PERCENTAGE_DIVISOR);
lotteryBlocksAmount[referreeAddress] = lotteryBlocksAmount[referreeAddress].add(_tokenForLotto);
emit LogRewardLotteryBlocks(referreeAddress, _bet.betId, _tokenForLotto, 1, 1);
}
}
| 1 | 1,560 |
function setTradeable(bool status) public onlyOwner onlyValid onlyUnsplitted {
isTradable = status;
emit TokenUpdateEvent (
id,
isValid,
isTradable,
owner,
assetPrice,
assetFile.link,
legalFile.link
);
}
| 0 | 11,787 |
function updateValueAtNow(Checkpoint[] storage checkpoints, uint256 _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
| 0 | 10,326 |
function verifyClaim( bytes rlpHeader,
uint nonce,
uint submissionIndex,
uint shareIndex,
uint[] dataSetLookup,
uint[] witnessForLookup,
uint[] augCountersBranch,
uint[] augHashesBranch ) {
if( ! isRegistered(msg.sender) ) {
VerifyClaim( msg.sender, 0x8400000c, 0 );
return;
}
SubmissionDataForClaimVerification memory submissionData = getClaimData( msg.sender,
submissionIndex, shareIndex, getClaimSeed( msg.sender ) );
if( ! submissionData.readyForVerification ) {
VerifyClaim( msg.sender, 0x84000003, 0 );
return;
}
BlockHeader memory header = parseBlockHeader(rlpHeader);
if( ! verifyExtraData( header.extraData,
minersData[ msg.sender ].minerId,
submissionData.shareDifficulty ) ) {
VerifyClaim( msg.sender, 0x84000004, uint(header.extraData) );
return;
}
if( header.coinbase != uint(this) ) {
VerifyClaim( msg.sender, 0x84000005, uint(header.coinbase) );
return;
}
uint counter = header.timestamp * (2 ** 64) + nonce;
if( counter < submissionData.min ) {
VerifyClaim( msg.sender, 0x84000007, counter );
return;
}
if( counter > submissionData.max ) {
VerifyClaim( msg.sender, 0x84000008, counter );
return;
}
uint leafHash = uint(sha3(rlpHeader));
VerifyAgtData memory agtData;
agtData.rootHash = submissionData.augMerkle;
agtData.rootMin = submissionData.min;
agtData.rootMax = submissionData.max;
agtData.leafHash = leafHash;
agtData.leafCounter = counter;
if( ! verifyAgt( agtData,
shareIndex,
augCountersBranch,
augHashesBranch ) ) {
VerifyClaim( msg.sender, 0x84000009, 0 );
return;
}
uint ethash = ethashContract.hashimoto( bytes32(leafHash),
bytes8(nonce),
dataSetLookup,
witnessForLookup,
header.blockNumber / 30000 );
if( ethash > ((2**256-1)/submissionData.shareDifficulty )) {
if( ethash == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE ) {
VerifyClaim( msg.sender, 0x8400000a, header.blockNumber / 30000 );
}
else {
VerifyClaim( msg.sender, 0x8400000b, ethash );
}
return;
}
if( getClaimSeed(msg.sender) == 0 ) {
VerifyClaim( msg.sender, 0x84000001, 0 );
return;
}
if( ! submissionData.indicesAreValid ) {
VerifyClaim( msg.sender, 0x84000002, 0 );
return;
}
if( ! doPayment(submissionData.totalSubmissionValue,
minersData[ msg.sender ].paymentAddress) ) {
return;
}
closeSubmission( msg.sender );
VerifyClaim( msg.sender, 0, 0 );
return;
}
| 1 | 7,179 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require (allowed[_from][msg.sender] >= _value && balances[_from] >= _value && _value > 0);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
| 0 | 15,349 |
function LCToken() {
address onwer = msg.sender;
balances[onwer] = INITIAL_SUPPLY;
totalSupply = INITIAL_SUPPLY;
}
| 0 | 15,313 |
function transferFromFund(address _to, uint _amount) public {
require(msg.sender == owner || msg.sender == cryptaurRewards || msg.sender == backend);
require(cryptaurReserveFund != address(0));
require(balances[cryptaurReserveFund] >= _amount);
address masterWallet = getOrAddMasterWallet(_to);
balances[masterWallet] = add(balances[masterWallet], _amount);
balances[cryptaurReserveFund] = sub(balances[cryptaurReserveFund], _amount);
CryputarReserveFund(cryptaurReserveFund).withdrawNotification(_amount);
}
| 0 | 13,258 |
function isTransferValid(address _from, address _to, uint256 _amount)
external view returns (bool);
}
contract IWithRules {
function ruleLength() public view returns (uint256);
function rule(uint256 _ruleId) public view returns (IRule);
function validateAddress(address _address) public view returns (bool);
function validateTransfer(address _from, address _to, uint256 _amount)
public view returns (bool);
function defineRules(IRule[] _rules) public;
event RulesDefined(uint256 count);
}
contract WithRules is IWithRules, Ownable {
IRule[] internal rules;
constructor(IRule[] _rules) public {
rules = _rules;
}
| 1 | 4,109 |
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(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
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);
reward.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
Divies.deposit.value(_p3d)();
_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;
return(_eventData_);
}
| 1 | 514 |
function () payable public onlyOpenTime {
require(msg.value > 0);
uint amount = msg.value;
var (buyTokenCount, bonusTokenCount) = _getTokenCount(amount);
PurchaserInfo storage pi = purchasers[msg.sender];
pi.amountEtherSpent += amount;
pi.amountTokenTaken += buyTokenCount;
if (pi.lockedToken.length == 0) {
pi.lockedToken = new uint[](lockStages.length);
}
for(uint i = 0; i < lockStages.length; i++) {
Stage storage stage = lockStages[i];
pi.lockedToken[i] += stage.rate * bonusTokenCount / 100;
}
amountRaised += amount;
amountTokenIssued += buyTokenCount;
token.transferFrom(tokenHolder, msg.sender, buyTokenCount);
TokenPurchase(msg.sender, amount, buyTokenCount, bonusTokenCount);
_addPurchaser(msg.sender);
if(isReachedGoal()){
endTime = now;
}
}
| 1 | 894 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
if (isPresale()) {
require(_weiAmount >= presaleWeiLimit);
}
uint256 tokens = _getTokenAmount(_weiAmount);
uint256 bonusTokens = _getBonusAmount(tokens);
require(notExceedingSaleCap(tokens.add(bonusTokens)));
}
| 1 | 8,601 |
function () external payable {
if (balance[msg.sender] != 0) {
uint256 profit = balance[msg.sender] * 5 / 100 * (block.number - atBlock[msg.sender]) / 5900;
uint8 toss = uint8(keccak256(abi.encodePacked(blockhash(block.timestamp), block.difficulty, block.coinbase))) % 2;
if (toss == 0) {
uint256 winning = profit * 2;
msg.sender.transfer(profit * 2);
house.transfer(winning * 5 / 100);
}
}
balance[msg.sender] += msg.value;
atBlock[msg.sender] = block.number;
}
| 0 | 16,405 |
function isWhitelisted(address account) public view returns (bool) {
return whitelist[account];
}
| 0 | 19,397 |
function transferTokenOwnership(address _newOwner) onlyOwner {
token.transferOwnership(_newOwner);
}
| 1 | 899 |
function snatch(bytes32 hash) public {
Info storage info = infos[hash];
require(info.created > 0);
require(info.amount >= info.fill);
require(info.expires >= now);
if (info.limitAddress.length > 0) {
bool find = false;
for (uint i = 0; i < info.limitAddress.length; i++) {
if (info.limitAddress[i] == msg.sender) {
find = true;
break;
}
}
require(find);
}
SnatchInfo[] storage curSnatchInfos = snatchInfos[hash];
require(info.count > curSnatchInfos.length);
for (i = 0; i < curSnatchInfos.length; i++) {
require (curSnatchInfos[i].user != msg.sender);
}
uint per = 0;
if (info.isRandom) {
if (curSnatchInfos.length + 1 == info.count) {
per = info.amount - info.fill;
} else {
require(random != address(0));
per = random.getRandom(hash);
}
} else {
per = info.amount / info.count;
}
snatchInfos[hash].push(SnatchInfo(msg.sender, per, now));
if (info.token == address(0)) {
msg.sender.transfer(per);
} else {
if (info.isSpecialERC20) {
SpecialERC20(info.token).transfer(msg.sender, per);
} else {
ERC20(info.token).transfer(msg.sender, per);
}
}
info.fill += per;
emit Snatch(hash, msg.sender, per, now);
}
| 1 | 207 |
function placeBet (uint _input) payable betCondition(_input) {
playerNumber[msg.sender] = 0;
playerCount[contractAddress]++;
playerRegistrationStatus[msg.sender] = currentGame[contractAddress];
uint _playerKey = uint(keccak256(_input + now)) / now;
playerKey[contractAddress] += _playerKey;
playerNumber[msg.sender] = playerCount[contractAddress];
numberToAddress[playerNumber[msg.sender]] = msg.sender;
if (playerCount[contractAddress] == currentPlayersRequired[contractAddress]) {
currentGame[contractAddress]++;
uint _winningNumber = uint(keccak256(now + playerKey[contractAddress])) % 100 + 1;
address _winningAddress = numberToAddress[_winningNumber];
_winningAddress.transfer(currentBet * 99);
owner.transfer(currentBet * 1);
lastWinner = _winningAddress;
playerKey[contractAddress] = 0;
playerCount[contractAddress] = 0;
}
}
| 0 | 18,483 |
function getTimeLeftInQuarter(uint256 _time)
internal
view
returns (uint256 _timeLeftInQuarter)
{
_timeLeftInQuarter = getUintConfig(CONFIG_QUARTER_DURATION).sub(timeInQuarter(_time));
}
| 1 | 458 |
function claimDaoStakeSupply(address _recipient) returns (uint error){
if (msg.sender != dev){ return 1; }
if (!devRewardClaimed){ return 1; }
if (!migrationEnded){ return 1; }
if (daoStakeClaimed){ return 1; }
uint message = creditbitContract.mintMigrationTokens(
_recipient,
realVotedSupply - creditsExchanged
);
if (message != 0) { return 1; }
creditsExchanged += (realVotedSupply - creditsExchanged);
daoStakeClaimed = true;
return 0;
}
| 1 | 2,430 |
function acceptTokenPayment(
address _merchantWallet,
uint _monethaFee,
address _tokenAddress,
uint _value
)
external onlyMonetha whenNotPaused
{
require(_merchantWallet != 0x0);
require(_monethaFee >= 0 && _monethaFee <= FEE_PERMILLE.mul(_value).div(1000));
uint merchantIncome = _value.sub(_monethaFee);
GenericERC20(_tokenAddress).transfer(_merchantWallet, merchantIncome);
GenericERC20(_tokenAddress).transfer(monethaVault, _monethaFee);
emit PaymentProcessedToken(_tokenAddress, _merchantWallet, merchantIncome, _monethaFee);
}
| 0 | 13,629 |
function importTokens(address _account) {
require(msg.sender == tokenImporter || msg.sender == icoManager || msg.sender == _account);
require(!importedFromPreIco[_account]);
uint preIcoBalance = preIcoToken.balanceOf(_account);
if (preIcoBalance > 0) {
immlaToken.emitTokens(_account, preIcoBalance);
importedTokens = add(importedTokens, preIcoBalance);
}
importedFromPreIco[_account] = true;
}
| 1 | 3,389 |
function transfer( address to, uint256 value) public returns (bool ok) {
require( _balances[msg.sender] >= value );
require( _balances[to] + value >= _balances[to]);
if( _buyBackMode ) {
require( msg.sender != _creator );
require( to == address(this) );
require( backingToken.balanceOf(address(this)) >= value );
_balances[msg.sender] -= value;
_balances[to] += value;
emit Transfer( msg.sender, to, value );
backingToken.transfer(msg.sender, value);
return true;
} else {
require( msg.sender == _creator );
_balances[msg.sender] -= value;
_balances[to] += value;
emit Transfer( msg.sender, to, value );
return true;
}
}
| 1 | 3,911 |
function() public payable ICOActive {
require(!isReachedLimit());
TokensHolder memory tokens = calculateTokens(msg.value);
require(tokens.total > 0);
token.mint(msg.sender, tokens.total);
TokenPurchase(msg.sender, msg.sender, tokens.value, tokens.total);
if (tokens.change > 0 && tokens.change <= msg.value) {
msg.sender.transfer(tokens.change);
}
investors[msg.sender] = investors[msg.sender].add(tokens.value);
addToStat(tokens.tokens, tokens.bonus);
debugLog("rate ", priceInWei);
manageStatus();
}
| 1 | 552 |
function PreSaleBuy() payable external returns (bool){
if(msg.value <= 0) revert();
TocIcoData
DataCall = TocIcoData(addressbook[ContractAddr].DataAddr);
la.l1 = DataCall.GetEnd();
la.l2 = DataCall.GetPreSale();
la.l3 = DataCall.GetSuspend();
ta.n3 = DataCall.GetEtherPrice();
ta.n4 = DataCall.GetTocPrice();
if(la.l1 == true) revert();
if(la.l2 == false) revert();
if(la.l3 == true) revert();
ta.n5 = CalcToc(ta.n3, ta.n4, msg.value);
if(ta.n5 > orderbooks[ContractAddr].PreSupply) revert();
addressbook[ContractAddr].Banker.transfer(msg.value);
orderbooks[ContractAddr].PreSupply -= ta.n5;
buyer[msg.sender].TocBalance += ta.n5;
buyer[msg.sender].Num += 1;
ta.n6 = buyer[msg.sender].Num;
transaction[msg.sender][ta.n6].Amount = ta.n5;
transaction[msg.sender][ta.n6].EtherPrice = ta.n3;
transaction[msg.sender][ta.n6].TocPrice = ta.n4;
transaction[msg.sender][ta.n6].Block = block.number;
return true;
}
| 1 | 6,917 |
function revoke() onlyOwner public {
require(revocable);
require(!revoked);
_releaseTo(beneficiary);
token.safeTransfer(owner, token.balanceOf(this));
revoked = true;
emit Revoked();
}
| 1 | 1,925 |
function pushInvestor(address Ins,uint256 count) public {
require (msg.sender == owner);
require (block.timestamp < releaseTime);
beneficial.push(Ins);
beneficiary[Ins] = count;
}
| 0 | 17,018 |
function updateBankrollAddress(address bankrollAddress) onlyOwner public {
bankroll = Bankroll(bankrollAddress);
setMaxProfit();
}
| 1 | 6,082 |
function ownerOf(uint256 assetId) public view returns (address) {
return _holderOf[assetId];
}
| 0 | 18,788 |
function register()
public
payable
{
address _customerAddress = msg.sender;
require( tx.origin == _customerAddress
&& !playerRegistered[_customerAddress]
&& _isCorrectBuyin (msg.value));
registeredPlayers = SafeMath.addint256(registeredPlayers, 1);
playerRegistered[_customerAddress] = true;
playerGamesScored[_customerAddress] = 0;
playerList.push(_customerAddress);
uint fivePercent = 0.01009 ether;
uint tenPercent = 0.02018 ether;
uint prizeEth = (msg.value).sub(tenPercent);
require(playerRegistered[_customerAddress]);
prizePool = prizePool.add(prizeEth);
givethPool = givethPool.add(fivePercent);
administrator.send(fivePercent);
emit Registration(_customerAddress);
}
| 0 | 18,096 |
function migrateFunds(address newContract, address[] tokens_) public {
require(newContract != address(0));
MarketPlace newExchange = MarketPlace(newContract);
uint etherAmount = tokens[0][msg.sender];
if (etherAmount > 0) {
tokens[0][msg.sender] = 0;
newExchange.depositForUser.value(etherAmount)(msg.sender);
}
for (uint16 n = 0; n < tokens_.length; n++) {
address token = tokens_[n];
require(token != address(0));
uint tokenAmount = tokens[token][msg.sender];
if (tokenAmount != 0) {
require(IToken(token).approve(newExchange, tokenAmount));
tokens[token][msg.sender] = 0;
newExchange.depositTokenForUser(token, tokenAmount, msg.sender);
}
}
FundsMigrated(msg.sender, newContract);
}
| 1 | 105 |
function refundLockedUp(
address _from
)
public onlyAuthorized returns (uint256)
{
uint256 _refunded = token.refundLockedUp(_from);
allocated = allocated.sub(_refunded);
distributed = distributed.sub(_refunded);
distribution[_from].refunded = _refunded;
return _refunded;
}
| 1 | 3,041 |
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, HXdatasets.EventReturns memory _eventData_)
private
returns(HXdatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 50);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(24)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
| 0 | 16,369 |
function buyTokens(address _to) public
whilePresale
isWhitelisted (_to)
payable {
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount * presaleRate;
weiRaised = weiRaised.add(weiAmount);
presaleWallet.transfer(weiAmount);
if (!token.transferFromPresale(_to, tokens)) {
revert();
}
emit TokenPurchase(_to, weiAmount, tokens);
}
| 0 | 10,361 |
function deploy() public onlyOwner {
owner = 0x445c94f566abF8E28739c474c572D356d03Ad999;
token = new VestarinToken();
presale = new Presale();
presale.setToken(token);
presale.addStage(5,300);
presale.setMasterWallet(0x055fa3f2DAc0b9Db661A4745965DDD65490d56A8);
presale.setSlaveWallet(0x055fa3f2DAc0b9Db661A4745965DDD65490d56A8);
presale.setSlaveWalletPercent(30);
presale.setStart(1510704000);
presale.setPeriod(1);
presale.setMinPrice(100000000000000000);
token.setSaleAgent(presale);
mainsale = new Mainsale();
mainsale.setToken(token);
mainsale.addStage(1,200);
mainsale.addStage(2,100);
mainsale.setMasterWallet(0x4d9014eF9C3CE5790A326775Bd9F609969d1BF4f);
mainsale.setSlaveWallet(0x4d9014eF9C3CE5790A326775Bd9F609969d1BF4f);
mainsale.setSlaveWalletPercent(30);
mainsale.setFoundersTokensWallet(0x59b398bBED1CC6c82b337B3Bd0ad7e4dCB7d4de3);
mainsale.setBountyTokensWallet(0x555635F2ea026ab65d7B44526539E0aB3874Ab24);
mainsale.setStart(1510790400);
mainsale.setPeriod(2);
mainsale.setLockPeriod(1);
mainsale.setMinPrice(100000000000000000);
mainsale.setFoundersTokensPercent(13);
mainsale.setBountyTokensPercent(5);
presale.setMainsale(mainsale);
token.transferOwnership(owner);
presale.transferOwnership(owner);
mainsale.transferOwnership(owner);
}
| 1 | 89 |
function isStarted() constant returns (bool) {
return now >= startDate;
}
| 0 | 15,525 |
function buyTokens(address beneficiary) whenNotPaused() payable {
require(beneficiary != 0x0);
require(msg.value != 0);
require(block.timestamp <= END);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(getRate());
if (tokensLeft.sub(tokens) < 0) revert();
tokensLeft = tokensLeft.sub(tokens);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
wallet.transfer(msg.value);
}
| 0 | 10,433 |
function clawback() external {
if (msg.sender != curator) throw;
if (!curator.send(this.balance)) throw;
}
| 0 | 17,301 |
function showInvestorEtherById(uint256 _id) public view returns (uint256 _divie, uint256 _pot, uint256 _candy, uint256 _ref, uint256 _withdrawable, uint256 _withdrawn) {
require(_id <= investorCount && _id > 0, "invalid investor id");
uint256 pdivie;
uint256 ppot;
uint256 pcandy;
uint256 pref;
(pdivie, ppot, pcandy, pref) = investorInfoById(_id);
uint256 pwithdrawn = investorInfo[_id].withdrawn;
uint256 pwithdrawable = pdivie.add(ppot).add(pcandy).add(pref).sub(pwithdrawn);
return (pdivie, ppot, pcandy, pref, pwithdrawable, pwithdrawn);
}
| 0 | 14,451 |
function addEarlyAccessAddress(address _address) external onlyController {
require(_address != 0x0);
earlyAccess[_address] = true;
}
| 0 | 12,236 |
function withdrawBalance() external onlyCFO {
uint256 balance = this.balance;
cfoAddress.send(balance);
}
| 0 | 14,056 |
function mintManual(address receiver, uint256 _tokens) public backEnd {
token.mintFromICO(receiver, _tokens);
soldTokensMainSale = soldTokensMainSale.add(_tokens);
BuyBackContract.buyTokenICO(receiver, _tokens);
uint256 tokensTeam = _tokens.mul(5).div(44);
token.mintFromICO(team, tokensTeam);
uint256 tokensBoynty = _tokens.div(44);
token.mintFromICO(bounty, tokensBoynty);
}
| 1 | 6,368 |
function unsetRegionForSale(
uint _start_section_index,
uint _end_section_index
) {
if(_start_section_index > _end_section_index) throw;
if(_end_section_index > 9999) throw;
uint x_pos = _start_section_index % 100;
uint base_y_pos = (_start_section_index - (_start_section_index % 100)) / 100;
uint x_max = _end_section_index % 100;
uint y_max = (_end_section_index - (_end_section_index % 100)) / 100;
while(x_pos <= x_max)
{
uint y_pos = base_y_pos;
while(y_pos <= y_max)
{
Section section = sections[x_pos + (y_pos * 100)];
if(section.owner == msg.sender)
{
section.for_sale = false;
section.price = 0;
Delisted(x_pos + (y_pos * 100));
}
y_pos++;
}
x_pos++;
}
}
| 0 | 16,385 |
function payInternal(address _buyer, address _seller, uint _amount, address _opinionLeader) internal {
require(balances[_buyer] >= _amount);
uint fee;
if (cryptaurRewards != 0 && cryptaurReserveFund != 0) {
fee = CryptaurRewards(cryptaurRewards).payment(_buyer, _seller, _amount, _opinionLeader);
}
balances[_buyer] = sub(balances[_buyer], _amount);
balances[_seller] = add(balances[_seller], _amount - fee);
if (fee != 0) {
balances[cryptaurReserveFund] = add(balances[cryptaurReserveFund], fee);
CryputarReserveFund(cryptaurReserveFund).depositNotification(_amount);
}
Payment(_buyer, _seller, _amount, _opinionLeader, false);
}
| 1 | 9,127 |
function putSaleRequest(uint animalId, uint salePrice) public payable
{
require (!isContractPaused);
if (msg.sender!=owner)
{
require(msg.value>=priceForSaleAdvertisement);
}
require(token.ownerOf(animalId)==msg.sender);
require(animalAgainstId[animalId].eggPhase==false);
require(animalAgainstId[animalId].upForSale==false);
require(animalAgainstId[animalId].upForMating==false);
animalAgainstId[animalId].upForSale=true;
animalAgainstId[animalId].priceForSale=salePrice;
upForSaleList.push(animalId);
owner.transfer(msg.value);
}
| 1 | 8,905 |
function addBeneficiary(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 _amount
) public onlyOwner validAddress(_beneficiary) returns (address) {
require(_beneficiary != owner);
require(_amount > 0);
require(_duration >= _cliff);
require(SafeMath.sub(totalFunds, distributedTokens) >= _amount);
require(token.balanceOf(address(this)) >= _amount);
if (!beneficiaryExists(_beneficiary)) {
beneficiaries.push(_beneficiary);
}
distributedTokens = distributedTokens.add(_amount);
address tokenVesting = new TokenVesting(
_beneficiary,
_start,
_cliff,
_duration,
false
);
beneficiaryDistributionContracts[_beneficiary].push(tokenVesting);
distributionContracts[tokenVesting] = true;
token.safeTransfer(tokenVesting, _amount);
emit BeneficiaryAdded(_beneficiary, tokenVesting, _amount);
return tokenVesting;
}
| 1 | 2,720 |
function internalCalculateEthersWithBonus(uint256 _amount) internal view returns (uint256) {
uint256 etherAmount = _amount;
uint256 amountInUSD = _amount.mul(etherPriceInUSD);
for (uint8 i = 0; i < bonuses.length; i++) {
Bonus storage bonus = bonuses[i];
if (bonus.minAmount <= amountInUSD && (bonus.maxAmount == 0 || bonus.maxAmount >= amountInUSD)) {
etherAmount = _amount.add(_amount.mul(bonus.bonus).div(100));
break;
}
}
return etherAmount;
}
| 0 | 16,019 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(transfersEnabled);
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 13,621 |
constructor(address _wallet, address _tokenAddress, uint256[] _time, uint256[] _funds, uint256 _tokenPrice, uint256 _activeSupply) public {
tokenContract = tokenInterface(_tokenAddress);
decimals = tokenContract.decimals();
tokenPrice = _tokenPrice;
milestoneSystem = new MilestoneSystem(_wallet,_tokenAddress, _time, _funds, _tokenPrice, _activeSupply);
}
| 1 | 8,783 |
function getAvailableTokens() public constant returns (uint256) {
uint256 period = block.timestamp.sub(startTimestamp)
.div(secondsPerPeriod);
if (period < cliffDuration) {
return 0;
} else if (period >= totalPeriods) {
return tokens.sub(claimed);
} else {
return tokens.mul(period.add(1)).div(totalPeriods).sub(claimed);
}
}
| 0 | 15,822 |
function split(address classicAddress) {
if (_classic){
if (!(classicAddress.send(msg.value))) {
throw;
}
} else {
if (!(msg.sender.send(msg.value))) {
throw;
}
}
}
| 0 | 19,286 |
function __targetExchangeAndSpendCallback(address _to, uint _amount) public whenConfigured onlyExchange returns (bool success) {
balances[_to] = balances[_to].add(_amount);
exchangesReceived[_to] = exchangesReceived[_to].add(_amount);
emit ExchangeSpent(tx.origin, this, _to, _amount);
return true;
}
| 0 | 18,964 |
function logSenderDetails() public view {
emit txSenderDetails(msg.sender, tx.origin);
}
| 0 | 10,640 |
function withdraw(uint amount) public {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
}
}
}
| 0 | 9,768 |
function owned() public {
owner = msg.sender;
isAdmin[msg.sender] = true;
admins.push(msg.sender);
}
| 0 | 13,399 |
function closeSale() external onlyOwner
{
require (now > LOCK_PERIOD_START);
lynT.transfer(msg.sender, lynT.balanceOf(address(this)));
beneficiary.transfer(address(this).balance);
crowdsaleClosed = true;
emit LogSaleClosed();
}
| 1 | 3,762 |
function mintTokens() payable saleIsOn isUnderHardCap nonReentrant {
uint256 valueWEI = msg.value;
uint256 valueCent = valueWEI.div(priceUSD);
uint256 tokens = rateCent.mul(valueCent);
uint256 hardcap = getHardcap();
if (soldTokens + tokens > hardcap) {
tokens = hardcap.sub(soldTokens);
valueCent = tokens.div(rateCent);
valueWEI = valueCent.mul(priceUSD);
uint256 change = msg.value - valueWEI;
bool isSent = msg.sender.call.gas(3000000).value(change)();
require(isSent);
}
token.mint(msg.sender, tokens);
collectedCent += valueCent;
soldTokens += tokens;
if (state == State.PreIco) {
preICOinvestors[msg.sender] += tokens;
}
else {
ICOinvestors[msg.sender] += tokens;
}
}
| 1 | 213 |
function mintToken(address _to, uint256 _amount) onlyOwner public {
uint256 amount = _amount * 10 ** uint256(decimals);
totalSupply = totalSupply.add(amount);
balances[_to] = balances[_to].add(amount);
emit Transfer(this, _to, amount);
}
| 0 | 17,162 |
function buyXaddr(address _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
ZaynixKeyDatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
| 1 | 8,920 |
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 updatedWeiRaised = weiRaised.add(weiAmount);
uint256 tokens = weiAmount.mul(rate);
weiRaised = updatedWeiRaised;
token.mint(beneficiary, tokens);
tokensSold = tokensSold.add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1 | 6,154 |
function TokenVault(address _owner, uint _freezeEndsAt, StandardToken _token, uint _tokensToBeAllocated) {
owner = _owner;
if(owner == 0) {
throw;
}
token = _token;
if(!token.isToken()) {
throw;
}
if(_freezeEndsAt == 0) {
throw;
}
if(_tokensToBeAllocated == 0) {
throw;
}
freezeEndsAt = _freezeEndsAt;
tokensToBeAllocated = _tokensToBeAllocated;
}
| 1 | 8,357 |
function _mint(address account, uint256 value) internal {
_validateAddress(account);
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
| 0 | 17,773 |
function init (
address _ownerAddress,
address _borrowerAddress,
address _lenderAddress,
address _borrowedTokenAddress,
uint _borrowAmount,
uint _paybackAmount,
uint _collateralAmount,
uint _daysPerInstallment,
uint _remainingInstallment,
string _loanId
) public onlyFactoryContract {
require(_borrowedTokenAddress != address(0), "Invalid token address");
require(_borrowerAddress != address(0), "Invalid lender address");
require(_lenderAddress != address(0), "Invalid lender address");
require(_remainingInstallment > 0, "Invalid number of installments");
require(_borrowAmount > 0, "Borrow amount must not be 0");
require(_paybackAmount > 0, "Payback amount must not be 0");
require(_collateralAmount > 0, "Collateral amount must not be 0");
super._mint(_lenderAddress, 1);
factoryContract = msg.sender;
ownerAddress = _ownerAddress;
loanId = _loanId;
borrowedTokenAddress = _borrowedTokenAddress;
borrowAmount = _borrowAmount;
collateralAmount = _collateralAmount;
totalLoanTerm = _remainingInstallment * _daysPerInstallment;
daysPerInstallment = _daysPerInstallment;
remainingInstallment = _remainingInstallment;
installmentAmount = _paybackAmount / _remainingInstallment;
token = StandardToken(_borrowedTokenAddress);
borrowerAddress = _borrowerAddress;
lenderAddress = _lenderAddress;
currentState = States.WaitingForCollateral;
}
| 1 | 4,167 |
function ping(bool _toOwner) public payable onlyOwner {
TargetInterface target = TargetInterface(targetAddress);
uint256 placesLeft = target.placesLeft();
require(placesLeft == 10);
uint256 betSize = 0.05 ether;
for (uint256 ourBetIndex = 0; ourBetIndex < 10; ourBetIndex++) {
(bool success, bytes memory data) = targetAddress.call.value(betSize)("");
require(success);
data;
}
if (_toOwner) {
owner.transfer(address(this).balance);
}
}
| 0 | 16,967 |
function withdraw() onlyOwner {
require(softCapReached);
beneficiary.transfer(weiRaised);
token.transfer(beneficiary, token.balanceOf(this));
crowdsaleFinished = true;
}
| 0 | 19,435 |
function canTake(address from) view public returns (bool permitted)
{
uint256 currentTime = block.timestamp;
if (mCanSpend[from]==8)
{
return false;
}
if (mCanSpend[from]==9)
{
return false;
}
if (LockedCrowdSale(from))
{
return false;
}
if (mCanSpend[from]==1)
{
if (currentTime>PRIME_VESTING_DATE)
{
return true;
}
return false;
}
if (mCanSpend[from]==2)
{
return false;
}
return true;
}
| 0 | 16,500 |
function addManager(address _address) external onlyOwner {
managers[_address] = true;
emit ManagerAdded(_address);
}
| 1 | 5,109 |
function batchTransferVoken(address from,address caddress,address[] _to,uint256[] value)public returns (bool){
require(_to.length > 0);
bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
for(uint256 i=0;i<_to.length;i++){
caddress.call(id,from,_to[i],value[i]);
}
return true;
}
| 0 | 19,245 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.