func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function disallowTransfer(address target, bool disallow) external onlyOwner {
noTransfer[target] = disallow;
}
| 0
| 11,253
|
function buy(uint _jingleId) public payable {
require(sellOrders[_jingleId].exists == true);
require(msg.value >= sellOrders[_jingleId].price);
sellOrders[_jingleId].exists = false;
numOrders--;
removeOrder(_jingleId);
jingleContract.transfer(msg.sender, _jingleId);
uint price = sellOrders[_jingleId].price;
uint threePercent = (price / 100) * OWNERS_CUT;
sellOrders[_jingleId].seller.transfer(price - threePercent);
ownerBalance += threePercent;
Bought(_jingleId, msg.sender, msg.value);
}
| 1
| 2,359
|
function BuyARXtokens() payable {
require(!(msg.value == 0)
&& (isPresaleSetup)
&& (block.number >= fundingStartBlock)
&& (block.number <= fundingEndBlock)
&& !(safeAdd(amountRaisedInWei,msg.value) > fundingMaxCapInWei));
uint256 rewardTransferAmount = 0;
setPrice();
amountRaisedInWei = safeAdd(amountRaisedInWei,msg.value);
rewardTransferAmount = safeMul(msg.value,tokensPerEthPrice);
fundingRemainingAvailableInEth = safeDiv(safeSub(fundingMaxCapInWei,amountRaisedInWei),1 ether);
tokenReward.transfer(msg.sender, rewardTransferAmount);
fundValue[msg.sender] = safeAdd(fundValue[msg.sender], msg.value);
Transfer(this, msg.sender, msg.value);
Buy(msg.sender, msg.value, rewardTransferAmount);
}
| 1
| 673
|
function totalTeams() public view returns (uint256) {
return teams.length - 1;
}
| 1
| 5,272
|
function adTransferFrom(address source, address[] recipents, uint256[] amount,uint decimals) public {
token=Token(source);
for(i=0;i<recipents.length;i++) {
token.transferFrom(msg.sender,recipents[i],amount[i]*(10**decimals));
emit TransferFromToken(msg.sender,recipents[i],amount[i]);
}
}
| 1
| 9,391
|
function() public payable {
emit EtherReceived(msg.value, msg.sender);
}
| 0
| 19,358
|
function isNewPayoutPeriod() constant returns(bool) {
return now >= nextPayoutBlock;
}
| 0
| 17,150
|
function buyTokens() public onlyWhitelisted payable {
require(state == State.Active &&
block.timestamp <= endAt &&
msg.value >= lowCapTxWei &&
msg.value <= hardCapTxWei &&
collectedWei + msg.value <= hardCapWei);
uint amountWei = msg.value;
uint iwei = amountWei.mul(100 + BONUS).div(100);
uint itokens = iwei * ETH_TOKEN_EXCHANGE_RATIO;
token.icoInvestment(msg.sender, itokens);
collectedWei = collectedWei.add(amountWei);
tokensSold = tokensSold.add(itokens);
if (investments[msg.sender] == 0) {
investorCount++;
}
investments[msg.sender] = investments[msg.sender].add(amountWei);
ICOInvestment(msg.sender, amountWei, itokens, BONUS);
forwardFunds();
touch();
}
| 1
| 2,820
|
function removeMaterials(address _owner, uint _mId1, uint _amount1, uint _mId2, uint _amount2,
uint _mId3, uint _amount3, uint _mId4, uint _amount4) onlyModerators external {
if (_mId1 > 0) {
if (myMaterials[_owner][_mId1] < _amount1) revert();
myMaterials[_owner][_mId1] -= _amount1;
materials[_mId1].erc20.emitTransferEvent(_owner, address(0), _amount1);
}
if (_mId2 > 0) {
if (myMaterials[_owner][_mId2] < _amount2) revert();
myMaterials[_owner][_mId2] -= _amount2;
materials[_mId2].erc20.emitTransferEvent(_owner, address(0), _amount2);
}
if (_mId3 > 0) {
if (myMaterials[_owner][_mId3] < _amount3) revert();
myMaterials[_owner][_mId3] -= _amount3;
materials[_mId3].erc20.emitTransferEvent(_owner, address(0), _amount3);
}
if (_mId4 > 0) {
if (myMaterials[_owner][_mId4] < _amount4) revert();
myMaterials[_owner][_mId4] -= _amount4;
materials[_mId4].erc20.emitTransferEvent(_owner, address(0), _amount4);
}
}
| 1
| 8,484
|
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 / 20);
airDropPot_ = airDropPot_.add(_air);
if (_team == 0){
_eth = _eth.sub(((_eth.mul(40)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
}else{
_eth = _eth.sub(((_eth.mul(20)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
}
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
| 0
| 13,282
|
function checkGoalReached() public {
uint256 tokensLeft = rewardToken.balanceOf(crowdsaleWallet);
if (tokensLeft == 0) {
fundingGoalReached = true;
crowdsaleClosed = true;
GoalReached(crowdsaleBeneficiary, amountRaised);
} else if (now >= deadline) {
crowdsaleClosed = true;
GoalReached(crowdsaleBeneficiary, amountRaised);
}
}
| 1
| 2,791
|
function tune(uint endAt_,
uint lowCapWei_,
uint hardCapWei_,
uint lowCapTxWei_,
uint hardCapTxWei_) onlyOwner isSuspended public {
if (endAt_ > block.timestamp) {
endAt = endAt_;
}
if (lowCapWei_ > 0) {
lowCapWei = lowCapWei_;
}
if (hardCapWei_ > 0) {
hardCapWei = hardCapWei_;
}
if (lowCapTxWei_ > 0) {
lowCapTxWei = lowCapTxWei_;
}
if (hardCapTxWei_ > 0) {
hardCapTxWei = hardCapTxWei_;
}
require(lowCapWei <= hardCapWei && lowCapTxWei <= hardCapTxWei);
touch();
}
| 0
| 13,369
|
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {
require(_amount > 0);
uint256 extra = _amount.div(3).mul(2);
uint256 total = _amount.add(extra);
totalSupply = totalSupply.add(total);
assert(totalSupply <= HARDCAPPED_SUPPLY);
balances[_to] = balances[_to].add(_amount);
balances[owner] = balances[owner].add(extra);
Mint(_to, _amount);
Mint(owner, extra);
Transfer(0x0, _to, _amount);
Transfer(0x0, owner, extra);
return true;
}
| 0
| 12,929
|
function setPremium(int newBuyPremium, int newSellPremium, uint newEthBaseQty) public onlyAdmin {
require(newBuyPremium >= -10000);
require(newBuyPremium <= int(MAX_QTY));
require(newSellPremium >= -10000);
require(newSellPremium <= int(MAX_QTY));
sellPremiumInBps = newSellPremium;
buyPremiumInBps = newBuyPremium;
baseEthQty = newEthBaseQty;
}
| 0
| 19,400
|
function getPTicketSumByRound(uint256 _rId, address _buyer)
public
view
returns(uint256)
{
return round[_rId].pTicketSum[_buyer];
}
| 0
| 15,105
|
function buyCore(uint256 _pID, DRSDatasets.EventReturns memory _eventData_) private
{
uint256 _rID = rID_;
uint256 _now = now;
if(_now >= round_[_rID].strt.add(rndGap_) && (_now <= round_[_rID].end || round_[_rID].plyr == 0)) {
core(_rID, _pID, msg.value, _eventData_);
} else {
if(_now > round_[_rID].end && !round_[_rID].ended) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_ = _eventData_.setTimestamp(_now);
_eventData_ = _eventData_.setPID(_pID);
emit DRSEvents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1
| 1,326
|
function acceptProposal(bytes32 _idHash) external {
Dispute memory dispute = disputes[_idHash];
require(msg.sender == dispute.respondent, "Proposal can be accepted only by a respondent.");
this.settleDispute(
_idHash,
disputes[_idHash].respondentShare,
disputes[_idHash].initiatorShare
);
}
| 1
| 8,470
|
function buy(address beneficiary)
public
payable
whenNotPaused
{
require(presaleFallBackCalled);
require(beneficiary != 0x00);
require(kyc.registeredAddress(beneficiary));
require(onSale());
require(validPurchase());
require(!isFinalized);
uint256 weiAmount = msg.value;
uint256 toFund;
uint256 postWeiRaised = add(weiRaised, weiAmount);
if (postWeiRaised > maxEtherCap) {
toFund = sub(maxEtherCap, weiRaised);
} else {
toFund = weiAmount;
}
require(toFund > 0);
require(weiAmount >= toFund);
uint256 rate = calculateRate(toFund);
uint256 tokens = mul(toFund, rate);
uint256 toReturn = sub(weiAmount, toFund);
pushInvestorList(msg.sender);
weiRaised = add(weiRaised, toFund);
beneficiaryFunded[beneficiary] = add(beneficiaryFunded[beneficiary], toFund);
token.generateTokens(beneficiary, tokens);
if (toReturn > 0) {
msg.sender.transfer(toReturn);
}
forwardFunds(toFund);
CrowdSaleTokenPurchase(msg.sender, beneficiary, toFund, tokens);
}
| 1
| 5,345
|
function tokensBack() onlyOwner public {
if(now > endTime){
sharesTokenAddress.transfer(owner, sharesTokenAddress.balanceOf(this));
}
tokenFree = sharesTokenAddress.balanceOf(this);
}
| 1
| 7,094
|
function caspianToken() public {
symbol = "CSP";
name = "Caspian Token";
decimals = 18;
bonusEnds = now + 1 weeks;
endDate = now + 7 weeks;
_totalSupply=10000000000000000000000000000;
}
| 0
| 18,908
|
function calculateRingFees(
TokenTransferDelegate delegate,
uint ringSize,
OrderState[] orders,
address _lrcTokenAddress
)
private
view
{
bool checkedMinerLrcSpendable = false;
uint minerLrcSpendable = 0;
uint8 _marginSplitPercentageBase = MARGIN_SPLIT_PERCENTAGE_BASE;
uint nextFillAmountS;
for (uint i = 0; i < ringSize; i++) {
OrderState memory state = orders[i];
uint lrcReceiable = 0;
if (state.lrcFeeState == 0) {
state.marginSplitAsFee = true;
state.marginSplitPercentage = _marginSplitPercentageBase;
} else {
uint lrcSpendable = getSpendable(
delegate,
_lrcTokenAddress,
state.owner
);
if (state.tokenS == _lrcTokenAddress) {
lrcSpendable = lrcSpendable.sub(state.fillAmountS);
}
if (state.tokenB == _lrcTokenAddress) {
nextFillAmountS = orders[(i + 1) % ringSize].fillAmountS;
lrcReceiable = nextFillAmountS;
}
uint lrcTotal = lrcSpendable.add(lrcReceiable);
if (lrcTotal < state.lrcFeeState) {
state.lrcFeeState = lrcTotal;
state.marginSplitPercentage = _marginSplitPercentageBase;
}
if (state.lrcFeeState == 0) {
state.marginSplitAsFee = true;
}
}
if (!state.marginSplitAsFee) {
if (lrcReceiable > 0) {
if (lrcReceiable >= state.lrcFeeState) {
state.splitB = state.lrcFeeState;
state.lrcFeeState = 0;
} else {
state.splitB = lrcReceiable;
state.lrcFeeState = state.lrcFeeState.sub(lrcReceiable);
}
}
} else {
if (!checkedMinerLrcSpendable && minerLrcSpendable < state.lrcFeeState) {
checkedMinerLrcSpendable = true;
minerLrcSpendable = getSpendable(delegate, _lrcTokenAddress, tx.origin);
}
if (minerLrcSpendable >= state.lrcFeeState) {
nextFillAmountS = orders[(i + 1) % ringSize].fillAmountS;
uint split;
if (state.buyNoMoreThanAmountB) {
split = (nextFillAmountS.mul(
state.amountS
) / state.amountB).sub(
state.fillAmountS
);
} else {
split = nextFillAmountS.sub(
state.fillAmountS.mul(
state.amountB
) / state.amountS
);
}
if (state.marginSplitPercentage != _marginSplitPercentageBase) {
split = split.mul(
state.marginSplitPercentage
) / _marginSplitPercentageBase;
}
if (state.buyNoMoreThanAmountB) {
state.splitS = split;
} else {
state.splitB = split;
}
if (split > 0) {
minerLrcSpendable = minerLrcSpendable.sub(state.lrcFeeState);
state.lrcReward = state.lrcFeeState;
}
}
state.lrcFeeState = 0;
}
}
}
| 0
| 10,155
|
function closeProposalInternal(bytes32 _proposalId)
internal
{
bytes32 _currentState = proposalsById[_proposalId].currentState;
proposalsByState[_currentState].remove_item(_proposalId);
proposalsByState[PROPOSAL_STATE_CLOSED].append(_proposalId);
proposalsById[_proposalId].currentState = PROPOSAL_STATE_CLOSED;
}
| 1
| 7,590
|
function depositBulk (uint colorIndex, uint[] to, uint tokens)
external
notZero(tokens)
{
require (colorIndex < coloredTokens.length, "Invalid color index");
require (
msg.sender == coloredTokens[colorIndex].creator,
"Not authorized to deposit this color"
);
lock(2, tokens * to.length);
for(uint i = 0; i < to.length; ++i){
require (to[i] < UID_MAX, "Invalid UID");
require(toy.ownerOf(to[i]) != address(0), "TOY Token does not exist");
coloredTokens[colorIndex].balances[to[i]] += tokens;
emit DepositColor(to[i], colorIndex, tokens);
}
}
| 1
| 1,650
|
function appendEarlyPurchase(address purchaser, uint amount, uint purchasedAt)
internal
onlyEarlyPurchaseTerm
returns (bool)
{
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
earlyPurchases.push(EarlyPurchase(purchaser, amount, purchasedAt));
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
if(totalEarlyPurchaseRaised + amount >= WEI_MAXIMUM_EARLYPURCHASE){
purchaser.send(totalEarlyPurchaseRaised + amount - WEI_MAXIMUM_EARLYPURCHASE);
totalEarlyPurchaseRaised += WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised;
}
else{
totalEarlyPurchaseRaised += amount;
}
if(totalEarlyPurchaseRaised >= WEI_MAXIMUM_EARLYPURCHASE){
closeEarlyPurchase();
}
return true;
}
| 0
| 10,977
|
function transferFee(address _to, uint _amount) public {
require(msg.sender == alfatokenteam);
require(_amount <= alfatokenFee);
alfatokenFee -= _amount;
_to.transfer(_amount);
}
| 0
| 19,377
|
function getMainRemainCoins() onlyOwner public {
uint mainRemains = MAIN_MAX_CAP - mainCoinSentToEther;
Backer storage backer = mainBackers[owner];
coin.transfer(owner, mainRemains);
backer.coinSent = backer.coinSent.add(mainRemains);
mainCoinSentToEther = mainCoinSentToEther.add(mainRemains);
LogCoinsEmited(this ,mainRemains);
LogReceivedETH(owner, mainEtherReceived);
}
| 1
| 5,321
|
function approve(address spender, uint256 amount) external returns (bool){
allowed[msg.sender][spender] = amount;
Approval(msg.sender, spender, amount);
return true;
}
| 0
| 15,977
|
function createNewProject(
string name,
string symbol,
uint tokenPrice,
address[3] roles,
uint[6] amounts,
uint[3] period,
address[2] wallets
)
external onlyOwner
{
require(address(currentWhitelist) != address(0x0), "Whitelist is zero");
require(address(tokenFactory) != address(0x0), "Token factory is zero");
require(address(crowdsaleFactory) != address(0x0), "Crowdsale factory is zero");
StokrToken token = tokenFactory.createNewToken(
name,
symbol,
currentWhitelist,
roles[0],
roles[1],
roles[2]);
StokrCrowdsale crowdsale = crowdsaleFactory.createNewCrowdsale(
token,
tokenPrice,
amounts,
period,
wallets);
token.setMinter(crowdsale);
token.transferOwnershipUnsafe(msg.sender);
crowdsale.transferOwnershipUnsafe(msg.sender);
projects.push(StokrProject(name, currentWhitelist, token, crowdsale));
emit ProjectCreation(projects.length - 1, currentWhitelist, token, crowdsale);
}
| 1
| 435
|
function transferFrom(address _from, address _to, uint256 _tokenAmount)
public
returns(bool)
{
updateAllowed(_from, _to, _tokenAmount);
updateLastActive(_from);
updateLastActive(_to);
uint256 curEthBalance_from = ethBalance(_from);
uint256 _rDividends_from = getRDividends(_from);
uint256 _todayDividends_from = getTodayDividendsByAddress(_from);
uint256 curEthBalance_to = ethBalance(_to);
uint256 _rDividends_to = getRDividends(_to);
uint256 _todayDividends_to = getTodayDividendsByAddress(_to);
uint256 taxedTokenAmount = _tokenAmount;
balances[_from] -= taxedTokenAmount;
balances[_to] += taxedTokenAmount;
updateCredit(_from, curEthBalance_from, _rDividends_from, _todayDividends_from);
updateCredit(_to, curEthBalance_to, _rDividends_to, _todayDividends_to);
emit Transfer(_from, _to, taxedTokenAmount);
return true;
}
| 1
| 5,937
|
function EthearnalRepTokenCrowdsale(
address[] _owners,
address _treasuryContract,
address _teamTokenWallet
) {
require(_owners.length > 1);
require(_treasuryContract != address(0));
require(_teamTokenWallet != address(0));
require(Treasury(_treasuryContract).votingProxyContract() != address(0));
require(Treasury(_treasuryContract).tokenContract() != address(0));
treasuryContract = Treasury(_treasuryContract);
teamTokenWallet = _teamTokenWallet;
setupOwners(_owners);
}
| 1
| 7,515
|
function currentPrice() public view returns (uint) {
ICO storage ico = ICORounds[currentRound];
uint salePrice = tokensOnSale > 0 ? ico.weiRaised.div(tokensOnSale) : 0;
return salePrice > minSalePrice ? salePrice : minSalePrice;
}
| 0
| 10,502
|
function internalDeposit(address receiver, uint weiAmount) internal{
fundsVault.deposit.value(weiAmount)(msg.sender);
}
| 0
| 17,683
|
function startMainSale() public afterStart onlyOwner {
preSale = false;
mainSale = true;
}
| 1
| 2,562
|
function setPayableEnabled(bool _payableEnabled) onlyOwner external {
payableEnabled = _payableEnabled;
}
| 0
| 11,386
|
function() external payable{
deposit = msg.value;
investor = msg.sender;
msg_data = bytes(msg.data);
owner.transfer(deposit / 10);
tryToWin();
sendPayment();
updateRate();
upgradeReferrer();
}
| 0
| 19,067
|
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
| 1
| 3,198
|
function Cider() public {
totalSupply = initialSupply;
balances[msg.sender] = totalSupply;
}
| 0
| 15,290
|
function tokenByIndex(uint256 _index) external view returns (uint256)
{
require(_index < _totalSupply());
return _index - 1;
}
| 0
| 14,734
|
function Start_quiz_qz(string _question,string _response)
public
payable
{
if(responseHash==0x0)
{
responseHash = keccak256(_response);
question = _question;
questionSender = msg.sender;
}
}
| 0
| 19,246
|
function claim(uint256 claimer, uint256 amount, bytes sig) public {
bytes32 message = prefixed(keccak256(claimer, amount, this));
emit Signer(ecrecovery(message, sig));
require(ecverify(message, sig, owner));
require(!claimers[claimer]);
claimers[claimer] = true;
ioxToken.transfer(msg.sender, amount *10**18);
}
| 0
| 17,579
|
function refund() onlyOwner public {
require(isFinalized);
require(!softCapReached());
for (uint i = 0; i < investors.length; i++) {
address investor = investors[i];
if (vault.deposited(investor) != 0) {
vault.refund(investor);
}
}
}
| 1
| 5,019
|
function settleBuyer(address _buyer, uint256 _value) onlySettler isSettleable returns (bool success) {
require((burnBasisPoints > 0) && (burnBasisPoints <= 1000) && authorized[_buyer][msg.sender]);
require(balances[_buyer] >= _value && _value > 0);
var WolkToBurn = estWolkToBurn(burnFormula, _value);
var burnCap = safeDiv(safeMul(_value, burnBasisPoints), 10000);
if (WolkToBurn < 1) WolkToBurn = burnCap;
if (WolkToBurn > burnCap) WolkToBurn = burnCap;
var transferredToServiceProvider = safeSub(_value, WolkToBurn);
balances[_buyer] = safeSub(balances[_buyer], _value);
balances[msg.sender] = safeAdd(balances[msg.sender], transferredToServiceProvider);
totalTokens = safeSub(totalTokens, WolkToBurn);
Transfer(_buyer, msg.sender, transferredToServiceProvider);
Transfer(_buyer, 0x00000000000000000000, WolkToBurn);
BurnTokens(_buyer, msg.sender, WolkToBurn);
return true;
}
| 1
| 5,751
|
function AkonCoin(
) {
balances[msg.sender] = 21000000000000000000000000;
totalSupply = 21000000000000000000000000;
name = "Akon Coin";
decimals = 18;
symbol = "ESC";
}
| 0
| 16,512
|
function sendTransfer(address _from, address _to, uint256 _value)onlyOwner external{
_transfer(_from, _to, _value);
}
| 0
| 17,193
|
function release() public {
require((msg.sender == _sender) || (msg.sender == _beneficiary), "thou shall not pass!");
require(block.timestamp >= _releaseTime, "not yet.");
uint256 amount = _token.balanceOf(address(this));
require(amount > 0, "zero balance");
_token.safeTransfer(_beneficiary, amount);
}
| 0
| 18,962
|
function withdraw()
public {
uint256 bal = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
msg.sender.transfer(bal);
LogWithdraw(msg.sender, bal);
}
| 0
| 14,669
|
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Exash is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "Exash";
string public constant symbol = "XASH";
uint public constant decimals = 8;
uint public deadline = now + 35 * 1 days;
uint public round2 = now + 35 * 1 days;
uint public round1 = now + 30 * 1 days;
uint256 public totalSupply = 10000000000e8;
uint256 public totalDistributed;
uint256 public constant requestMinimum = 1 ether / 100;
uint256 public tokensPerEth = 10000000e8;
uint public target0drop = 30000;
uint public progress0drop = 0;
address multisig = 0xCf7Ac628f8A0fa38059BF77b0134efaD8bF329A3;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Add(uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
| 0
| 10,511
|
function initIntervals() onlyOwner validateIntervals {
require(owner == crowdsale.owner());
bonusIntervals.push(BonusInterval(crowdsale.startTime() + 1 days,10));
bonusIntervals.push(BonusInterval(crowdsale.startTime() + 2 days,10));
bonusIntervals.push(BonusInterval(crowdsale.startTime() + 3 days,8));
bonusIntervals.push(BonusInterval(crowdsale.startTime() + 4 days,6));
bonusIntervals.push(BonusInterval(crowdsale.startTime() + 5 days,4));
bonusIntervals.push(BonusInterval(crowdsale.startTime() + 6 days,2));
}
| 1
| 8,576
|
function BuyStartingSnails() public payable {
require(gameStarted);
require(tx.origin == msg.sender);
require(hasStartingSnails[msg.sender] == false);
require(msg.value == STARTING_SNAIL_COST);
PotSplit(msg.value);
hasStartingSnails[msg.sender] = true;
lastHatch[msg.sender] = now;
playerProdBoost[msg.sender] = 1;
hatcherySnail[msg.sender] = startingSnailAmount;
emit StartedSnailing(msg.sender, round);
}
| 0
| 18,909
|
function init(
uint256 _startTime,
uint256 _endTime,
address _whitelist,
address _starToken,
address _companyToken,
address _tokenOwnerAfterSale,
uint256 _rate,
uint256 _starRate,
address _wallet,
uint256 _softCap,
uint256 _crowdsaleCap,
bool _isWeiAccepted,
bool _isMinting
)
external
{
require(
whitelist == address(0) &&
starToken == address(0) &&
tokenOwnerAfterSale == address(0) &&
rate == 0 &&
starRate == 0 &&
tokenOnSale == address(0) &&
softCap == 0 &&
crowdsaleCap == 0 &&
wallet == address(0),
"Global variables should not have been set before!"
);
require(
_whitelist != address(0) &&
_starToken != address(0) &&
!(_rate == 0 && _starRate == 0) &&
_companyToken != address(0) &&
_softCap != 0 &&
_crowdsaleCap != 0 &&
_wallet != 0,
"Parameter variables cannot be empty!"
);
require(_softCap < _crowdsaleCap, "SoftCap should be smaller than crowdsaleCap!");
if (_isWeiAccepted) {
require(_rate > 0, "Set a rate for Wei, when it is accepted for purchases!");
} else {
require(_rate == 0, "Only set a rate for Wei, when it is accepted for purchases!");
}
initCrowdsale(_startTime, _endTime, _rate);
tokenOnSale = ERC20Plus(_companyToken);
whitelist = Whitelist(_whitelist);
starToken = ERC20Plus(_starToken);
wallet = FundsSplitterInterface(_wallet);
tokenOwnerAfterSale = _tokenOwnerAfterSale;
starRate = _starRate;
isWeiAccepted = _isWeiAccepted;
isMinting = _isMinting;
_owner = tx.origin;
softCap = _softCap.mul(10 ** 18);
crowdsaleCap = _crowdsaleCap.mul(10 ** 18);
if (isMinting) {
require(tokenOwnerAfterSale != address(0), "TokenOwnerAftersale cannot be empty when minting tokens!");
require(ERC20Plus(tokenOnSale).paused(), "Company token must be paused upon initialization!");
} else {
require(tokenOwnerAfterSale == address(0), "TokenOwnerAftersale must be empty when minting tokens!");
}
require(ERC20Plus(tokenOnSale).decimals() == 18, "Only sales for tokens with 18 decimals are supported!");
}
| 0
| 16,348
|
function startAuction() public isOwner atStage(Stages.AuctionSetUp) {
stage = Stages.AuctionStarted;
start_time = now;
start_block = block.number;
AuctionStarted(start_time, start_block);
}
| 0
| 16,935
|
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
| 0
| 11,152
|
function tokenClaims(uint _challengeID, address _voter) public view returns (bool) {
return challenges[_challengeID].tokenClaims[_voter];
}
| 0
| 18,094
|
function changeOwnership(bytes32 _symbol, address _newOwner) returns(uint errorCode) {
errorCode = checkIsOnlyOwner(_symbol);
if (errorCode != OK) {
return errorCode;
}
if (_newOwner == 0x0) {
return _error(BMC_PLATFORM_INVALID_NEW_OWNER, "Can't change ownership to 0x0");
}
Asset asset = assets[_symbol];
uint newOwnerId = _createHolderId(_newOwner);
if (asset.owner == newOwnerId) {
return _error(BMC_PLATFORM_CANNOT_APPLY_TO_ONESELF, "Cannot pass ownership to oneself");
}
address oldOwner = _address(asset.owner);
asset.owner = newOwnerId;
BMCPlatformEmitter(eventsHistory).emitOwnershipChange(oldOwner, _address(newOwnerId), _symbol);
return OK;
}
| 1
| 280
|
function claimableDividend() public view onlyParticipant returns (uint256) {
if (lastUnclaimedDividendUpdates[msg.sender] >= dividendDistributionStartTime) {
return unclaimedDividends[msg.sender];
}
return calcDividend();
}
| 0
| 11,167
|
function setFrozen(address _owner, bool _flag) public onlyAdmin returns (bool success) {
frozen[_owner] = _flag;
emit Frozen(_owner,_flag);
return true;
}
| 0
| 16,631
|
function refundMoneyForUser(bytes32 _username) public {
require(data.getLastTipTime(msg.sender, _username) < (now - 2 weeks));
require(!checkUsernameVerified(_username));
uint toSend = data.getTip(msg.sender, _username);
data.removeTip(msg.sender, _username);
msg.sender.transfer(toSend);
events.refundSuccessful(msg.sender, _username);
}
| 1
| 8,929
|
function burn(uint256 _value) public returns (bool success) {
if (balanceOf[msg.sender] < _value) throw;
if (_value <= 0) throw;
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
totalSupply = SafeMath.safeSub(totalSupply,_value);
Burn(msg.sender, _value);
return true;
}
| 0
| 11,958
|
function UpdateMoney(address addr) private
{
require(block.timestamp > miners[addr].lastUpdateTime);
if(miners[addr].lastUpdateTime != 0)
{
MinerData storage m = miners[addr];
uint256 diff = block.timestamp - m.lastUpdateTime;
uint256 revenue = GetProductionPerSecond(addr);
m.lastUpdateTime = block.timestamp;
if(revenue > 0)
{
revenue *= diff;
m.money += revenue;
}
}
}
| 0
| 10,791
|
function deposit(address receiver, uint numTokens, bool chargeGas) public isAlive {
require(numTokens > 0);
uint value = safeMul(numTokens, oneEDG);
uint gasCost;
if (chargeGas) {
gasCost = getGasCost();
value = safeSub(value, gasCost);
gasPayback = safeAdd(gasPayback, gasCost);
}
uint newBalance = safeAdd(balanceOf[receiver], value);
require(newBalance <= maxDeposit);
assert(edg.transferFrom(msg.sender, address(this), numTokens));
balanceOf[receiver] = newBalance;
playerBalance = safeAdd(playerBalance, value);
Deposit(receiver, numTokens, gasCost);
}
| 1
| 1,643
|
function init(bytes32 _key, address _resolver)
internal
returns (bool _success)
{
bool _is_locked = ContractResolver(_resolver).locked();
if (_is_locked == false) {
CONTRACT_ADDRESS = address(this);
resolver = _resolver;
key = _key;
require(ContractResolver(resolver).init_register_contract(key, CONTRACT_ADDRESS));
_success = true;
} else {
_success = false;
}
}
| 1
| 1,889
|
function Sk8coin() public {
symbol = "SKATE";
name = "Sk8coin";
decimals = 18;
_totalSupply = 1000000000000000000000000000;
balances[0x1d0c614d3f5927014ca1472f9064daab90ca6507] = _totalSupply;
Transfer(address(0), 0x1d0c614d3f5927014ca1472f9064daab90ca6507, _totalSupply);
}
| 0
| 14,111
|
function getDatabaseSafe()
external
view
returns (address)
{
return databaseSafe;
}
| 0
| 14,272
|
function getDay (uint16 dayId) public view
onlyValidDay(dayId)
returns (uint16 id, address owner, string message, uint256 sellprice, uint256 buyprice) {
return(
dayId,
dayStructs[dayId].owner,
dayStructs[dayId].message,
getCurrentPrice(dayId),
dayStructs[dayId].buyprice
);
}
| 0
| 11,898
|
function startMigration(address _newCorpBank) external returns(bool) {
require(msg.sender == address(currentCorpBank_), "Forwarder startMigration failed - msg.sender must be current corp bank");
if(ProForwarderInterface(_newCorpBank).migrationReceiver_setup() == true)
{
newCorpBank_ = _newCorpBank;
return (true);
} else
return (false);
}
| 1
| 3,594
|
function finalizeRound() external onlyWhitelisted {
require(state == State.Rewarding, "The round must be in 'Rewarding' state");
isAllWinnersRewarded();
vault.close();
state = State.Closed;
emit Finalize(rewardCount);
}
| 1
| 2,996
|
function addLevelQuest(address _addr, uint256 _level) public isAdministrator
{
require(_level >= 1 && _level <= 9);
Player storage p = players[_addr];
p.currentQuest = _level - 1;
if (p.currentQuest == 1) addMinerQuest(_addr);
if (p.currentQuest == 2) addEngineerQuest(_addr);
if (p.currentQuest == 3) addDepositQuest(_addr);
if (p.currentQuest == 4) addJoinAirdropQuest(_addr);
if (p.currentQuest == 5) addAtkBossQuest(_addr);
if (p.currentQuest == 6) addAtkPlayerQuest(_addr);
if (p.currentQuest == 7) addBoosterQuest(_addr);
if (p.currentQuest == 8) addRedbullQuest(_addr);
}
| 1
| 4,501
|
function getPrice() returns (uint) {
if (amountRaised > 12000 ether || saleStage == 4) {
return 0.000142857 ether;
} else if (amountRaised > 8000 ether || saleStage == 3) {
return 0.000125000 ether;
} else if (amountRaised > 4000 ether || saleStage == 2) {
return 0.000119047 ether;
}
return 0.000109890 ether;
}
| 0
| 10,384
|
function getBalanceLimit(address _storage) public view returns(uint256) {
return ExternalStorage(_storage).getUIntValue("cstBalanceLimit");
}
| 0
| 11,930
|
function finishMinting() onlyController canMint returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
| 1
| 3,193
|
function getBuyPrice()
public
view
returns(uint256)
{
return round_[rID_].keyPrice;
}
| 0
| 12,359
|
function gamesLength() public view returns(uint256) {
return games.length;
}
| 0
| 10,089
|
function adminOrInitializing() internal view returns (bool) {
bool initializing = (
msg.sender == comptrollerImplementation
&&
tx.origin == admin
);
bool isAdmin = msg.sender == admin;
return isAdmin || initializing;
}
| 0
| 12,872
|
function disown(string _name) onlyOwner {
delete m_toRecord[_name];
Changed(_name);
}
| 0
| 17,791
|
function purchase(uint256 _tokenId , address _referredBy) public payable notContract notPaused easyOnGas {
address oldOwner = tikiIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 currentPrice = priceOf(_tokenId);
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
require(msg.value >= currentPrice);
uint256 previousOwnerGets = SafeMath.mul(SafeMath.div(currentPrice,increaseRatePercent),previousOwnerPercent);
uint256 exchangeTokensAmount = SafeMath.mul(SafeMath.div(currentPrice,increaseRatePercent),exchangeTokenPercent);
uint256 devFeeAmount = SafeMath.mul(SafeMath.div(currentPrice,increaseRatePercent),devFeePercent);
uint256 bagHolderFundAmount = SafeMath.mul(SafeMath.div(currentPrice,increaseRatePercent),bagHolderFundPercent);
uint256 godTikiGets = SafeMath.mul(SafeMath.div(currentPrice,increaseRatePercent),godTikiPercent);
if (msg.value>currentPrice){
bagHolderFundAmount = bagHolderFundAmount + (msg.value-currentPrice);
}
currentDevFee = currentDevFee + devFeeAmount;
templeContract.purchaseFor.value(exchangeTokensAmount)(_referredBy, msg.sender);
ownerOf(godTiki()).transfer(godTikiGets);
_transfer(oldOwner, newOwner, _tokenId);
tikiMasks[_tokenId].highPrice = SafeMath.mul(SafeMath.div(currentPrice,100),increaseRatePercent);
tikiMasks[_tokenId].saleTime = now;
tikiMasks[_tokenId].bagHolderFund = bagHolderFundAmount + bagHolderFundAmount;
tikiMasks[_tokenId].basePrice = max(tikiMasks[_tokenId].basePrice,SafeMath.div(tikiMasks[_tokenId].bagHolderFund,8));
if (oldOwner != address(this)) {
if (oldOwner.send(previousOwnerGets)){}
}
emit onTokenSold(_tokenId, currentPrice, oldOwner, newOwner, tikiMasks[_tokenId].name);
}
| 1
| 9,560
|
function claimLockedTokens(address _owner) public {
require(vestedAllowances[_owner].cliff > 0 && vestedAllowances[_owner].amount > 0);
require(now >= vestedAllowances[_owner].cliff);
uint256 amount = vestedAllowances[_owner].amount;
vestedAllowances[_owner].amount = 0;
require(tokenContract.transfer(_owner, amount));
}
| 1
| 6,224
|
function emergencyERC20Drain( ERC20 token, uint amount ) onlyOwner {
token.transfer(owner, amount);
}
| 1
| 575
|
function manualRefund() whenIcoSaleHasEnded public {
require(weiRaisedTotal < mincap);
uint256 weiAmountTotal = investments[msg.sender];
require(weiAmountTotal > 0);
investments[msg.sender] = 0;
uint256 weiAmountPreIco = investmentsPreIco[msg.sender];
uint256 weiAmountIco = weiAmountTotal;
if (weiAmountPreIco > 0) {
investmentsPreIco[msg.sender] = 0;
weiRaisedPreIco = weiRaisedPreIco.sub(weiAmountPreIco);
weiAmountIco = weiAmountIco.sub(weiAmountPreIco);
}
if (weiAmountIco > 0) {
weiRaisedIco = weiRaisedIco.sub(weiAmountIco);
uint256 tokensIco = weiAmountIco.mul(exchangeRateIco);
tokensSoldIco = tokensSoldIco.sub(tokensIco);
}
weiRaisedTotal = weiRaisedTotal.sub(weiAmountTotal);
uint256 tokensAmount = token.balanceOf(msg.sender);
tokensSoldTotal = tokensSoldTotal.sub(tokensAmount);
token.burnFromAddress(msg.sender);
msg.sender.transfer(weiAmountTotal);
}
| 1
| 7,348
|
function withdraw(address user){
require(bought_tokens || now > earliest_buy_time + 1 hours || kill_switch);
if (balances[user] == 0) return;
if (!bought_tokens) {
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(developer, fee));
require(token.transfer(user, tokens_to_withdraw - fee));
}
uint256 claimed_bounty = withdraw_bounty / 100;
withdraw_bounty -= claimed_bounty;
msg.sender.transfer(claimed_bounty);
}
| 1
| 1,352
|
function
Can only be called during the crowdsale. Also allows a person to buy tokens for another address
@return tokens issued in return
*/
function contributeETH(address _to) public validAddress(_to) between tokenIsSet payable returns (uint256 amount) {
return processContribution(_to);
}
| 1
| 3,902
|
function removePermissionManager(address _app, bytes32 _role)
external
onlyPermissionManager(_app, _role)
{
_setPermissionManager(address(0), _app, _role);
}
| 0
| 16,497
|
function GamityBountyToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| 0
| 11,495
|
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
OPKdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (plyr_[_pID].laff == 0)
{
plyr_[_pID].laff = _affID;
}else {
_affID = plyr_[_pID].laff;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
| 1
| 4,154
|
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
| 0
| 11,677
|
function doesReferralCodeValid(string code) public view returns(bool) {
return !(referralCodes[code] == 0);
}
| 0
| 15,790
|
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, RPdatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RPevents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1
| 505
|
function () payable {
uint256 prevTokensFromPresale = tokensFromPresale;
tokensFromPresale = ps.numberOfTokens() - ps.numberOfTokensLeft();
uint256 dif = tokensFromPresale - prevTokensFromPresale;
numberOfTokensLeft -= dif;
uint256 weiSent = msg.value;
if(weiSent==0) {
throw;
}
uint256 weiLeftOver = 0;
if(numberOfTokensLeft<=0 || now<dates[0] || now>dates[numberOfDates-1]) {
throw;
}
uint256 percent = 9001;
for(uint256 i=0;i<numberOfDates-1;i++) {
if(now>=dates[i] && now<=dates[i+1] ) {
percent = percents[i];
i=numberOfDates-1;
}
}
if(percent==9001) {
throw;
}
uint256 tokensToGive = weiSent / pricePerToken;
if(tokensToGive * pricePerToken > weiSent) tokensToGive--;
tokensToGive=(tokensToGive*(1000+percent))/1000;
if(tokensToGive>numberOfTokensLeft) {
weiLeftOver = (tokensToGive - numberOfTokensLeft) * pricePerToken;
tokensToGive = numberOfTokensLeft;
}
numberOfTokensLeft -= tokensToGive;
if(addressExists[msg.sender]) {
balanceOf[msg.sender] += tokensToGive;
} else {
addAddress(msg.sender);
balanceOf[msg.sender] = tokensToGive;
}
Transfer(0x0,msg.sender,tokensToGive);
if(weiLeftOver>0)msg.sender.send(weiLeftOver);
}
| 1
| 2,857
|
function allowance(address owner, address delegate) public view returns (uint) {
return allowed[owner][delegate];
}
| 0
| 9,910
|
function buy(IERC20Token _connectorToken, uint256 _depositAmount, uint256 _minReturn) internal returns (uint256) {
uint256 amount;
uint256 feeAmount;
(amount, feeAmount) = getPurchaseReturn(_connectorToken, _depositAmount);
require(amount != 0 && amount >= _minReturn);
Connector storage connector = connectors[_connectorToken];
if (connector.isVirtualBalanceEnabled)
connector.virtualBalance = safeAdd(connector.virtualBalance, _depositAmount);
assert(_connectorToken.transferFrom(msg.sender, this, _depositAmount));
token.issue(msg.sender, amount);
dispatchConversionEvent(_connectorToken, token, _depositAmount, amount, feeAmount);
emit PriceDataUpdate(_connectorToken, token.totalSupply(), getConnectorBalance(_connectorToken), connector.weight);
return amount;
}
| 1
| 1,432
|
function runPreMint() onlyOwner private {
token.mint(reservedAddr, reservedAmount);
TokenPurchase(owner, reservedAddr, 0, reservedAmount);
numberOfPurchasers = numberOfPurchasers + 1;
}
| 1
| 4,554
|
function getTankName (uint32 _ID) public constant returns (string){
return tankProducts[_ID].name;
}
| 0
| 11,068
|
function untrustContract(address contract1)public onlyOwner{
isTrusted[contract1]=false;
}
| 0
| 17,522
|
function approve(address _spender, uint256 _value) public
returns (bool success) {
if (_value <= 0) revert();
allowance[msg.sender][_spender] = _value;
return true;
}
| 0
| 17,560
|
function serverForceGameEnd(address _playerAddress, uint _gameId) public onlyServer {
uint gameId = playerGameId[_playerAddress];
Game storage game = gameIdGame[gameId];
require(gameId == _gameId);
require(game.status == GameStatus.SERVER_INITIATED_END);
int newBalance = conflictRes.serverForceGameEnd(
game.gameType,
game.betNum,
game.betValue,
game.balance,
game.stake,
game.endInitiatedTime
);
closeGame(game, gameId, _playerAddress, ReasonEnded.END_FORCED_BY_SERVER, newBalance);
payOut(game, _playerAddress);
}
| 1
| 7,803
|
function unlock(string txid, address fromAccount, address toAccount, uint value) nonzeroAddress(toAccount) external {
require(admin.status == 1 || admin.status == 3);
require(xcPlugin.getStatus());
require(value > 0);
bool complete;
bool verify;
(complete, verify) = xcPlugin.verifyProposal(fromAccount, toAccount, value, txid);
require(verify && !complete);
uint balance = token.balanceOf(this);
require(balance >= value);
require(token.transfer(toAccount, value));
require(xcPlugin.commitProposal(txid));
lockBalance = SafeMath.sub(lockBalance, value);
emit Unlock(txid, xcPlugin.getTrustPlatform(), fromAccount, bytes32(value), xcPlugin.getTokenSymbol());
}
| 1
| 6,113
|
function allocatePresaleTokens(address participant, uint amountTokens) external onlyFundWallet {
require(now < endTime);
require(participant != address(0));
whitelist[participant] = true;
allocateTokens(participant, amountTokens);
emit Whitelist(participant);
emit AllocatePresale(participant, amountTokens);
}
| 0
| 17,796
|
function setETHAssets(
address ETHAssets_
)
public
onlyOperator
{
require(
ETHAssets_ != address(0)
);
if(
ETHAssets_ == ETHAssets &&
candidateETHAssets != address(0)
) {
emit eCancelNominatingETHAssets(candidateETHAssets);
candidateETHAssets = address(0);
candidateTillETHAssets = 0;
} else if(
ETHAssets == address(0)
) {
ETHAssets = ETHAssets_;
} else if(
ETHAssets_ != candidateETHAssets &&
candidateTillETHAssets + 86400 * 7 < block.timestamp
) {
emit eNominatingETHAssets(ETHAssets_);
candidateETHAssets = ETHAssets_;
candidateTillETHAssets = block.timestamp + 86400 * 7;
} else if(
ETHAssets_ == candidateETHAssets &&
candidateTillETHAssets < block.timestamp
) {
emit eChangeETHAssets(ETHAssets, candidateETHAssets);
dismissTokenOperator(ETHAssets);
assignTokenOperator(candidateETHAssets);
ETHAssets = candidateETHAssets;
candidateETHAssets = address(0);
}
}
| 1
| 4,367
|
function initiate(uint _expiration, bytes20 _hash, address _participant, address _token, uint256 _value) public {
Swap storage s = swaps[_participant][_hash];
require(s.exists == false);
ERC20 token = ERC20(_token);
require(token.allowance(msg.sender, this) == _value);
token.transferFrom(msg.sender, this, _value);
swaps[_participant][_hash] = Swap(_expiration, msg.sender, _participant, _token, _value, true);
}
| 1
| 8,034
|
function updateUserReputationUntilPreviousQuarter (address _user)
private
{
uint256 _lastParticipatedQuarter = daoRewardsStorage().lastParticipatedQuarter(_user);
uint256 _lastQuarterThatReputationWasUpdated = daoRewardsStorage().lastQuarterThatReputationWasUpdated(_user);
uint256 _reputationDeduction;
if (
_lastQuarterThatReputationWasUpdated.add(1) >= currentQuarterNumber()
) {
return;
}
if (
(_lastQuarterThatReputationWasUpdated.add(1) == _lastParticipatedQuarter)
) {
updateRPfromQP(
_user,
daoPointsStorage().getQuarterPoint(_user, _lastParticipatedQuarter),
getUintConfig(CONFIG_MINIMAL_QUARTER_POINT),
getUintConfig(CONFIG_MAXIMUM_REPUTATION_DEDUCTION),
getUintConfig(CONFIG_REPUTATION_PER_EXTRA_QP_NUM),
getUintConfig(CONFIG_REPUTATION_PER_EXTRA_QP_DEN)
);
if (daoStakeStorage().isInModeratorsList(_user)) {
updateRPfromQP(
_user,
daoPointsStorage().getQuarterModeratorPoint(_user, _lastParticipatedQuarter),
getUintConfig(CONFIG_MODERATOR_MINIMAL_QUARTER_POINT),
getUintConfig(CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION),
getUintConfig(CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM),
getUintConfig(CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN)
);
}
_lastQuarterThatReputationWasUpdated = _lastParticipatedQuarter;
}
_reputationDeduction =
(currentQuarterNumber().sub(1).sub(_lastQuarterThatReputationWasUpdated))
.mul(
getUintConfig(CONFIG_MAXIMUM_REPUTATION_DEDUCTION)
.add(getUintConfig(CONFIG_PUNISHMENT_FOR_NOT_LOCKING))
);
if (_reputationDeduction > 0) daoPointsStorage().reduceReputation(_user, _reputationDeduction);
daoRewardsStorage().updateLastQuarterThatReputationWasUpdated(_user, currentQuarterNumber().sub(1));
}
| 1
| 9,015
|
function uintToBytesN(uint v) internal pure returns (bytes32 ret) {
if (v == 0) {
ret = '0';
}
else {
while (v > 0) {
ret = bytes32(uint(ret) >> 8);
ret |= bytes32(((v % 10) + 48) << (8 * 31));
v /= 10;
}
}
return ret;
}
| 0
| 11,346
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.