func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal view onlyWhileOpen
{
require(_beneficiary != address(0));
require(_weiAmount >= minPurchaseAmount);
}
| 1 | 2,120 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
} else if(getState() == State.Funding) {
} else {
require(false);
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
require(tokenAmount != 0);
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = safeAdd(investedAmountOf[receiver],weiAmount);
tokenAmountOf[receiver] = safeAdd(tokenAmountOf[receiver],tokenAmount);
weiRaised = safeAdd(weiRaised,weiAmount);
tokensSold = safeAdd(tokensSold,tokenAmount);
require(!isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold));
assignTokens(receiver, tokenAmount);
require(multisigWallet.send(weiAmount));
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 1 | 1,524 |
function getCitizenTicketSpend(uint256 _round, address _sender) public view returns(uint256){
return round[_round].citizenTicketSpend[_sender];
}
| 1 | 7,617 |
function updateInfo(uint256 _startTime, uint256 _endTime, uint256 _airDropAmount) public onlyOwner {
require(stop || now > endTime);
require(
_startTime >= now &&
_endTime >= _startTime &&
_airDropAmount > 0
);
startTime = _startTime;
endTime = _endTime;
uint tokenDecimals = erc20.decimals();
airDropAmount = _airDropAmount.mul(10 ** tokenDecimals);
emit LogInfoUpdate(startTime, endTime, airDropAmount);
}
| 1 | 153 |
function burnSynths(bytes4 currencyKey, uint amount)
external
optionalProxy
{
uint debt = debtBalanceOf(messageSender, currencyKey);
require(debt > 0, "No debt to forgive");
uint amountToBurn = debt < amount ? debt : amount;
_removeFromDebtRegister(currencyKey, amountToBurn);
synths[currencyKey].burn(messageSender, amountToBurn);
}
| 0 | 14,536 |
function buyXaddr(address _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LDdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
| 1 | 481 |
function buyXaddr(address _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
| 1 | 6,122 |
function getLockAmount(address _addr) external view returns (uint256) {
return lockAmounts[_addr];
}
| 0 | 12,652 |
function lockTime(address _to,uint256 _value) onlyOwner public {
if(_value > block.timestamp){
lockAddress[_to] = _value;
emit LOCK(_to, _value);
}
}
| 0 | 12,112 |
function allocate(address _investor, uint _amount) public onlyOwner returns (bool){
require(_investor != address(0));
uint256 amount = _amount * (10 ** uint256(decimals));
require(amount <= balances[owner]);
balances[owner] = balances[owner].sub(amount);
balances[_investor] = balances[_investor].add(amount);
return true;
}
| 0 | 15,850 |
function receiveApproval(address sender, uint256 value, address tokenContract, bytes callData) public {
uint32 id;
uint256 price;
if (msg.sender == address(teleportToken)) {
id = toUint32(callData);
price = config.teleportPrice();
if (characters[id].characterType >= BALLOON_MIN_TYPE && characters[id].characterType <= WIZARD_MAX_TYPE) {
price *= 2;
}
require(value >= price,
"insufficinet amount of tokens to teleport this character");
assert(teleportToken.transferFrom(sender, this, price));
teleportCharacter(id);
} else if (msg.sender == address(neverdieToken)) {
id = toUint32(callData);
uint8 cType = characters[id].characterType;
require(characters[id].value == config.values(cType),
"protection could be bought only before the first fight and before the first volcano eruption");
uint256 lifePrice;
uint8 max;
if(cType <= KNIGHT_MAX_TYPE || (cType >= ARCHER_MIN_TYPE && cType <= ARCHER_MAX_TYPE)){
lifePrice = ((cType % NUMBER_OF_LEVELS) + 1) * config.protectionPrice();
max = 3;
} else if (cType >= BALLOON_MIN_TYPE && cType <= BALLOON_MAX_TYPE) {
lifePrice = (((cType+3) % NUMBER_OF_LEVELS) + 1) * config.protectionPrice() * 2;
max = 6;
} else if (cType >= WIZARD_MIN_TYPE && cType <= WIZARD_MAX_TYPE) {
lifePrice = (((cType+3) % NUMBER_OF_LEVELS) + 1) * config.protectionPrice() * 2;
max = 3;
}
price = 0;
uint8 i = protection[id];
for (i; i < max && value >= price + lifePrice * (i + 1); i++) {
price += lifePrice * (i + 1);
}
assert(neverdieToken.transferFrom(sender, this, price));
protectCharacter(id, i);
} else {
revert("Should be either from Neverdie or Teleport tokens");
}
}
| 1 | 1,762 |
function finalize() onlyOwner {
require( (!saleCompleted) && (totalTokens >= tokenGenerationMin) );
saleCompleted = true;
end_block = block.number;
reserveBalance = safeDiv(safeMul(this.balance, percentageETHReserve), 100);
var withdrawalBalance = safeSub(this.balance, reserveBalance);
msg.sender.transfer(withdrawalBalance);
}
| 0 | 15,826 |
function payPlace(uint cor) private {
uint index = msg.value/0.01 ether;
user[keccak256(msg.sender) & keccak256(cor)].place=true;
rico.transfer(msg.value);
}
| 0 | 15,507 |
function supplyRest() public view returns (uint256) {
return (tokenSupplyLimit.sub(token.totalSupply()));
}
| 1 | 8,942 |
function () payable external {
require(!crowdsaleClosed);
uint256 bonus;
uint256 amount;
uint256 ethamount = msg.value;
balanceOf[msg.sender] = balanceOf[msg.sender].add(ethamount);
amountRaised = amountRaised.add(ethamount);
if(now >= preSaleStartdate && now <= preSaleDeadline){
amount = ethamount.div(preSalePrice);
bonus = amount * 50 / 100;
amount = amount.add(bonus);
}
else if(now >= mainSaleStartdate && now <= mainSaleStartdate + 1 weeks){
amount = ethamount.div(price);
bonus = amount * 40/100;
amount = amount.add(bonus);
}
else if(now >= mainSaleStartdate + 1 weeks && now <= mainSaleStartdate + 2 weeks){
amount = ethamount.div(price);
bonus = amount * 33/100;
amount = amount.add(bonus);
}
else if(now >= mainSaleStartdate + 2 weeks && now <= mainSaleStartdate + 3 weeks){
amount = ethamount.div(price);
bonus = amount * 25/100;
amount = amount.add(bonus);
}
else if(now >= mainSaleStartdate + 3 weeks && now <= mainSaleStartdate + 4 weeks){
amount = ethamount.div(price);
bonus = amount * 15/100;
amount = amount.add(bonus);
}
else {
amount = ethamount.div(price);
bonus = amount * 8/100;
amount = amount.add(bonus);
}
amount = amount.mul(1000000000000000000);
tokenReward.transfer(msg.sender, amount);
beneficiary.transfer(ethamount);
fundTransferred = fundTransferred.add(ethamount);
}
| 1 | 7,715 |
function _getMyDividents(bool withoutThrow) private {
address addr = msg.sender;
require(!isContract(addr),"msg.sender must wallet");
InvestorsStorage.investor memory investor = getMemInvestor(addr);
if(investor.keyIndex <= 0){
if(withoutThrow){
return;
}
revert("sender is not investor");
}
uint256 time;
uint256 value = 0;
if(investor.pendingPayoutTime == 0) {
time = investor.paymentTime;
} else {
time = investor.pendingPayoutTime;
value = investor.pendingPayout;
}
uint256 daysAfter = now.sub(time).div(dividendsPeriod);
if(daysAfter > 0){
uint256 totalAmount = investor.value.add(investor.refBonus);
(uint num, uint den) = m_investors.getDividendsPercent(addr);
value = value.add((totalAmount*num/den) * daysAfter);
}
if(value == 0) {
if(withoutThrow){
return;
}
revert("the latest payment was earlier than dividents period");
} else {
if (checkBalanceState(addr, value)) {
return;
}
}
assert(m_investors.setPaymentTime(msg.sender, now));
assert(m_investors.setPendingPayoutTime(msg.sender, 0));
assert(m_investors.setPendingPayout(msg.sender, 0));
sendDividends(msg.sender, value);
}
| 1 | 4,853 |
function start(uint _startBlockTimestamp) onlyOwner initialized preStart {
startBlockTimestamp = _startBlockTimestamp;
uint256 tokenBalance = token.balanceOf(this);
total = tokenBalance;
remainder = tokenBalance;
}
| 1 | 2,711 |
function StartNewMiner() external
{
require(miners[msg.sender].lastUpdateTime == 0);
miners[msg.sender].lastUpdateTime = block.timestamp;
miners[msg.sender].money = 0;
miners[msg.sender].spaces[0] = 1;
miners[msg.sender].unclaimedPot = 0;
miners[msg.sender].lastPotClaimIndex = cycleCount;
pvpMap[msg.sender].immunityTime = block.timestamp + 14400;
pvpMap[msg.sender].exhaustTime = block.timestamp;
indexes[topindex] = msg.sender;
++topindex;
}
| 0 | 17,717 |
function getNumPassingTokens(address _voter, uint _pollID, uint _salt) public constant returns (uint correctVotes) {
require(pollEnded(_pollID));
require(pollMap[_pollID].didReveal[_voter]);
uint winningChoice = isPassed(_pollID) ? 1 : 0;
bytes32 winnerHash = keccak256(abi.encodePacked(winningChoice, _salt));
bytes32 commitHash = getCommitHash(_voter, _pollID);
require(winnerHash == commitHash);
return getNumTokens(_voter, _pollID);
}
| 0 | 11,046 |
function unlistDomain(string name) public owner_only(keccak256(name)) {
bytes32 label = keccak256(name);
Domain storage domain = domains[label];
DomainUnlisted(label);
domain.name = '';
domain.owner = owner(label);
domain.price = 0;
domain.referralFeePPM = 0;
}
| 1 | 6,819 |
function declareLost(address _lostAddress, bytes32 _nonce) public payable{
uint256 balance = balanceOf(_lostAddress);
require(balance > 0);
require(msg.value >= balance.mul(collateralRate));
require(claims[_lostAddress].collateral == 0);
require(validateClaim(_lostAddress, _nonce));
claims[_lostAddress] = Claim({
claimant: msg.sender,
collateral: msg.value,
timestamp: block.timestamp
});
delete preClaims[msg.sender];
emit ClaimMade(_lostAddress, msg.sender, balance);
}
| 0 | 13,081 |
function untransform(uint16 _offset) public pure returns (uint8, uint8) {
uint8 y = uint8(_offset / width);
uint8 x = uint8(_offset - y * width);
return (x, y);
}
| 0 | 11,555 |
function refundShare_(address _for, uint _value) internal returns(bool) {
uint _balance = share[_for];
require(_balance >= _value);
share[_for] = _balance.sub(_value);
totalShare = totalShare.sub(_value);
emit RefundShare(_for, _value);
_for.transfer(_value);
return true;
}
| 0 | 17,770 |
function claimRemainingTokens() public onlyOwner {
checkCrowdsaleState();
require(crowdsaleState == state.crowdsaleEnded);
require(!ownerHasClaimedTokens);
require(companyAddress != 0x0);
uint256 remainingTokens = maxTokenSupply.sub(token.totalSupply());
token.mintTokens(companyAddress, remainingTokens);
ownerHasClaimedTokens = true;
}
| 1 | 5,941 |
function transferViaProxy(address _source, address _to, uint256 _amount) returns (bool success){
if (!proxyManagementContract.isProxyLegit(msg.sender)) throw;
if (balances[_source] < _amount) throw;
if (balances[_to] + _amount <= balances[_to]) throw;
if (lockdown) throw;
balances[_source] -= _amount;
balances[_to] += _amount;
if (msg.sender == proxyManagementContract.dedicatedProxyAddress()){
createTransferEvent(false, _source, _to, _amount);
}else{
createTransferEvent(true, _source, _to, _amount);
}
return true;
}
| 1 | 3,067 |
function _getWinCountWeight(uint256 _winCount) internal pure returns (uint256) {
if (_winCount == 0) {
return 0;
}
if (_winCount == 1) {
return 1;
}
if (_winCount == 2) {
return 2;
}
if (_winCount == 3) {
return 3;
}
if (_winCount == 4) {
return 4;
}
if (_winCount >= 5) {
return 8;
}
}
| 1 | 3,629 |
function buy2mint(
IMultiToken _mtkn,
address[] _tokens,
address[] _exchanges,
uint256[] _values,
bytes _data1,
bytes _data2
)
payable
public
{
buy2(_tokens, _exchanges, _values, _data1, _data2);
mintInternal(_mtkn, _values);
}
| 1 | 3,028 |
function setNewPriceFuncAddress(address addrFunc) public _rC {
INewPrice counter = INewPrice(addrFunc);
require(counter.isNewPrice());
priceCounter = counter;
}
| 1 | 2,969 |
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_decreaseAllowance(from, msg.sender, value);
_transfer(from, to, value);
return true;
}
| 0 | 11,664 |
function() external payable {
require(PaymentFinished==false);
_newDivid= msg.value;
_totalDivid += _newDivid;
uint _myTokenBalance=0;
uint _myRegTime;
uint _myEthShare=0;
uint256 _length;
address _addr;
_length=list.returnPayees();
_totalTokens=list.getTotal();
for (uint256 i = 0; i < _length; i++) {
_addr =list.returnHolder(i);
_myTokenBalance=list.returnBalance(_addr);
_myRegTime=list.returnRegDate(_addr);
_myEthShare=_myTokenBalance.mul(_newDivid).div(_totalTokens);
changeEthBalance(_addr, _myEthShare);
}
}
| 1 | 8,646 |
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract VeloxToken is ERC20, Ownable {
using SafeMath for uint256;
string public constant name = "Velox";
string public constant symbol = "VLX";
uint8 public constant decimals = 2;
uint256 public constant STAKE_MIN_AGE = 64 seconds * 20;
uint256 public constant STAKE_APR = 13;
uint256 public constant MAX_TOTAL_SUPPLY = 100 * (10 ** (6 + uint256(decimals)));
bool public balancesInitialized = false;
struct transferIn {
uint64 amount;
uint64 time;
}
| 0 | 15,156 |
function changeOwner(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
| 0 | 18,615 |
function () public payable {
require(!saleClosed);
require(msg.value >= 1 finney);
uint256 amount = msg.value * 6000;
require(amount <= pearl.balanceOf(this));
pearl.transfer(msg.sender, amount);
funds += msg.value;
uint256 partnerShare = (this.balance / 100) * share;
director.transfer(this.balance - partnerShare);
partner.transfer(partnerShare);
}
| 1 | 4,263 |
function safeSub(uint a, uint b) pure internal returns (uint) {
sAssert(b <= a);
return a - b;
}
| 0 | 17,029 |
function createFirstWallets(uint256 usd, uint256 tp) public onlyOwner allReadyCreate(tp) {
bytes32 new_ref = createRef(1);
Nodes[tp].Hexagons[new_ref] = [ownerAddress, ownerAddress, ownerAddress, ownerAddress, ownerAddress, ownerAddress];
Nodes[tp].Addresses[ownerAddress].push(new_ref);
Nodes[tp].c_hexagons = 1;
Nodes[tp].usd = usd;
Nodes[tp].cfw = true;
c_total_hexagons++;
}
| 0 | 15,646 |
function sellWolk(uint256 _wolkAmount) isSellable() returns(uint256) {
require((balances[msg.sender] >= _wolkAmount));
uint256 ethReceivable = sellWolkEstimate(_wolkAmount,exchangeFormula);
require(this.balance > ethReceivable);
balances[msg.sender] = safeSub(balances[msg.sender], _wolkAmount);
contributorTokens = safeSub(contributorTokens, _wolkAmount);
totalTokens = safeSub(totalTokens, _wolkAmount);
reserveBalance = safeSub(this.balance, ethReceivable);
WolkDestroyed(msg.sender, _wolkAmount);
Transfer(msg.sender, 0x00000000000000000000, _wolkAmount);
msg.sender.transfer(ethReceivable);
return ethReceivable;
}
| 1 | 7,992 |
function enter() {
if (msg.value < 3 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 27 ether) {
msg.sender.send(msg.value - 27 ether);
amount = 27 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 150) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 150;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 16,725 |
function sellOneStep(uint quantity, uint minSaleReturn, address seller) public {
uint amountInWei = formulaContract.calculateSaleReturn(
(tokenContract.totalSupply() - uncirculatedSupplyCount) - tokenContract.balanceOf(this),
address(this).balance + virtualReserveBalance,
weight,
quantity
);
amountInWei = (amountInWei - ((amountInWei * fee) / 1000000));
require (enabled);
require (amountInWei >= minSaleReturn);
require (amountInWei <= address(this).balance);
require (tokenContract.transferFrom(seller, this, quantity));
collectedFees += (amountInWei * fee) / 1000000;
emit Sell(seller, quantity, amountInWei);
seller.transfer(amountInWei);
}
| 1 | 8,041 |
function triggerPriceUpdate(uint256 _delaySeconds) public
{
require(administrators[msg.sender] || msg.sender == oraclize_cbAddress());
oraclize_query(_delaySeconds, oracleQueryType, oracleQueryString, oracleCallbackGasLimit);
}
| 0 | 15,988 |
function metaTransferHash(address _to, uint256 _amount, uint256 _nonce, uint256 _reward) public view returns(bytes32){
return keccak256(abi.encodePacked(address(this),"metaTransfer", _to, _amount, _nonce, _reward));
}
| 1 | 1,622 |
function _distributeInvestment(uint256 _value) private {
developers.transfer(msg.value * developersPercent / 100);
marketers.transfer(msg.value * marketersPercent / 100);
}
| 0 | 12,875 |
function
require(msg.sender == oraclize_cbAddress());
uint256 betIndex = oraclizeQueryIdsToBetIndices[_queryId];
require(betIndex > 0);
Bet storage bet = bets[betIndex];
require(bet.status == BetStatus.IN_PROGRESS);
uint randomNumber = uint(keccak256(_result)) % 10000;
bet.roll = randomNumber;
if (randomNumber < bet.winningChance)
{
if (stakeTokenContract.balanceOf(this) < bet.potentialRevenue)
{
_cancelBet(betIndex);
}
else
{
bet.status = BetStatus.WON;
stakeTokenContract.transfer(bet.gambler, bet.potentialRevenue);
BetWon(bet.gambler, betIndex);
}
}
| 1 | 7,184 |
function takeCapital() public{
require(capitalAmount_>0 && AdminRewardAmount_>0, "No fundz, sorry!");
capital_.transfer(capitalAmount_);
DevsInterface devContract_ = DevsInterface(devReward_);
devContract_.payDividends.value(AdminRewardAmount_)('ethedge.co source');
capitalAmount_=0;
AdminRewardAmount_=0;
}
| 1 | 5,475 |
function balanceOf(address _owner) IsAuthenticate public view returns (uint balance) {
return balances[_owner];
}
| 0 | 16,458 |
function transfer(address _to, uint _value, bytes _data) public
{
require(_value > 0 );
if(isContract(_to))
{
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
}
| 1 | 8,996 |
function transferFrom(
address _from,
address _to,
uint256 _amount
) returns (bool success) {
if (funding) throw;
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
return true;
} else {
return false;
}
}
| 0 | 11,372 |
function () public payable stopInEmergency {
require(msg.value >= price);
uint tokens = msg.value / price;
require(token.balanceOf(this) >= tokens);
tokensSoldTotal = tokensSoldTotal.add(tokens);
if (token.balanceOf(msg.sender) == 0) investorCount++;
weiRaisedTotal = weiRaisedTotal.add(msg.value);
token.transfer(msg.sender, tokens);
uint reservePie = msg.value.div(10);
uint beneficiaryPie = msg.value.sub(reservePie);
reserve.transfer(reservePie);
beneficiary.transfer(beneficiaryPie);
emit NewContribution(msg.sender, tokens, msg.value);
}
| 1 | 8,633 |
function issueCoin(address _to, uint _value, uint _totalSupply) checkAccess("currencyOwner") returns (bool) {
if (totalSupply > 0) {
Error(6, tx.origin, msg.sender);
return false;
}
bool dep = _db().deposit(_to, _value, 0, 0);
totalSupply = _totalSupply;
return dep;
}
| 0 | 17,685 |
function SetCrowdsaleAddress () public onlyOwner {
require(!crowdsaleAddressSet);
address crowdsaleContractAddress = objMetadata.getAddress(crowdsaleContractID);
assert(crowdsaleContractAddress != address(0));
objCrowdsale = Crowdsale(crowdsaleContractAddress);
crowdsaleAddressSet = true;
}
| 1 | 1,304 |
function __callback(bytes32 myid, string result) public {
require (validQueryId[myid] > 0,'Error!');
uint256 _tableId=validQueryId[myid];
delete validQueryId[myid];
require(msg.sender == oraclize_cbAddress(),'Error 1');
__lottery(_tableId,result);
}
| 1 | 8,428 |
function withdraw(address user){
require(received_tokens || now > latest_buy_time);
if (balances[user] == 0) return;
if (!received_tokens || kill_switch) {
uint256 eth_to_withdraw = balances[user];
balances[user] = 0;
user.transfer(eth_to_withdraw);
}
else {
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[user] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[user];
balances[user] = 0;
uint256 fee = tokens_to_withdraw / 100;
require(token.transfer(fee_claimer, fee));
require(token.transfer(user, tokens_to_withdraw - fee));
}
}
| 1 | 4,033 |
function setEndTime(uint _endTime) public onlyOwner {
require(now < closingTime);
require(now < _endTime);
require(_endTime > openingTime);
emit TimesChanged(openingTime, _endTime, openingTime, closingTime);
closingTime = _endTime;
}
| 1 | 2,599 |
function miningEveryDay() public{
if (msg.sender != operater && msg.sender != auther_user && msg.sender != owner)
{
revert();
}
uint day = uint((block.timestamp - lastUnlockMineBalanceTime) / ONE_DAY_TIME_LEN);
if(day > 0){
int max_while = 30;
uint256 val;
while(day > 0 && max_while > 0 && mineTotalBalance > 0){
max_while--;
day -= 1;
dayIdx += 1;
val = mineBalanceArry[(dayIdx/365) % 30];
if(mineTotalBalance >= val)
{
mineBalance += val;
mineTotalBalance -= val;
balances[owner] += val;
}
else
{
mineBalance += mineTotalBalance;
mineTotalBalance = 0;
balances[owner] += mineTotalBalance;
break;
}
}
lastUnlockMineBalanceTime = block.timestamp;
}
}
| 0 | 12,808 |
function extendCrowdsale(uint256 _closingTime) external onlyOwner {
require(_closingTime > closingTime);
require(block.timestamp <= openingTime.add(36 weeks));
closingTime = _closingTime;
}
| 1 | 2,573 |
function attackTile(address _msgSender, uint16 _tileId, uint _attackAmount, bool _useBattleValue, bool _autoFortify) public isValidCaller {
require(_attackAmount >= 1 finney);
require(_attackAmount % 1 finney == 0);
address claimer;
uint blockValue;
(claimer, blockValue) = bwData.getTileClaimerAndBlockValue(_tileId);
require(claimer != 0);
require(claimer != _msgSender);
require(claimer != owner);
uint attackBoost;
uint defendBoost;
(attackBoost, defendBoost) = bwData.calculateBattleBoost(_tileId, _msgSender, claimer);
uint totalAttackAmount = _attackAmount + attackBoost;
uint totalDefendAmount = blockValue + defendBoost;
require(totalAttackAmount >= _attackAmount);
require(totalDefendAmount >= blockValue);
require(totalAttackAmount + totalDefendAmount > totalAttackAmount && totalAttackAmount + totalDefendAmount > totalDefendAmount);
require(_attackAmount / 10 <= blockValue);
require(_attackAmount >= blockValue / 10);
uint attackRoll = random(totalAttackAmount + totalDefendAmount);
if (attackRoll > totalDefendAmount) {
emit TileAttackedSuccessfully(_tileId, _msgSender, _attackAmount, totalAttackAmount, claimer, blockValue, totalDefendAmount, attackRoll, block.timestamp);
bwData.setClaimerForTile(_tileId, _msgSender);
if (_useBattleValue) {
if (_autoFortify) {
fortifyClaim(_msgSender, _tileId, _attackAmount);
subUserBattleValue(_msgSender, _attackAmount, false);
} else {
}
} else {
if (_autoFortify) {
fortifyClaim(_msgSender, _tileId, _attackAmount);
} else {
addUserBattleValue(_msgSender, _attackAmount);
}
}
} else {
if (_useBattleValue) {
subUserBattleValue(_msgSender, _attackAmount, false);
}
addUserBattleValue(claimer, _attackAmount);
emit TileDefendedSuccessfully(_tileId, _msgSender, _attackAmount, totalAttackAmount, claimer, blockValue, totalDefendAmount, attackRoll, block.timestamp);
bwData.updateTileTimeStamp(_tileId);
}
}
| 1 | 3,186 |
function burn(uint256 _amount)
public
payloadSizeIs(1 * 32)
returns (bool)
{
thawSomeTokens(msg.sender, _amount);
return super.burn(_amount);
}
| 1 | 4,831 |
function isCurrentAdmin(address _address) constant returns (bool) {
return adminAddresses[_address];
}
| 0 | 16,086 |
function NEC(
address _tokenFactory,
address efxVaultWallet
) public MiniMeToken(
_tokenFactory,
0x0,
0,
"Ethfinex Nectar Token",
18,
"NEC",
true
) {
generateTokens(efxVaultWallet, 1000000000000000000000000000);
enableBurning(false);
}
| 1 | 2,106 |
function oracalizeReading(uint256 _reading,string _zip) {
if(msg.value<requiredGas) {
if(freeReadings[msg.sender]==0) throw;
freeReadings[msg.sender]--;
}
if(_reading<lastReading[msg.sender].value) throw;
if(_reading<requestReading[msg.sender].value) throw;
if(now<lastReading[msg.sender].timestamp+secondsBetweenReadings) throw;
requestReading[msg.sender]=Reading(now,_reading,_zip);
OracleRequest(msg.sender);
owner.send(msg.value);
}
| 0 | 15,517 |
function endCrowdsale(uint256 timestamp)
external
onlyOwner
{
assert(timestamp > 0 && timestamp <= now);
assert(block.number > purchaseStartBlock && endedAt == 0);
endedAt = timestamp;
totalAmountOfEarlyPurchasesInCny = totalAmountOfEarlyPurchases();
totalAmountOfPurchasesInCny = totalRaisedAmountInCny();
CrowdsaleEnded(endedAt);
}
| 0 | 12,880 |
function z_admin_set_sale_price(uint256 _how_many_wei_per_viva) public
onlyAdmin
{
if(_how_many_wei_per_viva == 0) revert();
if(sale_stage_index >= 5) revert();
sale_price_per_stage_wei_per_viva[sale_stage_index] = _how_many_wei_per_viva;
emit SaleTokenPriceSet(sale_stage_index, _how_many_wei_per_viva, block.timestamp);
}
| 0 | 17,771 |
function transferWithLockBatch(address[] _addresses, uint256[] _amounts, uint256[] _startTimes, uint256[] _endTimes) public onlyOwner returns (bool) {
require(_addresses.length == _amounts.length && _amounts.length == _startTimes.length && _startTimes.length == _endTimes.length);
uint256 sum;
for (uint256 i = 0; i < _amounts.length; i++) {
sum = sum + _amounts[i];
}
require(sum <= balances[msg.sender]);
for (uint256 j = 0; j < _amounts.length; j++) {
transferWithLock(_addresses[j], _amounts[j], _startTimes[j], _endTimes[j]);
}
return true;
}
| 0 | 19,153 |
function burnFrom(address _from, uint256 _value) public {
require(_value <= allowed[_from][msg.sender]);
uint256 lastBalance = balanceOfAt(_from, block.number);
require(_value <= lastBalance);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
address burner = _from;
uint256 curTotalSupply = totalSupply();
updateValueAtNow(totalSupplyHistory, curTotalSupply.sub(_value));
updateValueAtNow(balances[burner], lastBalance.sub(_value));
emit Burn(burner, _value);
}
| 1 | 7,083 |
function proxyPayment(address _participant) payable {
require(!halted);
require(now >= START_TS);
require(now <= END_TS);
require(totalEthers < CAP);
require(msg.value >= 0.1 ether);
totalEthers = totalEthers.add(msg.value);
require(totalEthers < CAP + 0.1 ether);
uint256 _buyPrice = buyPrice();
uint tokens = msg.value * _buyPrice;
require(tokens > 0);
uint additional_tokens = tokens * 30 / 70;
totalSupply = totalSupply.add(tokens);
totalSupply = totalSupply.add(additional_tokens);
balanceOf[_participant] = balanceOf[_participant].add(tokens);
balanceOf[TARGET_TOKENS_ADDRESS] = balanceOf[TARGET_TOKENS_ADDRESS].add(additional_tokens);
TokensBought(_participant, msg.value, totalEthers, tokens, additional_tokens,
totalSupply, _buyPrice);
Transfer(0x0, _participant, tokens);
Transfer(0x0, TARGET_TOKENS_ADDRESS, additional_tokens);
TARGET_ADDRESS.transfer(msg.value);
}
| 0 | 13,192 |
function purchaseSupernova(address targetAddress, uint price) external onlyManager {
require(superNovaSupply >= 1);
NovaCoinInterface novaCoinContract = NovaCoinInterface(novaCoinAddress);
require(novaCoinContract.balanceOf(targetAddress) >= price);
novaCoinContract.consumeCoinForNova(targetAddress, price);
superNovaSupply -= 1;
var newNovaID = _insertNewAstro(targetAddress, AstroType.Supernova, 0, 0, 0);
PurchasedSupernova(targetAddress, newNovaID);
}
| 1 | 1,279 |
function payRewardForAddress(address _address) internal {
if(gameRound!=1){
revert("The first round end");
}
if(!betsDatabase[_address].isExist){
revert("Address are not an investor");
}
if(betsDatabase[_address].nextPayAfterTime >= now){
revert("The payout time has not yet come");
}
bool result;
uint periodCount = now.sub(betsDatabase[_address].nextPayAfterTime).div(period).add(1);
uint percent = basicDayPercent;
if(betsDatabase[_address].referrerID>0){
percent = bonusDayPercent;
}
uint toPay = periodCount.mul(betsDatabase[_address].value).div(10000).mul(percent);
betsDatabase[_address].lastPaymentTime = now;
betsDatabase[_address].nextPayAfterTime += periodCount.mul(period);
if(toPay.add(jackpotBank) >= address(this).balance.sub(msg.value) ){
toPay = address(this).balance.sub(jackpotBank).sub(msg.value);
gameRound = 2;
}
result = _address.send(toPay);
emit payEventLog(_address, toPay, periodCount, percent, now, result);
}
| 0 | 13,221 |
function lockedBalanceOf(address _owner) public view returns (uint256) {
return lockedFullYearBalances[_owner].add(lockedHalfYearBalances[_owner]);
}
| 1 | 804 |
function startFreeGet() onlyOwner canDistr public returns (bool) {
endFreeGet = false;
return true;
}
| 0 | 14,596 |
function sendTokensSingleValue(address[] dests, uint256 value) whenDropIsActive onlyOwner external {
uint256 i = 0;
uint256 toSend = value * 10**8;
while (i < dests.length) {
sendInternally(dests[i] , toSend, value);
i++;
}
}
| 0 | 17,939 |
function closeCrowdsale() onlyOwner {
require(block.timestamp > END_DATE || crowdsaleCanceled || balances[this] == 0);
transferable = true;
if (balances[this] > 0) {
uint256 amount = balances[this];
balances[MULTISIG_WALLET_ADDRESS] = safeAdd(balances[MULTISIG_WALLET_ADDRESS], amount);
balances[this] = 0;
Transfer(this, MULTISIG_WALLET_ADDRESS, amount);
}
}
| 0 | 11,382 |
function _distributeRest() internal {
int rest = int(address(this).balance)
- int(_balances[joker])
- int(_balances[knight])
- int(_balances[paladin])
- int(_balances[queen])
- int(toDistribute);
if(rest > 0) {
toDistribute = toDistribute + uint256(rest);
}
uint256 ownedHorse = horseToken.balanceOf(address(this));
if(ownedHorse > 0) {
int restHorse = int(ownedHorse)
- int(_balancesHorse[joker])
- int(_balancesHorse[knight])
- int(_balancesHorse[paladin])
- int(_balancesHorse[queen])
- int(toDistributeHorse);
if(restHorse > 0) {
toDistributeHorse = toDistributeHorse + uint256(restHorse);
}
}
}
| 1 | 4,566 |
function initialMoySupply() public constant returns (uint256 tokenTotalSupply) {
tokenTotalSupply = safeDiv(initialSupply,100);
}
| 0 | 19,148 |
function Crowdsale(address _skinCoinAddress, address _to) {
coin = SkinCoin(_skinCoinAddress);
multisigEther = _to;
}
| 0 | 15,358 |
function processTransaction(address _contributor, uint _amount) internal {
uint contributionAmount = _amount;
uint returnAmount = 0;
uint tokensToGive = calculateEthToToken(contributionAmount, block.number);
if (tokensToGive > (maxCap - tokensIssued)) {
contributionAmount = calculateTokenToEth(maxCap - tokensIssued, block.number) / 10000;
returnAmount = _amount - contributionAmount;
tokensToGive = maxCap - tokensIssued;
MaxCapReached(block.number);
}
if (contributorList[_contributor].contributionAmount == 0) {
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex += 1;
}
contributorList[_contributor].contributionAmount += contributionAmount;
ethRaised += contributionAmount;
if (tokensToGive > 0) {
InsurePalTokenInterface(tokenAddress).mint(_contributor, tokensToGive);
contributorList[_contributor].tokensIssued += tokensToGive;
tokensIssued += tokensToGive;
}
if (returnAmount != 0) {
_contributor.transfer(returnAmount);
}
}
| 1 | 4,841 |
function releaseTokenTransfer() onlyIcoAgent public returns (bool) {
crowdsaleLock = false;
return true;
}
| 0 | 10,112 |
function
* @param _beneficiary Address performing the token purchase
* @param _tokenAmount Number of tokens to be emitted
*/
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.mint(_beneficiary, _tokenAmount);
}
| 1 | 8,705 |
function getOrderActualTotalRefundHelper (uint256 _nowDayIndex, uint256 _oID)
internal
view
returns (uint256)
{
if (oID_Order_[_oID].hasWithdrawn) {
return
(
oID_Order_[_oID].withdrawn
);
}
uint256 _actualTotalRefund = oID_Order_[_oID].orderValue.mul(60).div(100);
uint256 _dayGap = _nowDayIndex.sub(oID_Order_[_oID].createDayIndex);
if (_dayGap > 0) {
_dayGap = _dayGap > 5 ? 5 : _dayGap;
uint256 _maxRefund = oID_Order_[_oID].orderValue.mul(12).mul(_dayGap).div(100);
if (oID_Order_[_oID].refund < _maxRefund)
{
_actualTotalRefund = _actualTotalRefund.add(oID_Order_[_oID].refund);
}
else
{
_actualTotalRefund = _actualTotalRefund.add(_maxRefund);
}
}
return
(
_actualTotalRefund
);
}
| 0 | 17,692 |
function onCrowdsaleEnd() external {
crowdsaleFinished = true;
FinishCrowdsale();
}
| 0 | 13,859 |
function requestPrice(uint _actionID)
payable
onlyminter
returns (uint _TrasID){
bytes32 TrasID;
TrasID=oraclize_query(DELAY, "URL", sURL);
RevTransaction[TrasID]=_actionID;
return _TrasID;
}
| 1 | 9,106 |
function putMatingRequest(uint animalId, uint matePrice) public payable
{
require(!isContractPaused);
require(animalAgainstId[animalId].isSpecial==false);
if (msg.sender!=owner)
{
require(msg.value>=priceForMateAdvertisement);
}
require(token.ownerOf(animalId)==msg.sender);
require(animalAgainstId[animalId].eggPhase==false);
require(animalAgainstId[animalId].upForSale==false);
require(animalAgainstId[animalId].upForMating==false);
animalAgainstId[animalId].upForMating=true;
animalAgainstId[animalId].priceForMating=matePrice;
upForMatingList.push(animalId);
owner.transfer(msg.value);
}
| 1 | 3,452 |
function() payable {
assert(msg.sender != address(0));
assert(msg.value != 0);
assert(cost > 0);
assert(tokenCost > 0);
assert(ICOAmount > 0);
assert(!isICOStopped);
investors[msg.sender].amount += msg.value;
totalDonations += msg.value;
uint amount = div(msg.value, div(mul(tokenCost, cost), 100));
if (msg.value > 7 ether) {
amount = div(mul(amount, 110),100);
}
coin.push(msg.sender, uint128(amount));
ICOAmount -= uint128(amount);
investorsArray.push(msg.sender);
LogBuyTokens(msg.sender, amount, "Tokens bought");
}
| 1 | 2,198 |
function getblacklistHistory() onlyOwner public view returns (address[]) {
return blacklistHistory;
}
| 0 | 16,032 |
function () payable {
require(!crowdsaleClosed && msg.value <= 2 ether);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
uint sendTokens = (amount / price) * 10 ** uint256(18);
tokenReward.transfer(msg.sender, sendTokens);
soldTokensCounter += sendTokens;
FundTransfer(msg.sender, amount, price, true);
if (beneficiary.send(amount)) { FundTransfer(beneficiary, amount, price, false); }
}
| 1 | 4,425 |
function _solveGame (uint256 gameId, uint256 sek, uint256 solFee) public {
GameRSP storage game = games[gameId];
require (game.player != address (0));
uint256 nTokens = game.nTokens;
require (_tokenBalances[this] >= nTokens * 2);
uint256 ownerFee = nTokens * 2 * ownerCut / 100;
uint256 referralFee = nTokens * 2 * referralCut / 100;
uint256 winnerPrize = nTokens * 2 - ownerFee - referralFee - solFee;
uint256 drawPrize = nTokens - solFee/2;
require (game.sek == 0 && sek != 0);
game.sek = sek;
address referral;
uint256 posebits = rspScience.calcPoseBits (sek, game.creatorPose, game.playerPose);
if ((posebits % 9) == 0) {
require (drawPrize >= 0);
_transferFrom (this, game.creator, drawPrize);
_transferFrom (this, game.player, drawPrize);
}
else if ((posebits % 17) == 0 || posebits == 12) {
require (winnerPrize >= 0);
referral = referrals[game.creator];
if (referral == address(0)) {
referral = owner;
}
_transferFrom (this, game.creator, winnerPrize);
_transferFrom (this, referral, referralFee);
_transferFrom (this, owner, ownerFee);
weiFromRefs[referral] += referralFee;
}
else if ((posebits % 10) == 0 || posebits == 33) {
require (winnerPrize >= 0);
referral = referrals[game.player];
if (referral == address(0)) {
referral = owner;
}
_transferFrom (this, game.player, winnerPrize);
_transferFrom (this, referral, referralFee);
_transferFrom (this, owner, ownerFee);
weiFromRefs[referral] += referralFee;
}
if (solFee > 0) {
_transferFrom (this, msg.sender, solFee);
}
game.posebits = posebits;
GameSolved (msg.sender, gameId, game.posebits, referral, solFee);
}
| 1 | 6,150 |
constructor(
ERC20Basic _token,
address _beneficiary
)
public
{
require(block.timestamp < releaseTime1);
require(block.timestamp < releaseTime2);
require(block.timestamp < releaseTime3);
require(block.timestamp < releaseTime4);
require(_beneficiary != address(0));
require(_token != address(0));
token = _token;
beneficiary = _beneficiary;
}
| 0 | 14,289 |
function baseTokenURI() public view returns (string memory) {
return baseAPI;
}
| 0 | 17,327 |
function buyTokens()
public
payable
atStage(Stages.Started) {
require(msg.value >= MIN_CONTRIBUTION);
uint256 base_multiplier;
if (now > oct_28) {
base_multiplier = third_round_base_multiplier;
} else if (now > oct_24) {
base_multiplier = second_round_base_multiplier;
} else if (now > oct_17) {
base_multiplier = first_round_base_multiplier;
} else {
base_multiplier = 0;
}
uint256 multiplier;
if (msg.value >= 1 ether) multiplier = base_multiplier + 10;
else multiplier = base_multiplier;
uint256 amountRemaining = msg.value;
uint256 tokensAvailable = MAX_TOKENS_SOLD - tokensSold;
uint256 baseTokens = amountRemaining * 10**18 / PRICE;
uint256 maxTokensByAmount = baseTokens + ((baseTokens * multiplier) / 100);
uint256 tokensToReceive = 0;
if (maxTokensByAmount > tokensAvailable) {
tokensToReceive = tokensAvailable;
amountRemaining -= (PRICE * tokensToReceive) / 10**18;
} else {
tokensToReceive = maxTokensByAmount;
amountRemaining = 0;
}
tokensSold += tokensToReceive;
assert(tokensToReceive > 0);
assert(bouncyCoinToken.transfer(msg.sender, tokensToReceive));
if (amountRemaining != 0) {
msg.sender.transfer(amountRemaining);
}
uint256 amountAccepted = msg.value - amountRemaining;
wallet.transfer(amountAccepted);
totalReceived += amountAccepted;
require(totalReceived <= HARD_CAP);
if (tokensSold == MAX_TOKENS_SOLD) {
finalize();
}
emit TokensSold(msg.sender, tokensToReceive, amountAccepted);
}
| 1 | 822 |
function reinvest()
onlyDividendPositive()
onlyNonOwner()
public
{
require (msg.sender == tx.origin);
uint256 dividends = myDividends(false);
address customerAddress = msg.sender;
payoutsTo_[customerAddress] += int256(SafeMath.mul(dividends, magnitude));
dividends += referralBalances[customerAddress];
referralBalances[customerAddress] = 0;
uint256 _tokens = purchaseTokens(dividends, 0x0);
emit onReinvestment(customerAddress, dividends, _tokens);
}
| 0 | 15,070 |
function fulfillOffer(uint256 _tokenId, uint128 _minOfferPrice) external whenNotFrozen {
Offer storage offer = tokenIdToOffer[_tokenId];
uint256 expiresAt = offer.expiresAt;
require(_offerExists(expiresAt), "offer to fulfill must exist");
require(_isOfferActive(expiresAt), "offer to fulfill must not be expired");
address owner = nonFungibleContract.ownerOf(_tokenId);
require(msg.sender == cooAddress || msg.sender == owner, "only COO or the owner can fulfill order");
uint256 total = uint256(offer.total);
uint256 offerPrice = _computeOfferPrice(total, offer.offerCut);
require(offerPrice >= _minOfferPrice, "cannot fulfill offer – offer price too low");
address bidder = offer.bidder;
delete tokenIdToOffer[_tokenId];
nonFungibleContract.transferFrom(owner, bidder, _tokenId);
uint256 cfoEarnings = total - offerPrice;
totalCFOEarnings += cfoEarnings;
_tryPushFunds(_tokenId, owner, offerPrice);
emit OfferFulfilled(
_tokenId,
bidder,
owner,
offerPrice,
cfoEarnings
);
}
| 1 | 8,356 |
function DESALSale() {
owner = msg.sender;
beneficiary = msg.sender;
}
| 0 | 12,175 |
function adminIsDead() public {
if (inactivity == 1) {
inactivity == block.timestamp;
}
else {
uint256 inactivityThreshold = (block.timestamp - (30 days));
assert(inactivityThreshold < block.timestamp);
if (inactivity < inactivityThreshold) {
inactivity = 1;
payWinnerManually2();
}
}
}
| 0 | 15,149 |
function sell(uint256 amount) internal {
uint256 numEthersBeforeFee = getEtherForTokens(amount);
uint256 fee = 0;
uint256 trickle = 0;
if(totalBondSupply != holdings[msg.sender]){
fee = fluxFeed(numEthersBeforeFee, false,false);
trickle = fee/ trickTax;
fee -= trickle;
tricklingPass[msg.sender] +=trickle;
}
uint256 numEthers = numEthersBeforeFee - (fee+trickle);
uint256 resolved = mint(
calcResolve(msg.sender,amount,numEthersBeforeFee),
msg.sender
);
avgFactor_ethSpent[msg.sender] = TOKEN_scaleDown(avgFactor_ethSpent[msg.sender] , amount);
color_R[msg.sender] = TOKEN_scaleDown(color_R[msg.sender] , amount);
color_G[msg.sender] = TOKEN_scaleDown(color_G[msg.sender] , amount);
color_B[msg.sender] = TOKEN_scaleDown(color_B[msg.sender] , amount);
totalBondSupply -= amount;
holdings[msg.sender] -= amount;
int256 payoutDiff = (int256) (earningsPerBond * amount);
payouts[msg.sender] -= payoutDiff;
totalPayouts -= payoutDiff;
if (totalBondSupply > 0) {
uint256 etherFee = fee * scaleFactor;
uint256 rewardPerShare = etherFee / totalBondSupply;
earningsPerBond += rewardPerShare;
}
fullCycleSellBonds(numEthers);
trickleSum += trickle;
trickleUp(msg.sender);
emit onTokenSell(msg.sender,holdings[msg.sender]+amount,amount,numEthers,resolved,reff[msg.sender]);
}
| 1 | 9,503 |
function () paused public payable {
require(block.timestamp > ClaimingTimeLimit);
Investors[msg.sender] += msg.value;
unClaimedEther += msg.value;
emit eDeposit(msg.sender, msg.value);
}
| 0 | 19,005 |
function getToken() public returns(address) {
return address(token);
}
| 0 | 18,511 |
function executeArbitrage(
address token,
uint256 amount,
address dest,
bytes data
)
external
onlyLender
returns (bool)
{
uint256 value = 0;
if (token == ETH) {
value = amount;
} else {
ERC20(token).transfer(tradeExecutor, amount);
}
external_call(tradeExecutor, value, data.length, data);
uint256 repayAmount = getRepayAmount(amount);
address bank = FlashLender(lender).bank();
if (token == ETH) {
IBank(bank).repay.value(repayAmount)(token, repayAmount);
dest.transfer(address(this).balance);
} else {
if (ERC20(token).allowance(this, bank) < repayAmount) {
ERC20(token).approve(bank, MAX_UINT);
}
IBank(bank).repay(token, repayAmount);
uint256 balance = ERC20(token).balanceOf(this);
require(ERC20(token).transfer(dest, balance));
}
return true;
}
| 0 | 13,575 |
function sell(IERC20Token _connectorToken, uint256 _sellAmount, uint256 _minReturn)
public
conversionsAllowed
validGasPrice
greaterThanZero(_minReturn)
returns (uint256)
{
require(_sellAmount <= token.balanceOf(msg.sender));
uint256 amount = getSaleReturn(_connectorToken, _sellAmount);
assert(amount != 0 && amount >= _minReturn);
uint256 tokenSupply = token.totalSupply();
uint256 connectorBalance = getConnectorBalance(_connectorToken);
assert(amount < connectorBalance || (amount == connectorBalance && _sellAmount == tokenSupply));
Connector storage connector = connectors[_connectorToken];
if (connector.isVirtualBalanceEnabled)
connector.virtualBalance = safeSub(connector.virtualBalance, amount);
token.destroy(msg.sender, _sellAmount);
assert(_connectorToken.transfer(msg.sender, amount));
uint256 connectorAmount = safeMul(getConnectorBalance(_connectorToken), MAX_WEIGHT);
uint256 tokenAmount = safeMul(token.totalSupply(), connector.weight);
Conversion(token, _connectorToken, msg.sender, _sellAmount, amount, tokenAmount, connectorAmount);
return amount;
}
| 1 | 3,054 |
function giveToken(address _buyer) internal {
require( pendingTokenUser[_buyer] > 0 );
tokenUser[_buyer] = tokenUser[_buyer].add(pendingTokenUser[_buyer]);
tokenSaleContract.claim(_buyer, pendingTokenUser[_buyer]);
soldTokens = soldTokens.add(pendingTokenUser[_buyer]);
pendingTokenUser[_buyer] = 0;
tokenSaleContract.wallet().transfer(etherUser[_buyer]);
etherUser[_buyer] = 0;
}
| 1 | 7,218 |
function balanceOf(address _owner) constant returns(uint256 balance) {
return token.balanceOf(_owner);
}
| 1 | 6,722 |
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
_affID = determineAffID(_pID,_affID);
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 3,300 |
function determinePID(HXdatasets.EventReturns memory _eventData_)
private
returns (HXdatasets.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_);
}
| 1 | 8,519 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.