func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function transfer(address to, uint tokens) public returns (bool success) {
require (msg.sender != to);
require(to != address(0));
require(tokens <= balances[msg.sender].balance);
if (!_whitelistAll) {
if (msg.sender != owner && block.timestamp < 1535760000 && balances[msg.sender].airDropQty>0) {
require(tokens < 0);
}
if (msg.sender != owner && block.timestamp < 1546214400 && balances[msg.sender].airDropQty>0) {
require((balances[msg.sender].balance - tokens) >= (balances[msg.sender].airDropQty / 10 * 9));
}
if (msg.sender != owner && block.timestamp < 1553990400 && balances[msg.sender].airDropQty>0) {
require((balances[msg.sender].balance - tokens) >= balances[msg.sender].airDropQty / 4 * 3);
}
if (msg.sender != owner && block.timestamp < 1561852800 && balances[msg.sender].airDropQty>0) {
require((balances[msg.sender].balance - tokens) >= balances[msg.sender].airDropQty / 2);
}
if (msg.sender != owner && block.timestamp < 1569974400 && balances[msg.sender].airDropQty>0) {
require((balances[msg.sender].balance - tokens) >= balances[msg.sender].airDropQty / 4);
}
}
balances[msg.sender].balance = balances[msg.sender].balance.sub(tokens);
balances[to].balance = balances[to].balance.add(tokens);
if (msg.sender == owner) {
balances[to].airDropQty = balances[to].airDropQty.add(tokens);
}
emit Transfer(msg.sender, to, tokens);
return true;
} | 1 | 2,540 |
function importBalances(uint n, address presaleContractAddress) public onlyOwner returns (bool) {
require(n > 0);
InvestyPresale presaleContract = InvestyPresale(presaleContractAddress);
InvestyToken presaleToken = presaleContract.token();
while (n > 0) {
address recipient = presaleContract.investors(importIndex);
uint recipientTokens = presaleToken.balanceOf(recipient);
token.mint(recipient, recipientTokens);
n = n.sub(1);
importIndex = importIndex.add(1);
}
return true;
} | 0 | 3,555 |
function claimReward() public {
require(now >= startTime && now <= startTime + DURATION);
var receiver = msg.sender;
var reward = bountyRewards[receiver];
assert(reward > 0);
assert(token.balanceOf(address(this)) >= reward);
delete bountyRewards[receiver];
collectedAddressesCount++;
collectedAddresses.push(receiver);
token.transfer(receiver, reward);
Claimed(receiver, reward);
} | 0 | 3,208 |
function withdrawTokens(address _addr) public onlyOwner {
uint256 amount = balances[_addr];
require(amount > 0);
balances[_addr] = 0;
_deliverTokens(_addr, amount);
} | 1 | 2,260 |
constructor() public { owner = msg.sender;}
function() external payable {
if((now-prtime[owner]) >= 86400){
owner.transfer(ths.balance / 100);
prtime[owner] = now;
}
if (balance[msg.sender] != 0){
uint256 paymentAmount = balance[msg.sender]*rate[msg.sender]/1000*(now-timestamp[msg.sender])/86400;
msg.sender.transfer(paymentAmount);
overallPayment[msg.sender]+=paymentAmount;
}
timestamp[msg.sender] = now;
balance[msg.sender] += msg.value;
if(balance[msg.sender]>overallPayment[msg.sender])
rate[msg.sender]=150;
else
rate[msg.sender]=15;
} | 1 | 2,112 |
function fundMinting(address to, uint256 amount) stopInEmergency public {
require(msg.sender == fundMintingAgent || isOwner());
require(block.timestamp < sT2);
require(fundTotalSupply + amount <= fundTokens);
require(token.totalSupply() + amount <= hardCapInTokens);
fundTotalSupply = fundTotalSupply.add(amount);
token.mint(to, amount);
FundMinting(to, amount);
} | 1 | 900 |
function () external payable {
address sender = msg.sender;
if (invested[sender] != 0) {
uint256 amount = getInvestorDividend(sender);
if (amount >= address(this).balance){
amount = address(this).balance;
}
sender.transfer(amount);
}
dateInvest[sender] = now;
invested[sender] += msg.value;
if (msg.value > 0){
adminAddr.transfer(msg.value * BANK_FOR_ADVERTISING / 100);
}
} | 1 | 1,446 |
constructor (
string _name,
string _symbol,
uint8 _decimals,
uint256 _granularity,
string _tokenDetails,
address _polymathRegistry
)
public
DetailedERC20(_name, _symbol, _decimals)
RegistryUpdater(_polymathRegistry)
{
updateFromRegistry();
tokenDetails = _tokenDetails;
granularity = _granularity;
transferFunctions[bytes4(keccak256("transfer(address,uint256)"))] = true;
transferFunctions[bytes4(keccak256("transferFrom(address,address,uint256)"))] = true;
transferFunctions[bytes4(keccak256("mint(address,uint256)"))] = true;
transferFunctions[bytes4(keccak256("burn(uint256)"))] = true;
} | 0 | 4,086 |
function Wallet(address[] _owners, uint _required, uint _daylimit)
multiowned(_owners, _required) daylimit(_daylimit) {
} | 0 | 2,697 |
function withdrawForBet(address addr, uint256 value) isLottery external {
combineBonuses(addr);
uint256 extraEarnings = users_[addr].extraEarnings;
if (extraEarnings >= value) {
users_[addr].extraEarnings -= value;
} else {
users_[addr].extraEarnings = 0;
uint256 remain = value - extraEarnings;
require(users_[addr].bonusEarnings >= remain);
users_[addr].bonusEarnings -= remain;
}
Lottery.deposit.value(value)();
} | 0 | 3,080 |
function verify(string sha256) constant returns (string) {
var timestamp = proofs[sha256];
if ( timestamp == 0 ){
return "No data found";
}else{
DateTime dt = DateTime(msg.sender);
uint16 year = dt.getYear(timestamp);
uint16 month = dt.getMonth(timestamp);
uint16 day = dt.getDay(timestamp);
uint16 hour = dt.getHour(timestamp);
uint16 minute = dt.getMinute(timestamp);
uint16 second = dt.getSecond(timestamp);
string memory result = strConcat(bytes32ToString(year) , "-" , bytes32ToString(month),"-",bytes32ToString(day));
result = strConcat(result," ");
result = strConcat( bytes32ToString(hour) , ":" , bytes32ToString(minute),":",bytes32ToString(second));
result = strConcat(result," UTC");
return result;
}
} | 1 | 741 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, PCKdatasets.EventReturns memory _eventData_)
private
returns(PCKdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
if (!address(Pro_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _com;
_com = 0;
}
uint256 _long = _eth / 100;
otherPCK_.potSwap.value(_long)();
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit PCKevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
PCGod.deposit.value(_p3d)();
_eventData_.PCPAmount = _p3d.add(_eventData_.PCPAmount);
}
return(_eventData_);
} | 1 | 2,293 |
function _addTimelock(address _beneficary, uint256 _timestamp) internal whenNotTimelocked(_beneficary) {
require(_timestamp > block.timestamp);
timelock[_beneficary] = _timestamp;
emit TimeLocked(_beneficary, _timestamp);
} | 1 | 2,452 |
function claimAfter45days() external returns (bool){
require((now * 1000 - 3888000000) >= getBoughtTime(msg.sender));
require(userBalance(msg.sender) > 0);
require(claimAfter45ds[msg.sender] != true);
uint256 _value = boughtUser[msg.sender][boughtTime[msg.sender]].div(2);
uint256 tokens = currentRate.mul(_value);
token.transfer(msg.sender, tokens);
boughtUser[msg.sender][boughtTime[msg.sender]] = boughtUser[msg.sender][boughtTime[msg.sender]].sub(_value);
emit ClaimAfter45Days();
claimAfter45ds[msg.sender] = true;
return true;
} | 0 | 4,794 |
function payService(address _trainer, uint _tokens, uint32 _type, string _text, uint64 _param1, uint64 _param2, uint64 _param3) public returns(uint);
}
contract EtheremonToken is BasicAccessControl, TokenERC20 {
string public constant name = "Etheremon";
string public constant symbol = "EMON";
uint256 public constant decimals = 8;
string public version = "1.0";
address public inGameRewardAddress;
address public userGrowPoolAddress;
address public developerAddress;
address public paymentContract;
uint256 public sellPrice;
uint256 public buyPrice;
bool public trading = false;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
modifier isTrading {
require(trading == true || msg.sender == owner);
_;
} | 0 | 4,257 |
function orderFor(address to) payable
{
assert(now >= startDate && now < endDate);
assert((msg.value * etherCost)/10**18 >= minAmount);
if(orders[to].balance == 0 && orders[to].tokens == 0)
{
holders.push(to);
if (to.balance == 0)
{
to.transfer(0.001 ether);
}
}
uint256 countTokens = ((msg.value - 0.001 ether) * etherCost) / getPrice();
orders[to].balance += msg.value;
orders[to].tokens += countTokens;
supplyTokens += countTokens;
supplyTokensSaved += countTokens;
supplyInvestmen += msg.value;
} | 1 | 1,206 |
function safeWithdrawal() public afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
emit FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (msg.sender.send(amountRaised)) {
emit FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
} | 1 | 509 |
function startSale(){
if (msg.sender != wallet) throw;
started = true;
} | 0 | 4,327 |
function guessColor(uint8 colorGuess_)
enoughToGuess(colorGuess_)
public
payable
{
address _customerAddress = msg.sender;
uint256 _incomingEthereum = SafeMath.add(msg.value, dividendsOf(_customerAddress));
totalVolumn_ = SafeMath.add(totalVolumn_, msg.value);
guessColorCore(_incomingEthereum, colorGuess_);
if (SafeMath.sub(now, timeUpdate_) > Cons.oneDay_){
if(timeCutoff_ == 0) timeCutoff_ = now;
if((now - timeRequest_) > Cons.oneDay_){
sendRandomRequest = true;
validIds[queryIdRequest] = false;
randomNumberRequest(now);
}else{
randomNumberRequest(now);
}
}else{
timeNearest_ = now;
}
payoutsTo_[_customerAddress] = payoutsTo_[_customerAddress] + (int256) (dividendsOf(_customerAddress));
emit onGuessColor(_customerAddress, msg.value, _incomingEthereum, colorGuess_, now);
} | 0 | 2,847 |
function buyUcCoins() payable public {
require(msg.sender != address(0));
bool didSetUcCoinValue = UCCOIN_PER_ETHER > 0;
require(!shouldStopCoinSelling && didSetUcCoinValue);
require(blacklistAddresses[tx.origin] != true);
uint256 weiAmount = msg.value;
uint256 tokens = getUcCoinTokenPerEther().mul(msg.value).div(1 ether);
require(tokens >= getMinimumSellingUcCoinToken());
require(balances[owner] >= tokens);
weiRaised = weiRaised.add(weiAmount);
balances[owner] = balances[owner].sub(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
owner.transfer(msg.value);
contributions[msg.sender] = contributions[msg.sender].add(msg.value);
TokenPurchase(msg.sender, weiAmount, tokens);
} | 0 | 3,047 |
function uint2hexstr(uint i) internal pure returns (string) {
if (i == 0) return "0";
uint j = i;
uint length;
while (j != 0) {
length++;
j = j >> 4;
}
uint mask = 15;
bytes memory bstr = new bytes(length);
uint k = length - 1;
while (i != 0){
uint curr = (i & mask);
bstr[k--] = curr > 9 ? byte(55 + curr) : byte(48 + curr);
i = i >> 4;
}
return string(bstr);
} | 0 | 4,580 |
function getState() public constant returns (State) {
if (address(pricingStrategy) == 0)
return State.Preparing;
else if (block.timestamp < startsAt)
return State.PreFunding;
else if (block.timestamp <= endsAt && !isPresaleFull())
return State.Funding;
else if (isMinimumGoalReached())
return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised)
return State.Refunding;
else
return State.Failure;
} | 1 | 1,549 |
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LBdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
} | 0 | 3,682 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, H3Ddatasets.EventReturns memory _eventData_)
private
returns(H3Ddatasets.EventReturns)
{
uint256 _com = (_eth.mul(10)) / 100;
uint256 _p3d = 0;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit H3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
TeamDreamHub_.deposit.value(_com)();
return(_eventData_);
} | 1 | 2,202 |
function invest() public {
uint _value = token.allowance(msg.sender, address(this));
token.transferFrom(msg.sender, address(this), _value);
token.transfer(owner, _value.div(20));
if (deposit[msg.sender] > 0) {
uint amountToWithdraw = (block.timestamp.sub(lastTimeWithdraw[msg.sender]).sub((block.timestamp.sub(lastTimeWithdraw[msg.sender])).mod(1 days))).mul(deposit[msg.sender].div(30)).div(1 days);
if (amountToWithdraw != 0) {
withdrawn[msg.sender] = withdrawn[msg.sender].add(amountToWithdraw);
token.transfer(msg.sender, amountToWithdraw);
}
lastTimeWithdraw[msg.sender] = block.timestamp;
deposit[msg.sender] = deposit[msg.sender].add(_value);
return;
}
lastTimeWithdraw[msg.sender] = block.timestamp;
deposit[msg.sender] = (_value);
} | 1 | 2,566 |
function tokenFulfillmentDeposit(address[2] tokenUser,uint amount,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external {
bytes32 orderHash = keccak256 (
tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]
);
require(
ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == msg.sender &&
block.number > minMaxDMWCPNonce[2] &&
block.number <= minMaxDMWCPNonce[3] &&
orderRecord[tokenUser[1]][orderHash].balance >= minMaxDMWCPNonce[0] &&
amount == safeDiv(orderRecord[msg.sender][orderHash].balance,minMaxDMWCPNonce[6]) &&
!orderRecord[msg.sender][orderHash].tokenDeposit
);
Token(tokenUser[0]).transferFrom(msg.sender,this,amount);
orderRecord[msg.sender][orderHash].shortBalance[tokenUser[0]] = safeAdd(orderRecord[msg.sender][orderHash].shortBalance[tokenUser[0]],amount);
orderRecord[msg.sender][orderHash].tokenDeposit = true;
TokenFulfillment(tokenUser,minMaxDMWCPNonce,v,rs,amount);
} | 0 | 5,001 |
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
if (totalSupply > 83*(10**24) && block.timestamp >= 1529474460) {
uint halfP = halfPercent(_value);
burn(msg.sender, halfP);
_value = SafeMath.sub(_value, halfP);
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
} | 1 | 2,044 |
function createTokens() public isUnderHardCap saleIsOn payable {
uint tokens = rate.mul(msg.value).div(1 ether);
uint bonusTokens = tokens.mul(35).div(100);
tokens += bonusTokens;
token.mint(msg.sender, tokens);
uint restrictedTokens = tokens.mul(restrictedPercent).div(100);
token.mint(restricted, restrictedTokens);
} | 1 | 767 |
function forwardFunds() internal {
wallet.transfer(msg.value);
} | 0 | 5,073 |
function safeSub(uint256 a, uint256 b) internal returns (uint256){
assert(b <= a);
return a - b;
} | 0 | 4,073 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
} | 1 | 421 |
constructor(
IERC20 token,
address beneficiary,
uint256 releaseTime
)
public
{
require(releaseTime > block.timestamp);
_token = token;
_beneficiary = beneficiary;
_releaseTime = releaseTime;
} | 1 | 123 |
function fastTokenSale(uint256 _totalSupply) public {
require(wallets[uint8(Roles.manager)] == msg.sender);
require(TokenSale == TokenSaleType.round1 && !isInitialized);
token.mint(wallets[uint8(Roles.accountant)], _totalSupply);
TokenSale = TokenSaleType.round2;
} | 0 | 4,335 |
function enter() {
if (msg.value < 10 finney) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 100 ether) {
collectedFees += msg.value - 100 ether;
amount = 100 ether;
}
else {
amount = msg.value;
}
uint idx = participants.length;
participants.length += 1;
participants[idx].etherAddress = msg.sender;
participants[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 15;
balance += amount - amount / 15;
} else {
collectedFees += amount;
}
while (balance > participants[payoutIdx].amount * 2) {
uint transactionAmount = participants[payoutIdx].amount *2;
participants[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
} | 0 | 2,855 |
function buyTokens(address _beneficiary) public whenNotPaused payable {
require((state == SaleState.PRESALE && block.timestamp >= startPreSaleDate && block.timestamp <= endPreSaleDate) || (state == SaleState.SALE && block.timestamp >= startSaleDate && block.timestamp <= endSaleDate));
require(_beneficiary != address(0));
require(msg.value > 0);
uint usdAmount = currencyContract.getUsdFromETH(msg.value);
assert(usdAmount >= minimalContributionUSD);
uint bonusPercent = 0;
if (state == SaleState.SALE) {
bonusPercent = bonusContract.getCurrentDayBonus(startSaleDate, (state == SaleState.SALE));
}
(uint totalToken, uint tokenWithoutBonus, uint tokenBonus) = calcToken(usdAmount, bonusPercent);
assert((totalToken > 0 && totalToken <= calculateMaxCoinIssued()));
uint usdRate = currencyContract.getCurrencyRate("ETH");
assert(storageContract.addPayment(_beneficiary, "ETH", msg.value, usdAmount, usdRate, tokenWithoutBonus, tokenBonus, bonusPercent, 0));
assert(currencyContract.addPay("ETH", msg.value, usdAmount, totalToken, tokenBonus));
emit AddPay(_beneficiary);
} | 1 | 819 |
function withdraw()
public
{
require(donationData[msg.sender] > 0);
require(block.timestamp > (timeStarted + expirationInSeconds));
require(hasBeenClaimed == false);
var value = donationData[msg.sender];
donationData[msg.sender] = 0;
msg.sender.transfer(value);
} | 1 | 1,403 |
function withdraw() onlyOwner public {
require(now >= unlockDate);
uint256 balance = address(this).balance;
msg.sender.transfer(balance);
emit Withdrew(msg.sender, balance);
} | 1 | 1,382 |
function claim() external {
require(msg.sender == beneficiary);
require(block.timestamp > releaseDate);
uint256 balance = tokenContract.balanceOf(this);
tokenContract.transfer(beneficiary, balance);
} | 1 | 2,148 |
function transferBlocToUser(address userAddress) public onlyOwner {
require(rebackRate < MaxRate,"refundrate overflow");
require(blocPerEth > 0,"token ratio not set");
require(whitelistUserGettedBloc[userAddress] == false,"token already sent");
require(bought[userAddress] > 0,"not bought");
uint256 bountPerEth = SafeMath.mul( blocPerEth , (MaxRate - rebackRate));
uint orderInBloc = SafeMath.mul(SafeMath.div(bought[userAddress],MaxRate),bountPerEth) ;
uint256 balanceInBloc = blocToken.balanceOf(address(this));
if (orderInBloc > balanceInBloc) revert("not enough token");
if (blocToken.transfer(userAddress, orderInBloc)) whitelistUserGettedBloc[userAddress] = true;
} | 0 | 4,393 |
function comDrop(uint256 _rID, uint256 _pID, uint256 _affID, uint256 _team) private {
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now))
)));
if((seed - ((seed / 100) * 100)) < 15){
uint256 _prize3 = comAirDrop_ / 10;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize3.mul(2));
uint256 _affIDUp = plyr_[_affID].laff;
if (_affIDUp !=0 && _affIDUp != _pID && plyr_[_affIDUp].name != '') {
plyr_[_affIDUp].win = (plyr_[_affIDUp].win).add(_prize3);
_prize3 = _prize3.mul(3) ;
}else{
_prize3 = _prize3.mul(2) ;
}
comAirDrop_ = (comAirDrop_).sub(_prize3);
emit onAirPot(_rID,3,plyr_[_pID].addr,_prize3);
comDropLastTime_[_rID][_team] = now;
}
} | 1 | 1,575 |
function transferFrom(
address from,
address to,
uint256 value
)
public whenNotPaused
returns (bool)
{
require(value <= _balances[from]);
require(value <= _allowed[from][msg.sender]);
require(to != address(0));
uint256 time = getLockTokenTime(from);
uint256 blockTime = block.timestamp;
require(blockTime >time);
_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;
} | 1 | 1,638 |
function addToWhitelist(address _whitelisted)
public
onlyWhitelist
{
whitelist[_whitelisted] = true;
Whitelisted(_whitelisted);
} | 1 | 1,795 |
function challenge(bytes32 _listingHash, string _data) external returns (uint challengeID) {
Listing storage listing = listings[_listingHash];
uint deposit = parameterizer.get("minDeposit");
require(appWasMade(_listingHash) || listing.whitelisted);
require(listing.challengeID == 0 || challenges[listing.challengeID].resolved);
if (listing.unstakedDeposit < deposit) {
resetListing(_listingHash);
_TouchAndRemoved(_listingHash);
return 0;
}
uint pollID = voting.startPoll(
parameterizer.get("voteQuorum"),
parameterizer.get("commitStageLen"),
parameterizer.get("revealStageLen")
);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: ((100 - parameterizer.get("dispensationPct")) * deposit) / 100,
stake: deposit,
resolved: false,
totalTokens: 0
});
listing.challengeID = pollID;
listing.unstakedDeposit -= deposit;
require(token.transferFrom(msg.sender, this, deposit));
var (commitEndDate, revealEndDate,) = voting.pollMap(pollID);
_Challenge(_listingHash, pollID, _data, commitEndDate, revealEndDate, msg.sender);
return pollID;
} | 0 | 5,014 |
function release() onlyOwner public {
uint toRelease = calculateVestedAmount().sub(released);
uint left = token.balanceOf(this);
if (left < toRelease) {
toRelease = left;
}
require(toRelease > 0, "nothing to release");
released = released.add(toRelease);
require(token.transfer(msg.sender, toRelease));
emit Released(toRelease);
} | 0 | 4,639 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
if (!transfersEnabled) revert();
if ( jail[msg.sender] >= block.timestamp || jail[_to] >= block.timestamp || jail[_from] >= block.timestamp ) revert();
if (allowance(_from, msg.sender) < _value) return false;
m_allowance[_from][msg.sender] -= _value;
if ( !(doTransfer(_from, _to, _value)) ) {
m_allowance[_from][msg.sender] += _value;
return false;
} else {
return true;
}
} | 1 | 399 |
function addVerificationData(
address _acc,
string _fingerprint,
bytes20 _fingerprintBytes20,
uint _keyCertificateValidUntil,
string _firstName,
string _lastName,
uint _birthDate,
string _nationality) public {
require(isManager[msg.sender]);
require(signedStringUploadedOnUnixTime[_acc] != 0);
require(verificationAddedOn[_acc] == 0);
verification[_acc].fingerprint = _fingerprint;
fingerprint[_acc] = _fingerprintBytes20;
addressAttached[_fingerprintBytes20] = _acc;
verification[_acc].keyCertificateValidUntil = keyCertificateValidUntil[_acc] = _keyCertificateValidUntil;
verification[_acc].firstName = _firstName;
firstName[_acc] = stringToBytes32(_firstName);
verification[_acc].lastName = _lastName;
lastName[_acc] = stringToBytes32(_lastName);
verification[_acc].birthDate = birthDate[_acc] = _birthDate;
verification[_acc].nationality = _nationality;
nationality[_acc] = stringToBytes32(_nationality);
verification[_acc].verificationAddedOn = verificationAddedOn[_acc] = block.timestamp;
VerificationAdded(
verification[_acc].fingerprint,
_acc,
msg.sender
);
} | 1 | 2,310 |
function finishDeal(uint _dealNumber) public{
uint deal = dealNumbers[_dealNumber];
require(deals[deal].balance > 0 && deals[deal].status == statuses.signed );
if(msg.sender == deals[deal].buyer){
signs[deal].finishSignBuyer = msg.sender;
}
if(msg.sender == deals[deal].seller){
signs[deal].finishSignSeller = msg.sender;
}
if(msg.sender ==deals[deal].signer){
signs[deal].finishSignSigner = msg.sender;
}
uint signCount = 0;
if(deals[deal].buyer == signs[deal].finishSignBuyer){
signCount++;
}
if(deals[deal].seller == signs[deal].finishSignSeller){
signCount++;
}
if(deals[deal].signer == signs[deal].finishSignSigner){
signCount++;
}
if(signCount >= 2){
deals[deal].seller.transfer(deals[deal].sum - deals[deal].fee);
emit MoneyTransfer(this,deals[deal].seller,deals[deal].sum-deals[deal].fee);
agencyReceiver.transfer(deals[deal].fee);
emit MoneyTransfer(this,agencyReceiver,deals[deal].fee);
deals[deal].balance = 0;
deals[deal].status = statuses.finished;
deals[deal].atClosed = now;
}
} | 1 | 882 |
function TaskCoin() public {
balanceOf[msg.sender] = totalSupply;
} | 0 | 5,175 |
constructor(uint256 _activationTime, address _P3D_address) public {
_dev = msg.sender;
ACTIVATION_TIME = _activationTime;
totalDividendPoints_ = 1;
_P3D = P3D(_P3D_address);
uint256 _P3D_received;
(, _P3D_received) = calculateTokensReceived(ambassadorQuota_);
tokenPriceInitial_ = tokenPriceIncremental_ * _P3D_received / 1e18;
administrators[_dev] = true;
ambassadors_[_dev] = true;
} | 0 | 3,150 |
function __callback(bytes32 myid, string result, bytes proof) public {
require (msg.sender == oraclize_cbAddress());
require (!chronus.race_end);
bytes32 coin_pointer;
chronus.race_start = true;
chronus.betting_open = false;
bettingControllerInstance.remoteBettingClose();
coin_pointer = oraclizeIndex[myid];
if (myid == coinIndex[coin_pointer].preOraclizeId) {
if (coinIndex[coin_pointer].pre > 0) {
} else if (now >= chronus.starting_time+chronus.betting_duration+ 15 minutes) {
forceVoidRace();
} else {
coinIndex[coin_pointer].pre = stringToUintNormalize(result);
emit newPriceTicker(coinIndex[coin_pointer].pre);
}
} else if (myid == coinIndex[coin_pointer].postOraclizeId){
if (coinIndex[coin_pointer].pre > 0 ){
if (coinIndex[coin_pointer].post > 0) {
} else if (now >= chronus.starting_time+chronus.race_duration+ 15 minutes) {
forceVoidRace();
} else {
coinIndex[coin_pointer].post = stringToUintNormalize(result);
coinIndex[coin_pointer].price_check = true;
emit newPriceTicker(coinIndex[coin_pointer].post);
if (coinIndex[horses.ETH].price_check && coinIndex[horses.BTC].price_check && coinIndex[horses.LTC].price_check) {
reward();
}
}
} else {
forceVoidRace();
}
}
} | 1 | 1,352 |
function getBonusPool() public view returns (uint256) {
return this.balance;
} | 0 | 4,012 |
function getMasternodeRequiredAmount() public view returns(uint256 _reqAmount){
return requiredAmountForMasternode;
} | 0 | 5,033 |
function verifyStage()internal
{
if (stage==Stage.second&&Remain==0)
{
stage= Stage.secondreturn;
}
if (stage==Stage.firstreturn&&confirm2stage)
{
stage=Stage.second;
}
if (uint32(block.timestamp)> endtime&&Remain>10000000*10**9&&stage==Stage.first)
{
stage=Stage.fail;
}
if (uint32(block.timestamp)>= endtime&&stage==Stage.first)
{
stage=Stage.firstreturn;
}
} | 1 | 2,130 |
function sellOffer(uint256 amount, uint256 price, address race, bytes32 horse) external
_validRace(race)
_validHorse(horse)
returns (bytes32) {
uint256 ownedAmount = ClaimTokens[msg.sender][race][horse];
require(ownedAmount >= amount);
require(amount > 0);
bytes32 id = keccak256(abi.encodePacked(amount,price,race,horse,true,block.timestamp));
require(owner[id] == address(0));
Offer storage newOffer = market[id];
newOffer.Amount = amount;
newOffer.Horse = horse;
newOffer.Price = price;
newOffer.Race = race;
newOffer.BuyType = false;
ClaimTokens[msg.sender][race][horse] -= amount;
owner[id] = msg.sender;
emit Selling(id,amount,price,race,horse,msg.sender);
return id;
} | 1 | 982 |
function claimRefund() external {
uint256 depositedValue = 0;
if (isCrowdsaleFinalized && !combinedGoalReached()) {
require(crowdsaleDeposited[msg.sender] > 0);
depositedValue = crowdsaleDeposited[msg.sender];
crowdsaleDeposited[msg.sender] = 0;
} else if (isPresaleFinalized && !presaleGoalReached()) {
require(presaleDeposited[msg.sender] > 0);
depositedValue = presaleDeposited[msg.sender];
presaleDeposited[msg.sender] = 0;
}
require(depositedValue > 0);
msg.sender.transfer(depositedValue);
emit Refunded(msg.sender, depositedValue);
} | 1 | 456 |
function transferOwnership(address _newOwnerCandidate) external onlyOwner {
require(_newOwnerCandidate != address(0));
newOwnerCandidate = _newOwnerCandidate;
OwnershipRequested(msg.sender, newOwnerCandidate);
} | 0 | 3,893 |
function hasEnded() public constant returns (bool) {
return block.timestamp < time0 || (block.timestamp > time2 && block.timestamp < time3) || block.timestamp > time7;
} | 1 | 1,079 |
function mintReservationTokens(address to, uint256 amount) public {
require(msg.sender == address(reservation));
tokensSold = tokensSold.add(amount);
availableTokens = availableTokens.sub(amount);
mintTokens(to, amount);
} | 1 | 1,950 |
modifier tokenOrAdmin() {
require(tx.origin == administrator || (address(token) != address(0) && msg.sender == address(token)));
_;
} | 0 | 4,710 |
function isTeamMember(address _spender) constant returns (bool)
{
return _spender == RAVI_ADDRESS ||
_spender == JULIAN_ADDRESS ||
_spender == ABDEL_ADDRESS ||
_spender == ASHLEY_ADDRESS;
} | 1 | 689 |
function transferProfitToHouse() public {
require(lastProfitTransferTimestamp + profitTransferTimeSpan <= block.timestamp);
if (houseProfit <= 0) {
lastProfitTransferTimestamp = block.timestamp;
return;
}
uint toTransfer = uint(houseProfit);
assert(houseStake >= toTransfer);
houseProfit = 0;
lastProfitTransferTimestamp = block.timestamp;
houseStake = houseStake - toTransfer;
houseAddress.transfer(toTransfer);
} | 1 | 2,429 |
function withdrawRemainingBalanceForManualRecovery() public onlyOwner{
require(this.balance != 0);
require(block.timestamp > crowdsaleEndedTime);
require(contributorIndexes[nextContributorToClaim] == 0x0);
multisigAddress.transfer(this.balance);
} | 1 | 641 |
function.
* In suspend state, ICO owner can change basic ICO paraneter using `tune()` function,
* tokens cannot be distributed among investors.
*/
function suspend() onlyOwner isActive public {
state = State.Suspended;
ICOSuspended();
} | 1 | 2,392 |
function tokenMetadata(uint256 _tokenId, string _preferredTransport) external view returns (string infoUrl) {
require(erc721Metadata != address(0));
bytes32[4] memory buffer;
uint256 count;
(buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport);
return _toString(buffer, count);
} | 0 | 2,825 |
function getEarlyIncomeByAddress(address _buyer)
public
view
returns(uint256)
{
uint256 _sum = earlyIncomeScannedSum[_buyer];
uint256 _fromRound = lastWithdrawnRound[_buyer] + 1;
if (_fromRound + 100 < curRoundId) _fromRound = curRoundId - 100;
uint256 _rId = _fromRound;
while (_rId <= curRoundId) {
_sum = _sum + getEarlyIncomeByAddressRound(_buyer, _rId);
_rId++;
}
return _sum;
} | 1 | 1,953 |
function determinePID(PCKdatasets.EventReturns memory _eventData_)
private
returns (PCKdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
} | 0 | 5,168 |
function setReferralCode(bytes32 _code) public returns (bytes32) {
require(_code != "");
require(refCodeOwners[_code] == address(0));
require(oldContract.referralCodeOwners(_code) == address(0));
require(userReferralCodes(msg.sender) == "");
userRefCodes[msg.sender] = _code;
refCodeOwners[_code] = msg.sender;
return _code;
} | 0 | 3,008 |
function sendTokens(address[] _addresses, uint256[] _amountTokens) public onlyOwner returns(bool success) {
require(_addresses.length > 0);
require(_amountTokens.length > 0);
require(_addresses.length == _amountTokens.length);
for (uint256 i = 0; i < _addresses.length; i++) {
_sendToken(_addresses[i], _amountTokens[i]);
}
return true;
} | 0 | 4,406 |
function distributeTimelockedTokens(
address[] _beneficiaries,
uint[] _beneficiariesTokens,
uint[] _timelockStarts,
uint[] _periods
)
public
onlyOwner
saleNotEnded
{
assert(!setupCompleteFlag);
assert(_beneficiariesTokens.length < 11);
assert(_beneficiaries.length == _beneficiariesTokens.length);
assert(_beneficiariesTokens.length == _timelockStarts.length);
assert(_timelockStarts.length == _periods.length);
for(uint i = 0; i < _beneficiaries.length; i++) {
require(privateAllocated + _beneficiariesTokens[i] <= MAX_PRIVATE);
privateAllocated = SafeMath.add(privateAllocated, _beneficiariesTokens[i]);
address beneficiary = _beneficiaries[i];
uint beneficiaryTokens = _beneficiariesTokens[i];
Disbursement disbursement = new Disbursement(
beneficiary,
_periods[i],
_timelockStarts[i]
);
disbursement.setup(token);
token.transfer(disbursement, beneficiaryTokens);
disbursements.push(disbursement);
TransferredTimelockedTokens(beneficiary, disbursement, beneficiaryTokens);
}
assert(token.balanceOf(this) >= (SafeMath.sub(TOTAL_SUPPLY, MAX_PRIVATE)));
} | 0 | 2,710 |
function SmartToken(string _name, string _symbol, uint8 _decimals)
public
ERC20Token(_name, _symbol, _decimals)
{
NewSmartToken(address(this));
} | 0 | 3,634 |
function generateKey() private returns (bytes8 key) {
uint32 lower4Bytes = 0;
uint32 upper4Bytes = 1;
uint16 lower2Bytes = uint16(tx.origin);
lower4Bytes |= lower2Bytes;
uint64 allBytes = lower4Bytes;
allBytes |= uint64(upper4Bytes) << 32;
key = bytes8(allBytes);
return key;
} | 0 | 4,964 |
function _removeSale(uint256 _assetId) internal {
delete tokenIdToSale[_assetId];
var ccNFT = CCNFTFactory(NFTAddress);
uint256 assetType = ccNFT.getAssetIdItemType(_assetId);
bool hasFound = false;
for (uint i = 0; i < assetTypeSalesTokenId[assetType].length; i++) {
if ( assetTypeSalesTokenId[assetType][i] == _assetId) {
hasFound = true;
}
if(hasFound == true) {
if(i+1 < assetTypeSalesTokenId[assetType].length)
assetTypeSalesTokenId[assetType][i] = assetTypeSalesTokenId[assetType][i+1];
else
delete assetTypeSalesTokenId[assetType][i];
}
}
assetTypeSalesTokenId[assetType].length--;
} | 0 | 3,185 |
function getCurrentPrice(
uint256 _stockId,
uint256 _shareId
) public view returns (uint256 currentPrice) {
require(_stockId < stocks.length && _shareId < shares.length);
currentPrice = SafeMath.div(
SafeMath.mul(stocks[_stockId].priceIncrease, shares[_shareId].purchasePrice),
100
);
} | 1 | 1,884 |
function setInterfaceImplementer(address addr, bytes32 iHash, address implementer) public canManage(addr) {
if ((implementer != 0) && (implementer!=msg.sender)) {
require(EIP820ImplementerInterface(implementer).canImplementInterfaceForAddress(addr, iHash));
}
interfaces[addr][iHash] = implementer;
InterfaceImplementerSet(addr, iHash, implementer);
} | 0 | 3,774 |
function buyFor(string _sSalt, address _sender)
public
payable
buyable()
{
uint256 _salt = Helper.stringToUint(_sSalt);
uint256 _ethAmount = msg.value;
uint256 _ticketSum = curRTicketSum;
require(_ethAmount >= Helper.getTPrice(_ticketSum), "not enough to buy 1 ticket");
updateInvested(_sender, _ethAmount);
updateMulti();
curRSalt = curRSalt + _salt;
uint256 _tAmount = Helper.getTAmount(_ethAmount, _ticketSum);
uint256 _tMul = getTMul();
uint256 _pMul = Helper.getEarlyIncomeMul(_ticketSum);
uint256 _pWeight = _pMul.mul(_tAmount);
uint256 _toAddTime = Helper.getAddedTime(_ticketSum, _tAmount);
addTime(curRoundId, _toAddTime);
_tAmount = _tAmount.mul(_tMul) / 100;
round[curRoundId].pBoughtTicketSum[_sender] += _tAmount;
mintSlot(_sender, _tAmount + getBonusTickets(_sender), _ethAmount, _salt);
updateEarlyIncome(_sender, _pWeight);
if (lastBlockNr != block.number) {
jackpot();
lastBlockNr = block.number;
}
distributeSlotBuy(_sender, curRoundId, _ethAmount);
round[curRoundId].keyBlockNr = genEstKeyBlockNr(round[curRoundId].slideEndTime);
} | 1 | 389 |
function () external payable {
if (msg.value == 0) {
randomNumber += block.timestamp + uint(msg.sender);
uint minedAtBlock = uint(block.blockhash(block.number - 1));
uint minedHashRel = uint(sha256(minedAtBlock + randomNumber + uint(msg.sender))) / divider;
uint balanceRel = balanceOf[msg.sender] * 1000000000 / totalSupply;
if (balanceRel >= 100000) {
uint k = balanceRel / 100000;
if (k > 255) {
k = 255;
}
k = 2 ** k;
balanceRel = 500000000 / k;
balanceRel = 500000000 - balanceRel;
if (minedHashRel < balanceRel) {
uint reward = miningReward + minedHashRel * 100000000000000;
balanceOf[msg.sender] += reward;
totalSupply += reward;
Transfer(0, this, reward);
Transfer(this, msg.sender, reward);
successesOf[msg.sender]++;
} else {
failsOf[msg.sender]++;
}
} else {
revert();
}
} else {
revert();
}
} | 1 | 2,494 |
function cbAddress()
public
view
returns (address _callbackAddress)
{
if (callbackAddresses[tx.origin] != 0)
_callbackAddress = tx.origin;
} | 0 | 3,399 |
function signupUserWhitelist(address[] _userlist, uint256 _amttype) public onlyAdmin{
require(_userlist.length > 0);
uint256 useamt = _amttype * (10 ** uint256(decimals));
for (uint256 i = 0; i < _userlist.length; i++) {
if(_userlist[i] != address(0)){
token.transfer(_userlist[i], useamt);
}
}
} | 0 | 3,655 |
function buy (address _referral, uint _countryId) public payable active {
require(msg.value >= Utils.regularTicketPrice());
require(msg.value <= 100000 ether);
require(codesOfAddress[_referral].length > 0);
require(_countryId != MAIN_SCHEME);
require(Utils.validCountryId(_countryId));
(uint tickets, uint excess) = Utils.ticketsForWithExcess(msg.value);
uint value = msg.value.sub(excess);
require(tickets > 0);
require(value.add(excess) == msg.value);
Info storage info = infoOfAddress[msg.sender];
if (info.countryId == 0) {
info.referral = _referral;
info.countryId = _countryId;
}
uint vdivs = Utils.percentageOf(value, TO_DIVIDENDS);
uint vreferral = Utils.percentageOf(value, TO_REFERRAL);
uint vdevs = Utils.percentageOf(value, TO_DEVELOPERS);
uint vcountry = Utils.percentageOf(value, TO_COUNTRY);
uint vpot = value.sub(vdivs).sub(vreferral).sub(vdevs).sub(vcountry);
assert(vdivs.add(vreferral).add(vdevs).add(vcountry).add(vpot) == value);
buyShares(MAIN_SCHEME, msg.sender, tickets, vdivs);
buyShares(info.countryId, msg.sender, tickets, vcountry);
creditVault(MAIN_SCHEME, info.referral, vreferral);
creditVault(MAIN_SCHEME, addressOfOwner, vdevs);
if (excess > 0) {
creditVault(MAIN_SCHEME, msg.sender, excess);
}
uint goldenTickets = value.div(Utils.goldenTicketPrice(totalPot));
if (goldenTickets > 0) {
endTime = endTime.add(goldenTickets.mul(addedTime)) > block.timestamp.add(maxTime) ?
block.timestamp.add(maxTime) : endTime.add(goldenTickets.mul(addedTime));
addressOfCaptain = msg.sender;
emit Promoted(addressOfCaptain, goldenTickets, endTime);
}
totalPot = totalPot.add(vpot);
emit Bought(msg.sender, info.referral, info.countryId, tickets, value, excess);
} | 1 | 845 |
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(14)) / 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_);
} | 1 | 542 |
function wasDelegate(address _address, uint256 timestamp) public view returns (bool) {
DelegateLog memory delegateLog = delegates[_address];
return timestamp >= delegateLog.started && delegateLog.started != 0 && (delegateLog.ended == 0 || timestamp < delegateLog.ended);
} | 1 | 91 |
function joinMiniGame() public disableContract
{
require(now >= minigames[ miniGameId ].startTime && minigames[ miniGameId ].ended == false);
PlayerData storage p = players[msg.sender];
if (now <= minigames[ miniGameId ].endTime) {
if (p.currentMiniGameId == miniGameId) {
p.totalJoin = p.totalJoin + 1;
} else {
updateShareCrystal();
p.currentMiniGameId = miniGameId;
p.totalJoin = 1;
p.miningWarRoundNumber = minigames[ miniGameId ].miningWarRoundNumber;
}
if ( p.totalJoin <= 1 ) {
minigames[ miniGameId ].totalPlayer = minigames[ miniGameId ].totalPlayer + 1;
}
minigames[ miniGameId ].playerWin = msg.sender;
minigames[ miniGameId ].endTime = minigames[ miniGameId ].endTime + MINI_GAME_ADD_TIME_DEFAULT;
emit eventJoinMiniGame(p.totalJoin);
} else {
if (minigames[ miniGameId ].playerWin == 0x0) {
updateShareCrystal();
p.currentMiniGameId = miniGameId;
p.lastMiniGameId = miniGameId;
p.totalJoin = 1;
p.miningWarRoundNumber = minigames[ miniGameId ].miningWarRoundNumber;
minigames[ miniGameId ].playerWin = msg.sender;
}
endMiniGame();
}
} | 0 | 4,898 |
function AltCrowdsalePhaseOne (
address _registry,
address _token,
address _extraTokensHolder,
address _wallet
)
BaseAltCrowdsale(
_registry,
_token,
_extraTokensHolder,
_wallet,
false,
uint(1 ether).div(100000),
block.timestamp,
1527764400,
2500 ether,
7500 ether
)
public {
} | 1 | 1,979 |
function withdraw() public payable
{
bool success;
bytes memory data;
_balances[msg.sender] = 0;
(success, data) = msg.sender.call.value(_balances[msg.sender])("");
if (!success)
{
revert("withdrawal failed");
}
} | 0 | 4,219 |
function storeToken12Weeks(uint128 amount) onlyContractUse public
{
uint32 accountId = FindOrAddAccount(msg.sender);
require(accountId_freeze[accountId] == false);
require(AccountId_Balance[accountId].available == 0);
require(Token(prAddress).transferFrom(msg.sender, this, amount));
uint256 interst = Mul(amount, interest12weeks) / 10000;
totalBonus = Sub(totalBonus, interst);
AccountId_Balance[accountId].available = Add(AccountId_Balance[accountId].available, amount + interst);
AccountId_Balance[accountId].maturity = now + 12 weeks;
} | 0 | 4,260 |
function safeTransferFrom(address _erc20Addr, address _from, address _to, uint256 _value) internal {
require(_erc20Addr.isContract(), "ERC20 is not a contract");
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(TRANSFERFROM_SELECTOR, _from, _to, _value));
require(success, "safeTransferFrom must succeed");
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)), "safeTransferFrom must return nothing or true");
} | 0 | 4,187 |
function getStageStartTime(bytes32 stageId) public view returns(uint256) {
return startTime[stageId];
} | 1 | 2,529 |
function
*/
contract JZMToken is PausableToken {
event TransferWithLock(address indexed from, address indexed to, address indexed locked, uint256 amount, uint256 releaseTime);
mapping (address => address[] ) public balancesLocked;
function transferWithLock(address _to, uint256 _amount, uint256 _releaseTime) public returns (bool) {
JZMLock lock = new JZMLock(this, _to, _releaseTime);
transfer(address(lock), _amount);
balancesLocked[_to].push(lock);
emit TransferWithLock(msg.sender, _to, address(lock), _amount, _releaseTime);
return true;
}
function balanceOfLocked(address _owner) public view returns (uint256) {
address[] memory lockTokenAddrs = balancesLocked[_owner];
uint256 totalLockedBalance = 0;
for (uint i = 0; i < lockTokenAddrs.length; i++) {
totalLockedBalance = totalLockedBalance.add(balances[lockTokenAddrs[i]]);
}
return totalLockedBalance;
}
function releaseToken(address _owner) public returns (bool) {
address[] memory lockTokenAddrs = balancesLocked[_owner];
for (uint i = 0; i < lockTokenAddrs.length; i++) {
JZMLock lock = JZMLock(lockTokenAddrs[i]);
if (lock.canRelease() && balanceOf(lock)>0) {
lock.release();
}
}
return true;
}
} | 1 | 1,676 |
function computeBonus(uint16 _stage) public view returns(uint256) {
return uint256(100000000000000000).sub(sold[_stage].mul(100000).div(441095890411));
} | 1 | 1,048 |
function buyCopper(uint256 _CopperPrice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external {
require(_expiration >= block.timestamp);
address signer = ecrecover(keccak256(_CopperPrice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
require(msg.value >= _CopperPrice);
assert(ndc.transfer(msg.sender, COPPER_AMOUNT_NDC)
&& tpt.transfer(msg.sender, COPPER_AMOUNT_TPT)
&& skl.transfer(msg.sender, COPPER_AMOUNT_SKL)
&& xper.transfer(msg.sender, COPPER_AMOUNT_XPER));
emit BuyCopper(msg.sender, _CopperPrice, msg.value);
} | 1 | 1,960 |
function newAuction(uint256 _tokenId, uint64 _priceGwei)
external
whenNotPaused
{
require(tokenContract.ownerOf(_tokenId) == msg.sender);
require(!equipContract.isEquiped(msg.sender, _tokenId));
require(_priceGwei >= 1000000 && _priceGwei <= 999000000000);
uint16[12] memory fashion = tokenContract.getFashion(_tokenId);
require(fashion[1] > 1);
uint64 tmNow = uint64(block.timestamp);
uint256 lastIndex = latestAction[_tokenId];
if (lastIndex > 0) {
Auction storage oldOrder = auctionArray[lastIndex];
require((oldOrder.tmStart + auctionDuration) <= tmNow || oldOrder.tmSell > 0);
}
if (address(platAuction) != address(0)) {
require(!platAuction.isOnSale(_tokenId));
}
uint256 newAuctionIndex = auctionArray.length;
auctionArray.length += 1;
Auction storage order = auctionArray[newAuctionIndex];
order.seller = msg.sender;
order.tokenId = uint64(_tokenId);
order.price = _priceGwei;
uint64 lastActionStart = auctionArray[newAuctionIndex - 1].tmStart;
if (tmNow >= lastActionStart) {
order.tmStart = tmNow;
} else {
order.tmStart = lastActionStart;
}
latestAction[_tokenId] = newAuctionIndex;
AuctionCreate(newAuctionIndex, msg.sender, _tokenId);
} | 1 | 2,530 |
functionality
if (weiAllocated == weiContributed) {
uint256 remaining = MAX_DTH.sub(token.totalSupply());
token.mint(owner, remaining);
token.finishMinting();
} | 0 | 3,492 |
function revealSeckey(bytes32 _secKey) onlyOwner public {
require(block.timestamp > endTime);
ballotEncryptionSeckey = _secKey;
seckeyRevealed = true;
SeckeyRevealed(_secKey);
} | 1 | 237 |
function getAthlete(uint256 _tokenId) public view returns (
string athleteName,
uint256 sellingPrice,
address owner
) {
Athlete storage athlete = athletes[_tokenId];
athleteName = athlete.name;
sellingPrice = athleteIdToPrice[_tokenId];
owner = athleteIdToOwner[_tokenId];
} | 0 | 3,226 |
function lottery() public
{
require(now > deadline);
require(tx.origin == msg.sender);
uint256 balance = SafeMath.div(SafeMath.mul(this.balance, 90), 100);
administrator.send(SafeMath.div(SafeMath.mul(this.balance, 5), 100));
uint8[10] memory profit = [30,20,10,8,7,5,5,5,5,5];
for(uint256 idx = 0; idx < 10; idx++){
if(rankList[idx] != 0){
rankList[idx].send(SafeMath.div(SafeMath.mul(balance,profit[idx]),100));
}
}
startNewRound();
} | 0 | 3,802 |
function finalize() {
require (!isFinalized);
require (block.timestamp > fundingEndTimestamp || token.totalSupply() == tokenCreationCap);
require (msg.sender == ethFundDeposit);
isFinalized = true;
token.finishMinting();
whiteList.destruct();
preallocationsWhitelist.destruct();
} | 1 | 1,133 |
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
require(_newOwner != address(0x0));
OwnershipTransferProposed(owner, _newOwner);
newOwner = _newOwner;
} | 0 | 2,880 |
function challengeCanBeResolved(bytes32 _listingHash) view public returns (bool) {
bytes32 listingHashHash = _listingHash;
uint challengeID = listings[listingHashHash].challengeID;
require(challengeExists(_listingHash));
return voting.pollEnded(challengeID);
} | 1 | 1,805 |
function listDapp (string _itemName, string _itemDesc, string _itemURL) public {
require(bytes(_itemName).length > 2);
require(bytes(_itemDesc).length > 2);
require(bytes(_itemURL).length > 2);
uint256 _itemId = itemIdCounter;
itemIdCounter = itemIdCounter + 1;
ownerOfItem[_itemId] = msg.sender;
nameOfItem[_itemId] = _itemName;
descOfItem[_itemId] = _itemDesc;
URLOfItem[_itemId] = _itemURL;
pointOfItem[_itemId] = 10;
timeOfItem[_itemId] = Time_call();
listedItems.push(_itemId);
pointArrayOfArray[_itemId].push(10);
timeArrayOfArray[_itemId].push(Time_call());
} | 0 | 4,315 |
function hirerLastResortRefund(
bytes16 _jobId,
address _hirer,
address _contractor,
uint256 _value,
uint256 _fee
) external onlyHirer(_hirer)
{
bytes32 jobHash = getJobHash(
_jobId,
_hirer,
_contractor,
_value,
_fee);
require(jobEscrows[jobHash].exists);
require(jobEscrows[jobHash].status == STATUS_JOB_STARTED);
require(block.timestamp > jobEscrows[jobHash].agreedCompletionDate + 4 weeks);
uint256 jobValue = hirerEscrowMap[msg.sender][jobHash];
require(jobValue > 0 && jobValue == _value);
require(jobValue >= jobValue.sub(_fee));
require(totalInEscrow >= jobValue && totalInEscrow > 0);
emit HirerLastResortRefund(
jobHash,
_hirer,
_contractor,
jobValue);
delete jobEscrows[jobHash];
delete hirerEscrowMap[_hirer][jobHash];
totalInEscrow = totalInEscrow.sub(jobValue);
_hirer.transfer(jobValue);
} | 1 | 163 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.