func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
constructor(address _migrationSource, address [] _holders) public {
uint256 total = 0;
balances[0x80da2Af3A3ED3Ecd165D7aC76b4a0C10D2deCB13] = ERC20migrate(_migrationSource).balanceOf(0xbAc36D24b6641434C7cE8E48F89e79E1fb6bd497);
total += balances[0x80da2Af3A3ED3Ecd165D7aC76b4a0C10D2deCB13];
emit Transfer(address(this), 0x80da2Af3A3ED3Ecd165D7aC76b4a0C10D2deCB13, balance);
for(uint i=0; i<_holders.length; ++i) {
uint256 balance = ERC20migrate(_migrationSource).balanceOf(_holders[i]);
balances[_holders[i]] = balance;
total += balance;
emit Transfer(address(this), _holders[i], balance);
}
require(total == ERC20migrate(_migrationSource).totalSupply());
}
| 1 | 9,031 |
function setup(address _easyMineToken, address _sys, address _reservationAddress, uint256 _minStartDelay, uint256 _maxDuration)
public
isOwner
atStage(Stages.Deployed)
{
require(_easyMineToken != 0x0);
require(_sys != 0x0);
require(_reservationAddress != 0x0);
require(_minStartDelay > 0);
require(_maxDuration > 0);
priceThresholds[0] = PriceThreshold(2000000 * 10**18, 0.00070 * 10**18, 0);
priceThresholds[1] = PriceThreshold(2000000 * 10**18, 0.00075 * 10**18, 0);
priceThresholds[2] = PriceThreshold(23000000 * 10**18, 0.00080 * 10**18, 0);
easyMineToken = EasyMineToken(_easyMineToken);
sys = _sys;
reservationAddress = _reservationAddress;
minStartDelay = _minStartDelay;
maxDuration = _maxDuration;
assert(easyMineToken.balanceOf(this) == maxTokensSold());
stage = Stages.SetUp;
}
| 1 | 2,659 |
function () payable public {
uint256 bonus = 0;
uint256 amount;
uint256 ethamount = msg.value;
require(!crowdsaleClosed);
uint256 onlyAdt = ethamount.div(price);
uint256 weiAdt = SafeMath.mul(onlyAdt, 100000000000000);
require(isValidUser(msg.sender, weiAdt));
balanceOf[msg.sender] = balanceOf[msg.sender].add(ethamount);
amountRaised = amountRaised.add(ethamount);
if(now >= preSaleStartdate && now <= preSaleDeadline){
amount = ethamount.div(price);
bonus = amount * 33 / 100;
amount = amount.add(bonus);
}
else if(now >= mainSaleStartdate && now <= mainSaleStartdate + 30 days){
amount = ethamount.div(price);
bonus = amount * 25/100;
amount = amount.add(bonus);
}
else if(now >= mainSaleStartdate + 30 days && now <= mainSaleStartdate + 45 days){
amount = ethamount.div(price);
bonus = amount * 15/100;
amount = amount.add(bonus);
}
else if(now >= mainSaleStartdate + 45 days && now <= mainSaleStartdate + 60 days){
amount = ethamount.div(price);
bonus = amount * 10/100;
amount = amount.add(bonus);
} else {
amount = ethamount.div(price);
bonus = amount * 7/100;
amount = amount.add(bonus);
}
amount = amount.mul(100000000000000);
tokenReward.transfer(msg.sender, amount);
tokenSold = tokenSold.add(amount);
resetUserWhiteListAmount();
emit FundTransfer(msg.sender, ethamount, true);
}
| 1 | 141 |
function changeBurnBounds(uint newMin, uint newMax) onlyOwner public {
require(newMin <= newMax);
burnMin = newMin;
burnMax = newMax;
ChangeBurnBoundsEvent(newMin, newMax);
}
| 1 | 2,597 |
function initComptroller(_ITrComptroller _comptroller)
public
{
require(msg.sender == owner);
require(address(comptroller) == address(0));
require(_comptroller.treasury() == address(this));
comptroller = _comptroller;
emit ComptrollerSet(now, _comptroller, comptroller.token());
}
| 1 | 6,701 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
| 0 | 15,223 |
function lifeVestingStage() public view onlyTokenReserveLife returns(uint256) {
uint256 nowTime = block.timestamp;
uint256 stage = (nowTime.sub(lifeReserveTimeLock)).div(2592000);
if(stage > lifeVestingStages) {
stage = lifeVestingStages;
}
return stage;
}
| 0 | 19,356 |
function _updateDependencies() internal {
bondageAddress = coordinator.getContract("BONDAGE");
bondage = BondageInterface(bondageAddress);
address databaseAddress = coordinator.getContract("DATABASE");
db = DatabaseInterface(databaseAddress);
}
| 1 | 7,418 |
function closeDataResponse(
address seller,
bool transactionCompleted
) public onlyOwner validAddress(seller) returns (bool) {
require(orderStatus != OrderStatus.TransactionCompleted);
require(transactionCompletedAt == 0);
require(hasSellerBeenAccepted(seller));
require(sellerInfo[seller].status == DataResponseStatus.DataResponseAdded);
sellerInfo[seller].status = transactionCompleted
? DataResponseStatus.TransactionCompleted
: DataResponseStatus.RefundedToBuyer;
sellerInfo[seller].closedAt = uint32(block.timestamp);
return true;
}
| 0 | 10,449 |
function releaseTokens(address _adr) public{
require(_adr!=address(0));
HolderSchedule storage holderSchedule = holderList[_adr];
if(holderSchedule.isReleased==false&&holderSchedule.lockAmount>0){
uint256 unlockAmount=lockStrategy(_adr);
if(unlockAmount>0&&holderSchedule.lockAmount>=unlockAmount){
holderSchedule.lockAmount=holderSchedule.lockAmount.sub(unlockAmount);
holderSchedule.releasedAmount=holderSchedule.releasedAmount.add(unlockAmount);
holderSchedule.totalReleasedAmount=holderSchedule.totalReleasedAmount.add(unlockAmount);
holderSchedule.lastUnlocktime=block.timestamp;
if(holderSchedule.lockAmount==0){
holderSchedule.isReleased=true;
holderSchedule.releasedAmount=0;
holderSchedule.unlockNumed=0;
}
accessToken(_adr,unlockAmount);
emit ReleaseTokens(_adr,unlockAmount);
}
}
}
| 0 | 12,130 |
function halvingSubsidy(uint256 _halving)
public
constant
notBeforeGenesis
returns(uint256)
{
uint256 startBlock = halvingStartBlock(_halving);
return blockSubsidy(startBlock).mul(subsidyHalvingInterval);
}
| 0 | 17,486 |
function was called.
uint256 currentTotalBankroll = getBankroll();
uint256 currentSupplyOfTokens = totalSupply;
uint256 withdrawEther = SafeMath.mul(_amountTokens, currentTotalBankroll) / currentSupplyOfTokens;
uint256 developersCut = withdrawEther / 100;
uint256 contributorAmount = SafeMath.sub(withdrawEther, developersCut);
totalSupply = SafeMath.sub(currentSupplyOfTokens, _amountTokens);
balances[msg.sender] = SafeMath.sub(tokenBalance, _amountTokens);
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
msg.sender.transfer(contributorAmount);
emit CashOut(msg.sender, contributorAmount, _amountTokens);
emit Transfer(msg.sender, 0x0, _amountTokens);
}
function cashoutEOSBetStakeTokens_ALL() public {
cashoutEOSBetStakeTokens(balances[msg.sender]);
}
function transferOwnership(address newOwner) public {
require(msg.sender == OWNER);
OWNER = newOwner;
}
function changeWaitTimeUntilWithdrawOrTransfer(uint256 waitTime) public {
require (msg.sender == OWNER && waitTime <= 6048000);
WAITTIMEUNTILWITHDRAWORTRANSFER = waitTime;
}
function changeMaximumInvestmentsAllowed(uint256 maxAmount) public {
require(msg.sender == OWNER);
MAXIMUMINVESTMENTSALLOWED = maxAmount;
}
function withdrawDevelopersFund(address receiver) public {
require(msg.sender == OWNER);
EOSBetGameInterface(DICE).payDevelopersFund(receiver);
EOSBetGameInterface(SLOTS).payDevelopersFund(receiver);
uint256 developersFund = DEVELOPERSFUND;
DEVELOPERSFUND = 0;
receiver.transfer(developersFund);
}
function ERC20Rescue(address tokenAddress, uint256 amtTokens) public {
require (msg.sender == OWNER);
ERC20(tokenAddress).transfer(msg.sender, amtTokens);
}
function totalSupply() constant public returns(uint){
return totalSupply;
}
function balanceOf(address _owner) constant public returns(uint){
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success){
require(balances[msg.sender] >= _value
&& contributionTime[msg.sender] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)
&& _to != address(0));
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) public returns(bool){
require(allowed[_from][msg.sender] >= _value
&& balances[_from] >= _value
&& contributionTime[_from] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)
&& _to != address(0));
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public returns(bool){
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns(uint){
return allowed[_owner][_spender];
}
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
| 0 | 16,843 |
function _transfer(address _from, address _to, uint _value) internal {
require(balanceOf[_from] >= _value);
uint256 remain = balanceOf[_from].sub(_value);
uint256 length = lockedAddresses[_from].length;
for (uint256 i = 0; i < length; i++) {
LockMeta storage meta = lockedAddresses[_from][i];
if(block.timestamp < meta.endtime && remain < meta.remain){
revert();
}
}
super._transfer(_from, _to, _value);
}
| 0 | 16,013 |
function challenge(address listingAddress, string _data) public returns (uint challengeID) {
Listing storage listing = listings[listingAddress];
uint minDeposit = parameterizer.get("minDeposit");
require(appWasMade(listingAddress) || listing.whitelisted, "Listing must be in application phase or already whitelisted to be challenged");
require(listing.challengeID == 0 || challenges[listing.challengeID].resolved, "Listing must not have active challenge to be challenged");
if (listing.unstakedDeposit < minDeposit) {
resetListing(listingAddress);
emit _TouchAndRemoved(listingAddress);
return 0;
}
uint pollID = voting.startPoll(
parameterizer.get("voteQuorum"),
parameterizer.get("commitStageLen"),
parameterizer.get("revealStageLen")
);
uint oneHundred = 100;
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: ((oneHundred.sub(parameterizer.get("dispensationPct"))).mul(minDeposit)).div(100),
stake: minDeposit,
resolved: false,
totalTokens: 0
});
listing.challengeID = pollID;
listing.unstakedDeposit -= minDeposit;
require(token.transferFrom(msg.sender, this, minDeposit), "Token transfer failed");
var (commitEndDate, revealEndDate,) = voting.pollMap(pollID);
emit _Challenge(listingAddress, pollID, _data, commitEndDate, revealEndDate, msg.sender);
return pollID;
}
| 1 | 8,179 |
function setNewAvailableWithdrawal(bool _newAvailableWithdrawal) onlyOwner {
availableWithdrawal = _newAvailableWithdrawal;
}
| 0 | 11,565 |
function endRound()
private
{
Datasets.Round _round = round_[rID_];
if (_round.keys > 0 && _round.investment <= pot_.mul(luckyEdge_).div(100) && now > _round.end)
{
uint256 _referBonus = getReferBonus();
uint256 _ref = pot_.mul(_referBonus).div(100);
uint256 _luck = pot_.sub(_ref);
_round.ppk = _luck.mul(magnitude).div(_round.keys);
pot_ = 0;
luckyRounds_++;
Referralcontract_.outerDividend.value(_ref)();
emit onWinLuckyPrize(rID_);
}
rID_++;
round_[rID_].strt = now;
round_[rID_].end = now.add(rndInit_);
}
| 1 | 9,528 |
function setDigitalMediaStoreAddress(address _dmsAddress)
internal {
DigitalMediaStoreInterface candidateDigitalMediaStore = DigitalMediaStoreInterface(_dmsAddress);
require(candidateDigitalMediaStore.getDigitalMediaStoreVersion() == 2, "Incorrect version.");
currentDigitalMediaStore = candidateDigitalMediaStore;
currentDigitalMediaStore.registerTokenContractAddress();
currentStartingDigitalMediaId = currentDigitalMediaStore.getStartingDigitalMediaId();
}
| 1 | 6,370 |
function checkPermission(address _delegate, address _module, bytes32 _perm) public view returns(bool) {
for (uint256 i = 0; i < modules[PERMISSION_KEY].length; i++) {
if (!modulesToData[modules[PERMISSION_KEY][i]].isArchived)
return TokenLib.checkPermission(modules[PERMISSION_KEY], _delegate, _module, _perm);
}
return false;
}
| 1 | 4,628 |
function _unfreezeMaxTokens(uint _value) internal {
uint amount = frozenBalanceOf[msg.sender] > _value ? _value : frozenBalanceOf[msg.sender];
if (amount > 0) {
balanceOf[msg.sender] += amount;
frozenBalanceOf[msg.sender] -= amount;
Transfer(this, msg.sender, amount);
}
}
| 0 | 14,478 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
| 1 | 441 |
function _enqueueKitty(uint256 _kittyId) internal {
depositedKittiesQueue.push(_kittyId);
queueEndIndex = queueEndIndex.add(1);
}
| 0 | 9,794 |
function calculateTokens(uint _amount, uint _stage, uint _stageAmount) public returns (uint) {
bonuses[1] = firstBonusPercent;
bonuses[2] = secondBonusPercent;
bonuses[3] = thirdBonusPercent;
bonuses[4] = 0;
amounts[1] = 0;
amounts[2] = 0;
amounts[3] = 0;
amounts[4] = 0;
int amount = int(_amount);
uint i = _stage;
while (amount > 0) {
if (i > 3) {
amounts[i] = uint(amount);
break;
}
if (amount - int(_stageAmount) > 0) {
amounts[i] = _stageAmount;
amount -= int(_stageAmount);
i++;
} else {
amounts[i] = uint(amount);
break;
}
}
uint tokens = 0;
uint bonusTokens = 0;
uint _tokens = 0;
for (i = _stage; i <= 4; i++) {
if (amounts[i] == 0) {
break;
}
_tokens = rate.mul(amounts[i]).div(1 ether);
bonusTokens = _tokens * bonuses[i] / 100;
tokens += _tokens + bonusTokens;
}
return tokens;
}
| 1 | 9,046 |
function AALMCrowdsale(uint64 _startTimestamp, uint64 _endTimestamp, uint256 _hardCap, uint256 _minCap,
uint256 _founderTokensImmediate, uint256 _founderTokensVested, uint256 _vestingDuration,
uint256 _baseRate, uint32 _maxTimeBonusPercent, uint32 _referrerBonusPercent, uint32 _referralBonusPercent,
uint256[] bulkBonusMinAmounts, uint32[] bulkBonusPercents
) public {
require(_startTimestamp > now);
require(_startTimestamp < _endTimestamp);
startTimestamp = _startTimestamp;
endTimestamp = _endTimestamp;
require(_hardCap > 0);
hardCap = _hardCap;
minCap = _minCap;
initRatesAndBonuses(_baseRate, _maxTimeBonusPercent, _referrerBonusPercent, _referralBonusPercent, bulkBonusMinAmounts, bulkBonusPercents);
token = new AALMToken();
token.init(owner);
require(_founderTokensImmediate.add(_founderTokensVested) < _hardCap);
mintTokens(owner, _founderTokensImmediate);
founderVestingContract = new TokenVesting(owner, endTimestamp, 0, _vestingDuration, false);
mintTokens(founderVestingContract, _founderTokensVested);
}
| 1 | 3,830 |
function from modifying the pre-agreed %
require(
checkRefundSignature(_contractorPercent,_hirerMsgSig,_hirer)&&
checkRefundSignature(_contractorPercent,_contractorMsgSig,_contractor));
uint256 jobValue = hirerEscrowMap[_hirer][jobHash];
require(jobValue > 0 && jobValue == _value);
require(jobValue >= jobValue.sub(_fee));
require(totalInEscrow >= jobValue && totalInEscrow > 0);
totalInEscrow = totalInEscrow.sub(jobValue);
feesAvailableForWithdraw = feesAvailableForWithdraw.add(_fee);
delete jobEscrows[jobHash];
delete hirerEscrowMap[_hirer][jobHash];
uint256 contractorAmount = jobValue.sub(_fee).mul(_contractorPercent).div(100);
uint256 hirerAmount = jobValue.sub(_fee).mul(100 - _contractorPercent).div(100);
emit MutuallyAgreedCancellation(
jobHash,
msg.sender,
hirerAmount,
contractorAmount);
emit AddFeesToCoinSparrowPool(jobHash, _fee);
if (contractorAmount > 0) {
_contractor.transfer(contractorAmount);
}
| 0 | 18,559 |
function changeETXAddress(address etxAddress_) public {
require(msg.sender == admin);
require(block.number > Etx(etxAddress).expirationBlock());
etxAddress = etxAddress_;
}
| 1 | 6,344 |
function forceNeuroChainAddress(
address ethAddress,
string neurochainAddress
)
public onlyIcoContract
{
neuroChainAddresses[ethAddress] = neurochainAddress;
NeuroChainAddressSet(
ethAddress,
neurochainAddress,
block.timestamp,
true
);
}
| 0 | 17,768 |
function transferTokensTo(address to, uint256 givenTokens) internal returns (uint256) {
var providedTokens = givenTokens;
if (givenTokens > leftTokens) {
providedTokens = leftTokens;
}
leftTokens = leftTokens.sub(providedTokens);
addToSoldTokens(providedTokens);
require(token.manualTransfer(to, providedTokens));
transactionCounter = transactionCounter + 1;
return providedTokens;
}
| 1 | 1,958 |
function Withdraw() external returns (bool){
TocIcoData
DataCall = TocIcoData(addressbook[ContractAddr].DataAddr);
la.l4 = DataCall.GetEnd();
if(la.l4 == false) revert();
if(buyer[msg.sender].TocBalance <= 0) revert();
if(buyer[msg.sender].Withdrawn == true) revert();
buyer[msg.sender].Withdrawn = true;
buyer[msg.sender].WithdrawalBlock = block.number;
TOC
TOCCall = TOC(addressbook[ContractAddr].TOCAddr);
assert(buyer[msg.sender].Withdrawn == true);
TOCCall.transfer(msg.sender,buyer[msg.sender].TocBalance);
assert(buyer[msg.sender].Withdrawn == true);
return true;
}
| 1 | 155 |
function removeCardOwner(uint64 cardId) internal {
address cardOwner = cardIdMapping[cardId].owner;
if (playersCollections[cardOwner].cardIds.length > 1) {
uint64 rowToDelete = cardIdMapping[cardId].collectionPointer;
uint64 cardIdToMove = playersCollections[cardOwner].cardIds[playersCollections[cardOwner].cardIds.length - 1];
playersCollections[cardOwner].cardIds[rowToDelete] = cardIdToMove;
cardIdMapping[cardIdToMove].collectionPointer = rowToDelete;
}
playersCollections[cardOwner].cardIds.length--;
cardIdMapping[cardId].owner = 0;
}
| 0 | 10,487 |
function getRate() public constant returns (uint256)
{
uint256 ret = 1;
uint256 reduInterval= 1000;
uint256 reduRate = reduInterval.div(9);
uint256 startTimeStamp =now.sub(openingTime);
if(startTimeStamp<intervalTime)
{
startTimeStamp = 0;
}
ret = startRate - (startTimeStamp.div(intervalTime).mul(reduRate));
if( closingTime.sub(now)<intervalTime)
{
ret =10000;
}
return ret;
}
| 0 | 18,020 |
function withdrawNacNetfRe(uint _roundIndex) public {
require(NetfRevenue[_roundIndex].withdrawable == true && isPause == false);
require(usersNETF[_roundIndex][msg.sender].stake > 0 && usersNETF[_roundIndex][msg.sender].isWithdrawn == false);
require(NetfRevenue[_roundIndex].totalFci > 0);
uint nacReturn = ( NetfRevenue[_roundIndex].currentNAC.mul(usersNETF[_roundIndex][msg.sender].stake) ) / NetfRevenue[_roundIndex].totalFci;
NamiCrowdSale namiToken = NamiCrowdSale(NamiAddr);
namiToken.transfer(msg.sender, nacReturn);
usersNETF[_roundIndex][msg.sender].isWithdrawn = true;
}
| 1 | 4,578 |
function removePrice(uint256 tokenId) public returns (uint256){
require(erc721Address.ownerOf(tokenId) == msg.sender);
resetPrice(tokenId);
return prices[tokenId].price;
}
| 1 | 1,089 |
function () payable public {
require(!finalised);
require(block.timestamp >= startTime);
require(block.timestamp <= endTime);
require(availableSupply > 0);
mintMAN();
}
| 0 | 12,576 |
function Pay(bytes32 referrer_addr) public payable nonReentrant {
require(!address(msg.sender).isContract());
require(msg.value >= min_paymnet);
if(!users[msg.sender].isRegitered){
_register(referrer_addr);
}
uint amount = msg.value;
bool[3] memory levels = [false,false,false];
for(uint i = 0; i < users[msg.sender].referrers.length; i++){
address ref = users[msg.sender].referrers[i];
if(users[ref].next_payment > now){
uint reward = amount.mul(reward_parts[i]).div(100);
ref.transfer(reward);
levels[i] = true;
}
}
address fomo_user = msg.sender;
if(users[msg.sender].referrers.length>0 && users[users[msg.sender].referrers[0]].next_payment > now)
fomo_user = users[msg.sender].referrers[0];
_fomo.AddToBank.value(amount.mul(reward_parts[3]).div(100)).gas(gasleft())(fomo_user);
if(now > users[msg.sender].next_payment)
users[msg.sender].next_payment = now.add(amount.mul(min_time_to_add).div(min_paymnet));
else
users[msg.sender].next_payment = users[msg.sender].next_payment.add(amount.mul(min_time_to_add).div(min_paymnet));
emit PayEvent(msg.sender, amount, levels);
}
| 1 | 9,122 |
function BotCore() public {
paused = true;
ceoAddress = msg.sender;
cooAddress = msg.sender;
_createBot(0, 0, 0, uint256(-1), msg.sender);
}
| 1 | 7,950 |
function attowethBalance() public view returns (uint256 _attoweth) {
return weth.balanceOf(address(this));
}
| 0 | 11,101 |
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
if (c < a) revert();
return c;
}
| 0 | 17,866 |
function close() onlyOwner public {
uint256 tokens = token.balanceOf(this);
token.transfer(owner , tokens);
withdraw();
isClose = true;
}
| 1 | 6,416 |
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
}
contract CryptoAllStars is ERC721 {
event Birth(uint256 tokenId, string name, address owner);
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
event Transfer(address from, address to, uint256 tokenId);
string public constant NAME = "CryptoAllStars";
string public constant SYMBOL = "AllStarToken";
uint256 private startingPrice = 0.001 ether;
uint256 private constant PROMO_CREATION_LIMIT = 10000;
uint256 private firstStepLimit = 0.053613 ether;
uint public currentGen = 0;
mapping (uint256 => address) public allStarIndexToOwner;
mapping (address => uint256) private ownershipTokenCount;
mapping (uint256 => address) public allStarIndexToApproved;
mapping (uint256 => uint256) private allStarIndexToPrice;
address public ceo = 0x047F606fD5b2BaA5f5C6c4aB8958E45CB6B054B7;
address public cfo = 0xed8eFE0C11E7f13Be0B9d2CD5A675095739664d6;
uint256 public promoCreatedCount;
struct AllStar {
string name;
uint gen;
}
| 0 | 16,021 |
function migrateToNewControllerContract(address newControllerAddr) onlyAdministrator public {
require(newControllerAddr != address(0x0) && isActualContractVer);
isActive = false;
core.setNewControllerAddress(newControllerAddr);
if (stakeFreezer != address(0x0)) {
stakeFreezer.setNewControllerAddress(newControllerAddr);
}
uint256 mntpTokenAmount = getMntpBalance();
uint256 goldTokenAmount = getGoldBalance();
if (mntpTokenAmount > 0) mntpToken.transfer(newControllerAddr, mntpTokenAmount);
if (goldTokenAmount > 0) goldToken.transfer(newControllerAddr, goldTokenAmount);
isActualContractVer = false;
}
| 1 | 9,087 |
function() public payable onlyHuman checkFirstDeposit {
cashback();
sendCommission();
sendPayout();
updateUserInvestBalance();
}
| 0 | 11,439 |
function lock() public
notLocked
onlyOwner
{
uint totalLockedAmount = firstPrivateLockedAmount.add(secondPrivateLockedAmount);
totalLockedAmount = totalLockedAmount.add(minerLockedAmount);
require(token.balanceOf(address(this)) == totalLockedAmount);
lockedAt = block.timestamp;
firstPrivateReleaseTime = lockedAt.add(firstPrivateLockTime);
secondPrivateReleaseTime = lockedAt.add(secondPrivateLockTime);
minerRelaseTime = lockedAt.add(minerLockTime);
}
| 1 | 7,096 |
function offerAsSacrifice(address MN)
external
payable
isValidOffer
prepareStage
isNewToStage
{
acceptOffer(MN);
tryFinalizeStage();
}
| 1 | 1,098 |
function __callback(bytes32 _queryId, string _result, bytes _proof) oraclize_randomDS_proofVerify(_queryId, _result, _proof)
{
if(msg.sender != oraclize_cbAddress()) throw;
random_number = uint(sha3(_result))%potSize + 1;
winnerAddress = findWinner(random_number);
amountWon = this.balance * 98 / 100 ;
winnerAnnounced(winnerAddress, amountWon);
if(winnerAddress.send(amountWon)) {
if(owner.send(this.balance)) {
openPot();
}
}
}
| 1 | 5,433 |
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public
{
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
| 0 | 13,230 |
function FutureTokenSaleLockBox(ERC20Interface _simpleToken, TokenSaleInterface _tokenSale)
Owned()
public
{
require(address(_simpleToken) != address(0));
require(address(_tokenSale) != address(0));
simpleToken = _simpleToken;
tokenSale = _tokenSale;
uint256 endTime = tokenSale.endTime();
require(endTime > 0);
unlockDate = endTime.add(26 weeks);
}
| 1 | 6,450 |
constructor(
uint256 _start,
uint256 _end,
uint256 _rate,
address _wallet,
MintableToken _token
)
public
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_start, _end)
{
}
| 0 | 12,328 |
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
| 0 | 10,785 |
function postEvent(address[] _winners, uint _winningNumber, uint _jackpot) internal {
activity.newEvent(id, _winners, _winningNumber, _jackpot);
}
| 1 | 3,348 |
function unbond(bytes32 endpoint, uint numDots) public returns(uint256) {
require(status == ContestStatus.Settled, "not ready");
bondage = BondageInterface(coord.getContract("BONDAGE"));
uint issued = bondage.getDotsIssued(address(this), endpoint);
bondage.unbond(address(this), winner, numDots);
currentCost = CurrentCostInterface(coord.getContract("CURRENT_COST"));
uint reserveCost = currentCost._costOfNDots(address(this), endpoint, issued + 1 - numDots, numDots - 1);
FactoryTokenInterface curveToken = FactoryTokenInterface(curves[endpoint]);
if( status == ContestStatus.Initialized || status == ContestStatus.Canceled) {
require(block.number > ttl, "oracle query not expired.");
status = ContestStatus.Canceled;
curveToken.burnFrom(msg.sender, numDots);
require(reserveToken.transfer(msg.sender, reserveCost), "transfer failed");
emit Unbonded(endpoint, reserveCost, msg.sender);
return reserveCost;
}
else {
require( status == ContestStatus.Settled, " contest not settled");
require(redeemed[msg.sender] == 0, "already redeeemed");
require(winner==endpoint, "only winners can unbond for rewards");
uint reward = ( winValue * FactoryTokenInterface(getTokenAddress(winner)).balanceOf(msg.sender) ) + reserveCost;
curveToken.burnFrom(msg.sender, numDots);
reserveToken.transfer(msg.sender, reward);
redeemed[msg.sender] = 1;
return reward;
}
}
| 1 | 4,079 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
ExitScamsdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 9,177 |
function toBytes32(RLPItem memory self)
internal
pure
returns (bytes32 data)
{
return bytes32(toUint(self));
}
| 0 | 18,859 |
function synthesize(uint16[5] inputAssets, uint256 sCount) public payable whenNotPaused {
require(isSynthesizeAllowed == true);
require(accountsToFurnace[msg.sender].inSynthesization == false);
require(sCount <= maxSCount && sCount > 0);
bytes32[8] memory asset = assets[msg.sender];
bytes32 mask;
uint256 maskedValue;
uint256 count;
bytes32 _asset;
uint256 pos;
uint256 maxLevel = 0;
uint256 totalFee = 0;
uint256 _assetLevel;
Patent memory _patent;
uint16 currentAsset;
for (uint256 i = 0; i < 5; i++) {
currentAsset = inputAssets[i];
if (currentAsset < 248) {
_asset = asset[currentAsset / 31];
pos = currentAsset % 31;
mask = bytes32(255) << (8 * pos);
maskedValue = uint256(_asset & mask);
require(maskedValue >= (sCount << (8*pos)));
maskedValue -= (sCount << (8*pos));
_asset = ((_asset ^ mask) & _asset) | bytes32(maskedValue);
asset[currentAsset / 31] = _asset;
count += 1;
_assetLevel = assetLevel[currentAsset];
if (_assetLevel > maxLevel) {
maxLevel = _assetLevel;
}
if (_assetLevel > 0) {
_patent = patents[currentAsset];
if (_patent.patentOwner != address(0) && _patent.patentOwner != msg.sender && !_patent.onSale && (_patent.beginTime + patentValidTime > now)) {
maskedValue = pFees[_assetLevel] * sCount;
_patent.patentOwner.transfer(maskedValue / 10000 * feeRatio);
totalFee += maskedValue;
}
}
}
}
require(msg.value >= prePaidFee + totalFee);
require(count >= 2 && count <= 5);
require(_isCooldownReady(msg.sender));
uint128 skinType = skinContract.getActiveSkin(msg.sender);
uint256 _cooldownTime = chemistry.computeCooldownTime(skinType, cooldownLevels[maxLevel]);
accountsToFurnace[msg.sender].pendingAssets = inputAssets;
accountsToFurnace[msg.sender].cooldownEndTime = now + _cooldownTime;
accountsToFurnace[msg.sender].inSynthesization = true;
accountsToFurnace[msg.sender].count = sCount;
assets[msg.sender] = asset;
emit AutoSynthesize(msg.sender, accountsToFurnace[msg.sender].cooldownEndTime);
}
| 1 | 587 |
function checkForReceivedTokens() public{
if (getTokenBalance() != internalBalance){
uint256 receivedFunds = getTokenBalance().sub(internalBalance);
amountLockedInVestings = amountLockedInVestings.add(receivedFunds);
internalBalance = getTokenBalance();
emit TokensReceivedSinceLastCheck(receivedFunds);
}else{
emit TokensReceivedSinceLastCheck(0);
}
}
| 1 | 9,346 |
function getUpgradeProposals()
external
view
returns (address[] proposals)
{
return upgradeProposals;
}
| 0 | 13,269 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(block.timestamp >= unlockTime || whitelist[msg.sender], "Unable to transfer as unlock time not passed or address not whitelisted");
return super.transferFrom(_from, _to, _value);
}
| 0 | 13,537 |
function Token() public {
totalSupply = 350000000 * 10 ** uint(decimals);
initialSupply = totalSupply;
balances[msg.sender] = totalSupply;
}
| 0 | 18,582 |
function reserveFunds(address _address) public onlyOwner {
require(_address != address(0));
require(!isReservedFundsDone);
sendFromContract(_address, RESERVE_FUND);
isReservedFundsDone = true;
}
| 0 | 10,964 |
function requireRegistrantOrGreater(SPEntry spEntry) internal view {
require (msg.sender == spEntry.registrant ||
msg.sender == owner);
require (isSubscribed(spEntry) || msg.sender == owner);
}
| 0 | 13,675 |
function commit()
public
inState(State.Open)
payable{
require(msg.value >= commitThreshold);
if (msg.value > 0) {
FundsAdded(msg.value);
amountDeposited += msg.value;
}
recipient = msg.sender;
state = State.Committed;
Committed(recipient);
if (hasDefaultRelease) {
defaultTriggerTime = now + defaultTimeoutLength;
}
}
| 0 | 16,299 |
function claimTeamTokens(address _to, uint _choice) onlyOwner public {
require(crowdsaleState == state.crowdsaleEnded);
require(tokensIssued >= minCap);
uint mintAmount;
if (_choice == 1) {
assert(!insurePalTeamTokensClaimed);
mintAmount = insurePalTeam;
insurePalTeamTokensClaimed = true;
} else if (_choice == 2) {
assert(!tcsSupportTeamTokensClaimed);
mintAmount = tcsSupportTeam;
tcsSupportTeamTokensClaimed = true;
} else if (_choice == 3) {
assert(!advisorsAndAmbassadorsTokensClaimed);
mintAmount = advisorsAndAmbassadors;
advisorsAndAmbassadorsTokensClaimed = true;
} else if (_choice == 4) {
assert(!incentivesTokensClaimed);
mintAmount = incentives;
incentivesTokensClaimed = true;
} else if (_choice == 5) {
assert(!earlyInvestorsTokensClaimed);
mintAmount = earlyInvestors;
earlyInvestorsTokensClaimed = true;
} else if (_choice == 6) {
assert(!foundersTokensClaimed);
assert(insurePalTeamTokensClaimed);
assert(tcsSupportTeamTokensClaimed);
assert(advisorsAndAmbassadorsTokensClaimed);
assert(incentivesTokensClaimed);
assert(earlyInvestorsTokensClaimed);
assert(tokenTotalSupply > ERC20TokenInterface(tokenAddress).totalSupply());
mintAmount = tokenTotalSupply - ERC20TokenInterface(tokenAddress).totalSupply();
foundersTokensClaimed = true;
} else {
revert();
}
InsurePalTokenInterface(tokenAddress).mint(_to, mintAmount);
}
| 1 | 645 |
function mintToken(address target, uint256 mintedAmount) public onlyOwner {
balanceOf[target] =balanceOf[target].add(mintedAmount);
totalSupply =totalSupply.add(mintedAmount);
Transfer(0, owner, mintedAmount);
Transfer(owner, target, mintedAmount);
}
| 0 | 11,749 |
function assignUnitRafflePrize(address winner) internal {
unitRaffleWinner = winner;
updatePlayersGoo(winner);
increasePlayersGooProduction(winner, getUnitsProduction(winner, unitRaffleRareId, 1));
unitsOwned[winner][unitRaffleRareId] += 1;
}
| 1 | 9,587 |
function TheMobileMoney() {
balances[msg.sender] = totalSupply;
}
| 0 | 16,648 |
function isApprovedForAll(address _owner, address _operator) public constant returns (bool) {
return approvedOperators[_owner][_operator];
}
| 0 | 11,739 |
function ()
public
payable
{
purchaseTokens();
}
| 0 | 15,036 |
function Lotery(uint _maxPeriodDuration, uint _ticketPrice, uint _benefitPercents, uint _maxTicketAmount, address _hashAddr, uint _jackPotPercents) public {
require(_maxPeriodDuration > 0 && _ticketPrice > 0 && _benefitPercents > 0 && _benefitPercents < 50 && _maxTicketAmount > 0 && _jackPotPercents > 0 && _jackPotPercents < 50);
maxPeriodDuration = _maxPeriodDuration;
ticketPrice = _ticketPrice;
benefitPercents = _benefitPercents;
maxTicketAmount = _maxTicketAmount;
jackPotPercents = _jackPotPercents;
hashGenerator = Hash(_hashAddr);
baseHash = hashGenerator.get();
periods[currentPeriod].number = currentPeriod;
periods[currentPeriod].startDate = now;
}
| 1 | 226 |
function removeBeneficiary(address beneficiary) external onlyOwner {
Info storage info = _info[beneficiary];
require(info.known, "The address you are trying to remove is unknown to the contract");
_release(beneficiary);
info.known = false;
info.totalAmount = 0;
info.receivedAmount = 0;
info.startTime = 0;
info.releaseTime = 0;
}
| 1 | 3,864 |
function enableTransfer() external onlyOwner {
transferEnabled = true;
approve(tokenOfferingAddr, 0);
}
| 0 | 10,592 |
function _computeCurrentPrice(
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
uint256 _secondsPassed
)
internal
pure
returns (uint256)
{
if (_secondsPassed >= _duration) {
return _endingPrice;
} else {
int256 _totalPriceChange = int256(_endingPrice) - int256(_startingPrice);
int256 _currentPriceChange = _totalPriceChange * int256(_secondsPassed) / int256(_duration);
int256 _currentPrice = int256(_startingPrice) + _currentPriceChange;
return uint256(_currentPrice);
}
}
| 0 | 18,192 |
function withdraw() public{
require(now >= withdrawDate);
require(msg.sender == largestPenisOwner);
largestPenisOwner = 0;
largestPenis = 0;
owner.transfer(this.balance*3/100);
msg.sender.transfer(this.balance);
}
| 0 | 19,279 |
function refferal (address REF) public payable {
require(tx.gasprice <= 50000000000 wei, "Gas price is too high! Do not cheat!");
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= 10 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
uint promo = msg.value*Reclame_PERCENT/100;
Reclame.send(promo);
uint admin = msg.value*Admin_PERCENT/100;
Admin.send(admin);
uint bmg = msg.value*BMG_PERCENT/100;
BMG.send(bmg);
require(REF != 0x0000000000000000000000000000000000000000 && REF != msg.sender, "You need another refferal!");
uint ref = msg.value*Refferal_PERCENT/100;
REF.send(ref);
pay();
}
}
| 0 | 16,154 |
function abortSale()
public
isActive
onlySaleCreator
onlyWhenSelling
{
require(!currentSale.ended);
address investor = currentSale.investor;
address shareholder = currentSale.shareholder;
address company = address(this);
investor.transfer(currentSale.weiRaised);
require(token().transferFrom(investor, company, currentSale.sharesSold));
require(token().transferFrom(company, shareholder, currentSale.sharesCap));
SaleAborted(now);
currentSale.exists = false;
}
| 1 | 8,438 |
function receiveAirDrop() public {
require(isValidAirDropForIndividual());
invalidAirDrop[msg.sender] = true;
arrayAirDropReceivers.push(msg.sender);
require(erc20.transfer(msg.sender, airDropAmount));
emit LogAirDrop(msg.sender, airDropAmount);
}
| 1 | 1,529 |
function withdraw() onlyOwner onlyAfter(endTime) returns (bool) {
if (!beneficiary.send(collectedEthers)) {
return false;
}
presaleFinished = true;
return true;
}
| 0 | 17,669 |
function changeOwnerAddress(address newOwner) public
onlyOwner {
if (newOwner == address(0x0)) throw;
owner = newOwner;
}
| 1 | 923 |
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount, withdrawAmount);
}
| 0 | 17,296 |
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(31)) / 100).add((_eth.mul(fees_[_team].p3d)) / 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 | 17,053 |
function assignTokens(address receiver, uint tokenAmount) internal {
token.mint(receiver, tokenAmount);
}
| 0 | 10,102 |
function receiveApproval(address _from, uint _amount, address, bytes) public onlyBy(pinakion) {
require(pinakion.transferFrom(_from, this, _amount));
balance += _amount;
}
| 1 | 7,183 |
function register(address _user, string memory _userName, address _inviter)
onlyReserveFundContract
public
returns
(uint)
{
require(_userName.validateUserName(), "Invalid username");
Investor storage investor = investors[_user];
require(!isCitizen(_user), "Already an citizen");
bytes24 _userNameAsKey = _userName.stringToBytes24();
require(userNameAddresses[_userNameAsKey] == address(0x0), "Username already exist");
userNameAddresses[_userNameAsKey] = _user;
investor.id = userAddresses.length;
investor.userName = _userName;
investor.inviter = _inviter;
investor.rank = Rank.UnRanked;
increaseInvitersSubscribers(_inviter);
increaseInviterF1(_inviter, _user);
userAddresses.push(_user);
return investor.id;
}
| 0 | 12,150 |
function transfer(address _to, uint _value, bytes _data) public whenNotPaused returns (bool) {
if(_to.isContract()) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 0 | 18,435 |
function awardRafflePrize(address checkWinner, uint256 checkIndex) external {
require(raffleEndTime < block.timestamp);
require(raffleWinner == 0);
require(erc.ownerOf(tokenId) == address(this));
if (!raffleWinningTicketSelected) {
drawRandomWinner();
}
if (checkWinner != 0) {
TicketPurchases storage tickets = ticketsBoughtByPlayer[checkWinner];
if (tickets.numPurchases > 0 && checkIndex < tickets.numPurchases && tickets.raffleId == raffleId) {
TicketPurchase storage checkTicket = tickets.ticketsBought[checkIndex];
if (raffleTicketThatWon >= checkTicket.startId && raffleTicketThatWon <= checkTicket.endId) {
assignRafflePrize(checkWinner);
return;
}
}
}
for (uint256 i = 0; i < rafflePlayers[raffleId].length; i++) {
address player = rafflePlayers[raffleId][i];
TicketPurchases storage playersTickets = ticketsBoughtByPlayer[player];
uint256 endIndex = playersTickets.numPurchases - 1;
if (raffleTicketThatWon >= playersTickets.ticketsBought[0].startId && raffleTicketThatWon <= playersTickets.ticketsBought[endIndex].endId) {
for (uint256 j = 0; j < playersTickets.numPurchases; j++) {
TicketPurchase storage playerTicket = playersTickets.ticketsBought[j];
if (raffleTicketThatWon >= playerTicket.startId && raffleTicketThatWon <= playerTicket.endId) {
assignRafflePrize(player);
return;
}
}
}
}
}
| 1 | 2,591 |
function revoke(ERC20Interface token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
emit Revoked();
}
| 1 | 5,906 |
function recharge(string code) public isActive callFromHuman(msg.sender) payable {
require(msg.value >= minRecharge, "not enough fund");
string memory _code = coinHolders.getRefCode(msg.sender);
if (bytes(_code).length > 0) {
code = _code;
} else {
if (!dealers.dealerExisted(code)) {
code = defaultRefCode;
}
coinHolders.setRefCode(msg.sender, code);
}
coinHolders.add(msg.sender, msg.value);
roundIn(msg.value, code);
}
| 0 | 11,205 |
constructor() public {
_predecessor = 0x0;
if (_predecessor != 0x0) {
uint lastRevision = ZeroCache(_predecessor).getRevision();
_revision = lastRevision + 1;
}
_zer0netDb = Zer0netDbInterface(0xE865Fe1A1A3b342bF0E2fcB11fF4E3BCe58263af);
}
| 1 | 7,133 |
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
bool isPresale = isPresaleTime();
uint tokensAmount = tokenStrategy.getTokenAmount(_weiAmount, isPresale);
if (isPresale) {
require(tokensUsedOnPresale.add(tokensAmount) <= tokenStrategy.tokensAvailableForPresale());
tokensUsedOnPresale = tokensUsedOnPresale.add(tokensAmount);
} else {
require(tokensUsedOnSale.add(tokensAmount) <= tokenStrategy.tokensAvailableForSale());
tokensUsedOnSale = tokensUsedOnSale.add(tokensAmount);
}
return tokensAmount;
}
| 1 | 2,307 |
function creditEqually(address[] users, uint256 value) public onlyMaster returns (bool) {
uint256 balance = balances[msg.sender];
uint256 totalValue = users.length * value;
require(totalValue <= balance);
balances[msg.sender] = balance - totalValue;
address currentUser;
uint256 currentOldBalance;
uint256 currentNewBalance;
for (uint256 i = 0; i < users.length; ++i) {
currentUser = users[i];
currentOldBalance = balances[currentUser];
currentNewBalance = currentOldBalance + value;
require(currentOldBalance <= currentNewBalance);
balances[currentUser] = currentNewBalance;
Transfer(msg.sender, currentUser, value);
}
return true;
}
| 0 | 17,071 |
function payRequstedSum(uint clientId, uint date) onlyBy(owner) {
if (payouts[clientId].veto != 0) { throw; }
if (date - payouts[clientId].date < 60 * 60 * 24 * 3) { throw; }
clients[clientId].addr.send(payouts[clientId].amount);
delete payouts[clientId];
}
| 0 | 14,203 |
function payoutAndReset0(uint winningPerformer) public {
require(msg.sender == owner);
StarCoin instanceStarCoin = StarCoin(starCoinAddress);
EtherPornStars instanceEPS = EtherPornStars(epsAddress);
uint ownersfee = balance0/10;
uint total = balance0 - ownersfee;
for (uint i=0; i < idToVotersArray0[winningPerformer].length; i++) {
address payee = instanceEPS.ownerOf(idToVotersArray0[winningPerformer][i].voters0);
uint share = total.div(idToVotersArray0[winningPerformer].length);
instanceStarCoin.transferFromStudio(this, payee, share);
}
for (uint i1=0; i1 < 12; i1++) {
delete idToVotersArray0[i1];
}
delete balance0;
cashout(ownersfee);
}
| 1 | 612 |
function calculateAmountForETH(uint256 amountETH) public view returns (uint256) {
return Rationals.rmul(amountETH, ethRate);
}
| 0 | 11,168 |
function airdropManually(address _holder, uint _amount) public onlyOwner isAllowed {
require(_holder != address(0));
require(tokenReceived[_holder] == false);
if (!token.transfer(_holder, _amount)) revert();
tokenReceived[_holder] = true;
totalClaimed = totalClaimed.add(_amount);
}
| 1 | 6,629 |
function setInvestor(address investor, uint amount) public onlyOwner {
if(lockedAt > 0) {
throw;
}
if(amount == 0) throw;
if(balances[investor] > 0) {
throw;
}
balances[investor] = amount;
investorCount++;
tokensAllocatedTotal += amount;
Allocated(investor, amount);
}
| 1 | 4,135 |
function allocate() public notLocked notAllocated onlyOwner {
require(token.balanceOf(address(this)) == totalAllocation);
allocations[teamReserveWallet] = teamReserveAllocation;
allocations[lifeReserveWallet] = lifeReserveAllocation;
allocations[finanReserveWallet] = finanReserveAllocation;
allocations[econReserveWallet] = econReserveAllocation;
allocations[developReserveWallet] = developReserveAllocation;
Allocated(teamReserveWallet, teamReserveAllocation);
Allocated(lifeReserveWallet, lifeReserveAllocation);
Allocated(finanReserveWallet, finanReserveAllocation);
Allocated(econReserveWallet, econReserveAllocation);
Allocated(developReserveWallet, developReserveAllocation);
lock();
}
| 1 | 1,898 |
function signedTransferFrom(Data storage self, address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
require(self.transferable);
bytes32 hash = signedTransferFromHash(self, spender, from, to, tokens, fee, nonce);
require(spender != address(0) && spender == ecrecoverFromSig(keccak256(signingPrefix, hash), sig));
require(!self.accountLocked[from]);
require(self.nextNonce[spender] == nonce);
self.nextNonce[spender] = nonce + 1;
self.balances[from] = safeSub(self.balances[from], tokens);
self.allowed[from][spender] = safeSub(self.allowed[from][spender], tokens);
self.balances[to] = safeAdd(self.balances[to], tokens);
Transfer(from, to, tokens);
self.balances[from] = safeSub(self.balances[from], fee);
self.allowed[from][spender] = safeSub(self.allowed[from][spender], fee);
self.balances[feeAccount] = safeAdd(self.balances[feeAccount], fee);
Transfer(from, feeAccount, fee);
return true;
}
| 0 | 13,937 |
function createListing(address tokenContractAddress, uint256 price, uint256 allowance, uint256 dateEnds, uint256 salt) external {
require(price > 0);
require(allowance > 0);
require(dateEnds > 0);
require(getBalance(tokenContractAddress, msg.sender) > allowance);
require(getAllowance(tokenContractAddress, msg.sender, this) <= allowance);
bytes32 listingId = getHashInternal(tokenContractAddress, price, allowance, dateEnds, salt);
Listing memory listing = Listing(msg.sender, tokenContractAddress, price, allowance, now, dateEnds);
listings[listingId] = listing;
ListingCreated(listingId, tokenContractAddress, price, allowance, now, dateEnds, msg.sender);
}
| 1 | 282 |
function unholdSubscription(uint subId) public notSuspended noReentrancy(L05) returns (bool success) {
Subscription storage sub = subscriptions[subId];
assert (_isSubscription(sub));
var _to = sub.transferTo;
require (msg.sender == _to || msg.sender == sub.transferFrom);
if (sub.onHoldSince > 0) {
if (msg.sender == _to || ServiceProvider(_to).onSubUnHold(subId, msg.sender, false)) {
sub.paidUntil += now - sub.onHoldSince;
sub.onHoldSince = 0;
SubOnHold(subId, false, msg.sender);
return true;
}
}
if (isContract(msg.sender)) { return false; }
else { throw; }
}
| 1 | 258 |
function resolve(uint8 v, bytes32 r, bytes32 s, bytes32 value) {
require(ecrecover(sha3(factHash, value), v, r, s) == ethAddr);
require(!resolved);
uint valueInt = uint(value);
require(valueInt==0 || valueInt==1);
outcome = valueInt;
resolved = true;
Resolve(resolved, outcome);
}
| 0 | 11,116 |
function distributeExternal(uint256 _rID, uint256 _eth, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = (_eth.mul(5)) / 100;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
round_[_rID].pot = round_[_rID].pot.add(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 0 | 18,933 |
function tradeBalances (address tokenGet, uint amountGet, address tokenGive, uint amountGive, address user, uint amount) private {
uint feeMakeXfer = safeMul(amount, feeMake) / (1 ether);
uint feeTakeXfer = safeMul(amount, feeTake) / (1 ether);
uint feeRebateXfer = 0;
if (accountLevelsAddr != 0x0) {
uint accountLevel = AccountLevels(accountLevelsAddr).accountLevel(user);
if (accountLevel==1) feeRebateXfer = safeMul(amount, feeRebate) / (1 ether);
if (accountLevel==2) feeRebateXfer = feeTakeXfer;
}
tokens[tokenGet][msg.sender] = safeSub(tokens[tokenGet][msg.sender], safeAdd(amount, feeTakeXfer));
tokens[tokenGet][user] = safeAdd(tokens[tokenGet][user], safeSub(safeAdd(amount, feeRebateXfer), feeMakeXfer));
tokens[tokenGet][feeAccount] = safeAdd(tokens[tokenGet][feeAccount], safeSub(safeAdd(feeMakeXfer, feeTakeXfer), feeRebateXfer));
tokens[tokenGive][user] = safeSub(tokens[tokenGive][user], safeMul(amountGive, amount) / amountGet);
tokens[tokenGive][msg.sender] = safeAdd(tokens[tokenGive][msg.sender], safeMul(amountGive, amount) / amountGet);
}
| 1 | 4,943 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.