func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function freezeOf(address _owner) public view returns (uint256) {
return freezes[_owner];
}
| 0 | 13,817 |
function depositToken(address token, uint amount) public {
require(token!=0);
require(StandardToken(token).transferFrom(msg.sender, this, amount));
tokens[token][msg.sender] = tokens[token][msg.sender].add(amount);
emit Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
| 1 | 421 |
function fundTransfer(uint256 weiAmount) internal {
beneficiaryAddress.transfer(weiAmount);
}
| 0 | 9,963 |
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, NTech3DDatasets.EventReturns memory _eventData_)
private returns(NTech3DDatasets.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].nt)) / 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 | 9,898 |
function compute() constant returns (bytes32, bool) {
bytes32[] memory wuts = new bytes32[](uint96(next) - 1);
uint96 ctr = 0;
for (uint96 i = 1; i < uint96(next); i++) {
if (values[bytes12(i)] != 0) {
var (wut, wuz) = DSValue(values[bytes12(i)]).peek();
if (wuz) {
if (ctr == 0 || wut >= wuts[ctr - 1]) {
wuts[ctr] = wut;
} else {
uint96 j = 0;
while (wut >= wuts[j]) {
j++;
}
for (uint96 k = ctr; k > j; k--) {
wuts[k] = wuts[k - 1];
}
wuts[j] = wut;
}
ctr++;
}
}
}
if (ctr < min) return (val, false);
bytes32 value;
if (ctr % 2 == 0) {
uint128 val1 = uint128(wuts[(ctr / 2) - 1]);
uint128 val2 = uint128(wuts[ctr / 2]);
value = bytes32(wdiv(hadd(val1, val2), 2 ether));
} else {
value = wuts[(ctr - 1) / 2];
}
return (value, true);
}
| 1 | 9,350 |
function tokenApprovalWithSignature(address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, bytes32 sigHash, bytes signature) internal returns (bool success)
{
address recoveredSignatureSigner = ECRecovery.recover(sigHash,signature);
require(from == recoveredSignatureSigner);
require(msg.sender == getRelayingKing()
|| msg.sender == from
|| msg.sender == to);
require(block.number < expires);
uint burnedSignature = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x1;
if(burnedSignature != 0x0 ) revert();
allowed[token][from][msg.sender] = relayerReward;
Approval(from, token, msg.sender, relayerReward);
if(!transferTokensFrom(from, msg.sender, token, relayerReward)) revert();
allowed[token][from][to] = tokens;
Approval(from, token, to, tokens);
return true;
}
| 1 | 2,306 |
function setUpdateOperator(uint256 assetId, address operator) external onlyOwnerOf(assetId) {
updateOperator[assetId] = operator;
emit UpdateOperator(assetId, operator);
}
| 1 | 8,465 |
function computeBonus(uint256 _incharge) internal {
if(BonusState(bonusState).getSettlementTime()<=now){
BonusState(bonusState).setComputedTotalBalance((address(this).balance).sub(_incharge));
BonusState(bonusState).setComputedUnitPrice((address(this).balance).sub(_incharge).div(totalSupply.div(10**decimals)));
bonusState_fixed = bonusState;
bonusState = new BonusState(address(this));
}
}
| 1 | 171 |
function bid(uint256 _wave, uint256 _tokenId) external payable whenNotPaused {
require(ethernautsStorage.ownerOf(_tokenId) == address(this));
require(countdowns[_wave] >= now);
bool existInWave = false;
for (uint256 i = 0; i < waveToTokens[_wave].length; i++) {
if (waveToTokens[_wave][i] == _tokenId) {
existInWave = true;
break;
}
}
require(existInWave);
address oldBuyer = tokenToBuyer[_tokenId];
uint256 sellingPrice = ethernautsStorage.priceOf(_tokenId);
require(msg.sender != address(0));
require(msg.value > sellingPrice);
sellingPrice = msg.value;
uint256 newPrice = SafeMath.div(SafeMath.mul(sellingPrice, bonus[_wave]), percBase);
uint256 lastPrice = tokenToLastPrice[_tokenId];
tokenToLastPrice[_tokenId] = sellingPrice;
ethernautsStorage.setPrice(_tokenId, newPrice);
tokenToBuyer[_tokenId] = msg.sender;
if (oldBuyer != address(0)) {
oldBuyer.transfer(lastPrice);
}
Bid(_tokenId, sellingPrice, newPrice, oldBuyer, msg.sender);
}
| 1 | 3,956 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, MC2datasets.EventReturns memory _eventData_)
private
returns(MC2datasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _up;
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_up = _com;
_com = 0;
}
uint256 _long = _eth / 100;
otherMC2_.potSwap.value(_long)();
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit MC2events.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_up = _aff;
}
_up = _up.add((_eth.mul(fees_[_team].up)) / (100));
if (_up > 0)
{
Divies.deposit.value(_up)();
_eventData_.UPAmount = _up.add(_eventData_.UPAmount);
}
return(_eventData_);
}
| 1 | 5,606 |
function */
Players[myid].queryResult2 = stringToUint(result);
if(Players[myid].queryResult1 > Players[myid].queryResult2)
{
DOWN_totalBets++;
DOWN_winBets++;
DOWN_winRate = DOWN_winBets*10000/DOWN_totalBets;
DOWN_etherWin = DOWN_etherWin+((Players[myid].playerbetvalue *75)/100);
DownPlayerResult("WIN",Players[myid].playerAddress,Players[myid].queryResult1,Players[myid].queryResult2,now);
winnerReward(Players[myid].playerAddress,Players[myid].playerbetvalue);
}
| 1 | 5,811 |
function withdrawEther(uint256 amount) onlyOwner{
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
if(msg.sender != owner)throw;
owner.transfer(amount);
}
| 0 | 17,402 |
function finalize()
external
tdeEnded
onlyOwner
{
require(!isFinalized);
uint256 teamVestingCliff = 15778476;
uint256 teamVestingDuration = 1 years;
TokenVesting teamVesting = new TokenVesting(owner, now, teamVestingCliff, teamVestingDuration, true);
teamVesting.transferOwnership(owner);
teamVestingAddress = address(teamVesting);
balances[teamVestingAddress] = FT_TEAM_FUND;
if (!capReached) {
uint256 unsoldVestingCliff = 3 years;
uint256 unsoldVestingDuration = 10 years;
TokenVesting unsoldVesting = new TokenVesting(owner, now, unsoldVestingCliff, unsoldVestingDuration, true);
unsoldVesting.transferOwnership(owner);
unsoldVestingAddress = address(unsoldVesting);
balances[unsoldVestingAddress] = FT_TOKEN_SALE_CAP - fttIssued;
}
balances[operationalReserveAddress] = FT_OPERATIONAL_FUND - FT_TEAM_FUND;
isFinalized = true;
TdeFinalized(block.timestamp);
}
| 1 | 8,462 |
function tokensToWei(uint256 _tokenAmount) public view returns (uint256) {
require(tokenNAVMicroUSD != uint256(0));
require(weiPerUSD != uint256(0));
return _tokenAmount.mul(tokenNAVMicroUSD).mul(weiPerUSD).div(million);
}
| 0 | 11,380 |
function tokenFallback(address _from, uint _value, bytes)
public {
require(msg.sender == phxAddress);
require(_value >= stakingRequirement);
payout();
balance = balance.add(_value);
lastFund = now;
lastFunder = _from;
}
| 1 | 1,725 |
function bleach(uint128 skinId, uint128 attributes) external payable whenNotPaused {
require(isBleachAllowed);
if (bleachLastClearTime[msg.sender] == uint256(0)) {
bleachLastClearTime[msg.sender] = now;
} else {
if (bleachLastClearTime[msg.sender] < levelClearTime && now > levelClearTime) {
accountToBleachNum[msg.sender] = 0;
bleachLastClearTime[msg.sender] = now;
}
}
require(accountToBleachNum[msg.sender] < bleachDailyLimit);
accountToBleachNum[msg.sender] += 1;
require(msg.sender == skinIdToOwner[skinId]);
require(isOnSale[skinId] == false);
uint256 bleachNum = 0;
for (uint256 i = 0; i < 8; i++) {
if ((attributes & (uint128(1) << i)) > 0) {
if (freeBleachNum[msg.sender] > 0) {
freeBleachNum[msg.sender]--;
} else {
bleachNum++;
}
}
}
require(msg.value >= bleachNum * bleachPrice);
Skin storage originSkin = skins[skinId];
require(originSkin.mixingWithId == 0);
uint128 newAppearance = mixFormula.bleachAppearance(originSkin.appearance, attributes);
originSkin.appearance = newAppearance;
emit Bleach(skinId, newAppearance);
}
| 1 | 8,938 |
function tokenFallback(address _from, uint _value, bytes _data) public {
require(_from == tx.origin);
require(msg.sender == mainContract);
require(isOpen);
address oldowner;
if(uint8(_data[0]) == 1){
withdraw(1);
require(card1.price == _value);
card1.price = _value.mul(2);
oldowner = card1.owner;
card1.owner = _from;
ChickenParkCoin.transfer(oldowner, _value.mul(80) / 100);
} else if(uint8(_data[0]) == 2){
withdraw(2);
require(card2.price == _value);
card2.price = _value.mul(2);
oldowner = card2.owner;
card2.owner = _from;
ChickenParkCoin.transfer(oldowner, _value.mul(80) / 100);
} else if(uint8(_data[0]) == 3){
withdraw(3);
require(card3.price == _value);
card3.price = _value.mul(2);
oldowner = card3.owner;
card3.owner = _from;
ChickenParkCoin.transfer(oldowner, _value.mul(80) / 100);
}
}
| 0 | 15,829 |
function DIVIUMx2()
public
{
administrators[0x703e04F6162f0f6c63F397994EbbF372a90e3d1d] = true;
ambassadors_[0x480bc57cE5BDA76c60A3B74abff50ce4D1F17c1e] = true;
ambassadors_[0x2116a113E7FbC5ce43eFC333720dB7eB56332780] = true;
ambassadors_[0x0C4a9Ebd53E82cC6eb714Fa009C65e9386F76743] = true;
}
| 0 | 9,756 |
function addFunds() payable public {
if (msg.sender != feeAddress) {
msg.sender.transfer(msg.value);
}
}
| 0 | 9,974 |
function initiateLocking (uint256 _alreadyTransferredTokens) public {
require(msg.sender == objMetadata.getAddress(crowdsaleContractID) && startBlock == 0);
startBlock = now;
unlockedTokens = 0;
balance = objCrowdsale.balanceOf(this);
totalSupplyFromInventory = _alreadyTransferredTokens;
totalRemainInInventory = balance.Add(_alreadyTransferredTokens).Sub(_alreadyTransferredTokens);
StateChanged(true);
}
| 1 | 9,035 |
function appendToList(address payable _addr) private {
players.push(_addr);
}
| 0 | 18,862 |
function buy() payable {
if(isSelling == false) revert();
uint amount = msg.value * buyPrice;
balanceOf[msg.sender] += amount;
balanceOf[owner] -= amount;
Transfer(owner, msg.sender, amount);
}
| 0 | 14,063 |
function proposeProxy(bytes _resolution)
external
returns (ProposalInterface)
{
ProperProposal proposal;
bytes memory clone = hex"600034603b57602f80600f833981f3600036818037808036816f5fbe2cc9b1b684ec445caf176042348e5af415602c573d81803e3d81f35b80fd";
assembly {
let data := add(clone, 0x20)
proposal := create(0, data, 58)
}
proposal.init(msg.sender, _resolution);
accounts[proposal].membership |= PROPOSAL;
Proposal(proposal);
return proposal;
}
| 1 | 904 |
function _appendAccountIssuanceRecord()
internal
{
uint initialDebtOwnership;
uint debtEntryIndex;
(initialDebtOwnership, debtEntryIndex) = synthetixState.issuanceData(messageSender);
feePool.appendAccountIssuanceRecord(
messageSender,
initialDebtOwnership,
debtEntryIndex
);
}
| 1 | 3,494 |
function SiringClockAuction(address _nftAddr, uint256 _cut) public
ClockAuction(_nftAddr, _cut) {}
| 1 | 8,346 |
function ERC20Token(
) {
balances[msg.sender] = 300000000000000000000000000;
totalSupply = 3000000000000000000000000;
name = "Vinyl";
decimals = 18;
symbol = "VYN";
}
| 0 | 15,063 |
function setPrice(uint256 _tokenId, uint256 _ethPrice, uint256 _usdtPrice) public {
require(erc721Address.ownerOf(_tokenId) == msg.sender);
prices[_tokenId] = Price(msg.sender, _ethPrice, 0, 0);
usdtPrices[_tokenId] = Price(msg.sender, _usdtPrice, 0, 0);
}
| 1 | 7,797 |
function unfreeze() external onlyUnpaused onlyEmergency {
require(crowdsalePhase != CrowdsalePhase.PhaseOne);
tokenContract.unfreeze();
}
| 0 | 9,739 |
function rollOne(address referral, uint8 number)
external payable isValidBet(rewardOne) bankNotEmpty {
require(isValidNumber(number));
bets[msg.sender]++;
splitTheBet(referral);
uint8[5] memory numbers = [number, 0, 0, 0, 0];
uint8[5] memory randoms = [getRN(), 0, 0, 0, 0];
emit UserBet(msg.sender, number, 0, 0, 0, 0);
emit DiceRoll(randoms[0], 0, 0, 0, 0);
if (isWinner(1, numbers, randoms)) {
rewardTheWinner(rewardOne);
} else {
emit Loser(msg.sender);
}
}
| 1 | 7,396 |
function Game()
{
oraclize_setProof(proofType_Ledger);
}
| 1 | 6,089 |
function moveOldUser (uint id) public {
address inviter;
address itself;
uint totalPayout;
(inviter, itself, totalPayout) = eth1.getParticipantById(id);
if ((Tree[itself].inviter != 0x0) || (id >= oldUserCount)) throw;
addParticipant(inviter, itself, totalPayout);
}
| 1 | 2,080 |
function burn(uint256 _value) onlyPayloadSize(32) public onlyOwner whenNotPaused
returns (bool success) {
require(!deprecated);
require(ARCCheck.maximumCirculation() < valueTotalSupply);
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
valueTotalSupply = valueTotalSupply.sub(_value);
Burn(msg.sender, _value);
return true;
}
| 1 | 7,928 |
function vestedAmount(ERC20 _token) public view returns (uint256) {
uint256 currentBalance = _token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[_token]);
uint256 totalPhased = (start.add(duration).sub(cliff)).div(phased);
uint256 everyPhasedReleaseAmount = totalBalance.div(totalPhased);
if (block.timestamp < cliff.add(phased)) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[_token]) {
return totalBalance;
} else {
uint256 currentPhased = block.timestamp.sub(cliff).div(phased);
return everyPhasedReleaseAmount.mul(currentPhased);
}
}
| 0 | 16,868 |
function BuyTorpedo( int256 score, uint256 torpedoBatchID, address _referrer_address , bytes32 r , bytes32 s , uint8 v ) public payable
onlyDirectTransaction
{
address _customer_address = msg.sender;
uint256 eth = msg.value;
require( maintenanceMode==false && this_gRND>0 && (eth==minimumSharePrice || eth==minimumSharePrice*10 || eth==minimumSharePrice*100) && (block.number <GameRoundData[ this_gRND ].blockNumberTimeout));
GameVar_s memory gamevar;
gamevar.score = score;
gamevar.torpedoBatchID = torpedoBatchID;
gamevar.r = r;
gamevar.s = s;
gamevar.v = v;
gamevar.multiplier =uint32( eth / minimumSharePrice);
CoreBuyTorpedo( _customer_address , eth , _referrer_address, gamevar);
}
| 1 | 7,933 |
function airdrop()
private
view
returns(bool)
{
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)).add
(block.number)
)));
if((seed - ((seed / 100) * 100)) < selfOdds[msg.sender])
return(true);
else
return(false);
}
| 0 | 15,108 |
function transferOwnership(uint256 _prpsIdx) public isOwner isPrpsExists(_prpsIdx) multiSig(_prpsIdx) {
require(proposals[_prpsIdx].prpsType == ProposalType.transferOwner, "");
address oldOwnerAddr = proposals[_prpsIdx].fromAddr;
address newOwnerAddr = proposals[_prpsIdx].toAddr;
require(oldOwnerAddr != address(0), "");
require(newOwnerAddr != address(0), "");
require(oldOwnerAddr != newOwnerAddr, "");
for(uint256 i = 0; i < owners.length; i++) {
if( owners[i] == oldOwnerAddr){
owners[i] = newOwnerAddr;
delete isOwnerMap[oldOwnerAddr];
isOwnerMap[newOwnerAddr] = true;
}
}
proposals[_prpsIdx].finalized = true;
emit OwnershipTransferred(oldOwnerAddr, newOwnerAddr);
}
| 0 | 12,177 |
function deploy() public onlyOwner {
token = new QBEToken();
presale = new Presale();
presale.setToken(token);
presale.addStage(10,3000);
presale.setMultisigWallet(0x4c076e99d9E8cFC647E1807D89506189d4256Ee1);
presale.setStart(1509393730);
presale.setPeriod(1);
presale.setMinPrice(100000000000000000);
token.setSaleAgent(presale);
mainsale = new Mainsale();
mainsale.setToken(token);
mainsale.addStage(100,1500);
mainsale.setMultisigWallet(0xf32737F7779cA2D20c017Da8F51b2DF99F86A221);
mainsale.setFoundersTokensWallet(0x5b819179C8Ba84FB4a517Dd566cb09Ff4b8a277f);
mainsale.setBountyTokensWallet(0x7D2b00C23aDab97152aaB6588A50FcEdCEbD58e4);
mainsale.setUnsoldTokensWallet(0xAE5e64280eD777c6D2bb8EddfeF2394A21f147DD);
mainsale.setStart(1509393800);
mainsale.setPeriod(1);
mainsale.setLockPeriod(1);
mainsale.setMinPrice(100000000000000000);
mainsale.setFoundersTokensReserve(20 * (10**6) * 10**18);
mainsale.setBountyTokensReserve(10 * (10**6) * 10**18);
mainsale.setMaxTokenSupply(100 * (10**6) * 10**18);
presale.setMainsale(mainsale);
token.transferOwnership(owner);
presale.transferOwnership(owner);
mainsale.transferOwnership(owner);
}
| 1 | 9,316 |
function claim(address _beneficiary) public returns(bytes32) {
require(avatar != Avatar(0), "should initialize first");
address beneficiary;
if (_beneficiary == address(0)) {
beneficiary = msg.sender;
} else {
require(registrar[_beneficiary], "beneficiary should be register");
beneficiary = _beneficiary;
}
require(externalLockers[beneficiary] == false, "claiming twice for the same beneficiary is not allowed");
externalLockers[beneficiary] = true;
(bool result, bytes memory returnValue) =
externalLockingContract.call(abi.encodeWithSignature(getBalanceFuncSignature, beneficiary));
require(result, "call to external contract should succeed");
uint256 lockedAmount;
assembly {
lockedAmount := mload(add(returnValue, 0x20))
}
return super._lock(lockedAmount, 1, beneficiary, 1, 1);
}
| 0 | 18,053 |
function play(uint256 combinations, uint256 answer) public payable {
uint256 answerSize = _countBits(answer);
uint256 possibleReward = msg.value.mul(combinations).div(answerSize);
require(minReward <= possibleReward && possibleReward <= maxReward, "Possible reward value out of range");
require(possibleReward <= address(this).balance.mul(maxRewardPercent).div(100), "Possible reward value out of range");
require(answer > 0 && answer < (1 << combinations) - 1, "Answer should not contain all bits set");
require(2 <= combinations && combinations <= 100, "Combinations value is invalid");
updateState();
uint256 blockNumber = block.number + 1;
emit GameStarted(
msg.sender,
blockNumber,
games.length,
combinations,
answer,
msg.value
);
games.push(Game({
player: msg.sender,
blockNumber: blockNumber,
value: msg.value,
combinations: combinations,
answer: answer,
salt: nextJackpot.totalLength()
}));
(uint256 begin, uint256 end) = nextJackpot.addRange(msg.sender, msg.value);
emit JackpotRangeAdded(
prevJackpots.length,
msg.sender,
begin,
end
);
totalWeisInGame = totalWeisInGame.add(possibleReward);
require(totalWeisInGame <= address(this).balance, "Not enough balance");
}
| 1 | 2,645 |
function batchReturnEthIfFailed(uint256 _numberOfReturns) onlyOwner{
if (block.number < endBlock || totalEthRaised >= minEthToRaise) throw;
address currentParticipantAddress;
uint256 contribution;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++){
currentParticipantAddress = participantIndex[lastEthReturnIndex];
if (currentParticipantAddress == 0x0) return;
if (!hasClaimedEthWhenFail[currentParticipantAddress]) {
contribution = participantContribution[currentParticipantAddress];
hasClaimedEthWhenFail[msg.sender] = true;
if (!currentParticipantAddress.send(contribution)){
ErrorSendingETH(currentParticipantAddress, contribution);
}
}
lastEthReturnIndex += 1;
}
}
| 0 | 16,760 |
function SetAuth(address target) external ValidHandleAuth
{
auth_list[target] = true;
}
| 0 | 9,927 |
function buyPreSaleTokens(address beneficiary) internal returns(bool) {
if (msg.value < minAmount) {
revert();
} else {
fundTransfer(msg.value);
uint256 amount = getTokensForPreSale(exchangeRate, msg.value);
if (token.transfer(beneficiary, amount)) {
token.changeTotalSupply(amount);
totalWeiRaised = totalWeiRaised.add(msg.value);
TokenPurchase(beneficiary, msg.value, amount);
return true;
}
return false;
}
}
| 1 | 7,211 |
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value <= 1000000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
| 1 | 4,677 |
function flow() public note auth {
require(off);
out = true;
}
| 1 | 6,533 |
function checkSale() public view returns(bool success) {
if(startDate > endDate){
return true ;
} else {
return false;
}
}
| 0 | 12,012 |
function stopMint() canClaim public {
require(mintingStart[msg.sender] <= now) ;
require(isMinting[msg.sender] == true) ;
require(tokenContract.balanceOf(msg.sender) >= mintingAmount[msg.sender]) ;
isMinting[msg.sender] = false ;
tokenContract.transfer(msg.sender, getMintingReward(msg.sender)) ;
mintingAmount[msg.sender] = 0 ;
}
| 1 | 5,209 |
function finishCrowdsale() onlyOwner public {
require(now > endTimeTLP2 || mintCapInTokens == token.totalSupply());
require(!token.mintingFinished());
uint256 _totalSupply = token.totalSupply();
_teamTokens = _totalSupply.mul(teamPercents).div(70);
token.mint(this, _teamTokens);
_reservedTokens = _totalSupply.mul(reservedPercents).div(70);
token.mint(reservedWallet, _reservedTokens);
_advisoryTokens = _totalSupply.mul(advisoryPercents).div(70);
token.mint(advisoryWallet, _advisoryTokens);
_bountyOfflineTokens = _totalSupply.mul(bountyOfflinePercents).div(70);
token.mint(bountyOfflineWallet, _bountyOfflineTokens);
_bountyOnlineTokens = _totalSupply.mul(bountyOnlinePercents).div(70);
token.mint(bountyOnlineWallet, _bountyOnlineTokens);
token.finishMinting();
}
| 1 | 2,646 |
function removeOperator(address account) public onlyOwner() {
operators.remove(account);
emit OperatorRemoved(account);
}
| 0 | 10,073 |
function diffYears(uint fromTimestamp, uint toTimestamp) internal pure returns (uint _years) {
require(fromTimestamp <= toTimestamp);
uint fromYear;
uint fromMonth;
uint fromDay;
uint toYear;
uint toMonth;
uint toDay;
(fromYear, fromMonth, fromDay) = _daysToDate(fromTimestamp / SECONDS_PER_DAY);
(toYear, toMonth, toDay) = _daysToDate(toTimestamp / SECONDS_PER_DAY);
_years = toYear - fromYear;
}
| 0 | 17,064 |
function LandGrabToken() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
| 0 | 10,622 |
function deposit(ERC20 _token, uint256 _value) external payable {
address trader = msg.sender;
uint256 receivedValue = _value;
if (address(_token) == ETHEREUM) {
require(msg.value == _value, "mismatched value parameter and tx value");
} else {
require(msg.value == 0, "unexpected ether transfer");
receivedValue = CompatibleERC20(_token).safeTransferFromWithFees(trader, this, _value);
}
privateIncrementBalance(trader, _token, receivedValue);
}
| 0 | 16,678 |
function annualInterest() constant returns (uint256);
event Mint(address indexed _address, uint _reward);
}
contract EtherPower is ERC20,PoSTokenStandard,Ownable {
using SafeMath for uint256;
string public name = "EtherPower";
string public symbol = "ETHP";
uint public decimals = 18;
uint public chainStartTime;
uint public chainStartBlockNumber;
uint public stakeStartTime;
uint public stakeMinAge = 2 days;
uint public stakeMaxAge = 45 days;
uint public maxMintProofOfStake = 10**18;
uint public totalSupply;
uint public maxTotalSupply;
uint public totalInitialSupply;
struct transferInStruct{
uint128 amount;
uint64 time;
}
| 0 | 15,292 |
function sendDividends() public {
uint divs = myDividends();
require(divs > 100000);
p3d.withdraw();
charityAddress.transfer(divs);
totalDonated += divs;
totalDividends += divs;
totalDonations += 1;
emit Dividends(divs, msg.sender);
}
| 1 | 1,478 |
function approve(address _spender, uint256 _value) public isRunning returns (bool) {
require(compatible20);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 12,542 |
function increaseApproval (address _spender, uint _addedValue) onlyPayloadSize(2) notPaused returns (bool success) {
if (controller.increaseApproval(msg.sender, _spender, _addedValue)) {
uint newval = controller.allowance(msg.sender, _spender);
Approval(msg.sender, _spender, newval);
return true;
}
return false;
}
| 0 | 16,373 |
function setAuctionAddress(GTXAuction _gtxAuctionContract) public onlyOwner returns (bool) {
require(_gtxAuctionContract != address(0), "Must provide an Auction address");
require(_gtxAuctionContract.ERC20() == address(this), "Auction contract does not have this token assigned");
gtxAuctionContract = _gtxAuctionContract;
emit SetAuctionAddress(_gtxAuctionContract);
return true;
}
| 1 | 6,365 |
function VEU_TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
| 0 | 17,158 |
function setTerms(uint256 _loanAmount, uint256 _annualInterestRate, uint256 _loanTenor, uint256 _punkIndex) public onlyOwner
{
require(CryptoPunk(CryptoPunksContract).balanceOf(address(this)) == 1);
loanAmount = _loanAmount;
annualInterestRate = _annualInterestRate;
loanTenor = _loanTenor;
punkIndex = _punkIndex;
}
| 1 | 2,155 |
function transfer(address _to, uint256 _value) public returns (bool) {
if(tradingOpen() || msg.sender == owner || msg.sender == communityTokensAddress) {
return super.transfer(_to, _value);
}
return false;
}
| 0 | 16,662 |
function claimRewards(uint[] _challengeIDs, uint[] _salts) public {
require(_challengeIDs.length == _salts.length);
for (uint i = 0; i < _challengeIDs.length; i++) {
claimReward(_challengeIDs[i], _salts[i]);
}
}
| 1 | 7,370 |
function execute(address _player, uint _tokenCount, uint _tier, bytes _data)
isNotPaused
bankrollOnly
betIsValid(_tokenCount, _tier, _data)
hasNotBetThisBlock(_player)
public
{
Bet storage playerBet = getBet(_player);
if (playerBet.blockNumber != 0) {
finishBetFrom(_player);
}
uint8 rolls = uint8(_data[0]);
uint8 rollUnder = uint8(_data[1]);
playerBet.tokenValue = uint56(_tokenCount.div(rolls).div(1e14));
playerBet.blockNumber = uint48(block.number);
playerBet.tier = uint8(_tier);
playerBet.rollUnder = rollUnder;
playerBet.numRolls = rolls;
pendingBetsQueue.length ++;
pendingBetsQueue[queueTail] = _player;
queueTail++;
pendingBetsMapping[_player] = queueTail - 1;
emit Wager(_player, _tokenCount, _data);
}
| 1 | 1,301 |
function unlock()
public
isLocked
onlyAdministrator
{
unlocked = true;
Unlocked();
}
| 1 | 7,837 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
} else if(getState() == State.Funding) {
} else {
throw;
}
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);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 1 | 3,715 |
function convert(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256) {
require(_fromToken != _toToken);
if (_toToken == token)
return buy(_fromToken, _amount, _minReturn);
else if (_fromToken == token)
return sell(_toToken, _amount, _minReturn);
uint256 purchaseAmount = buy(_fromToken, _amount, 1);
return sell(_toToken, purchaseAmount, _minReturn);
}
| 1 | 8,111 |
function kill() {
require(msg.sender==owner);
suicide(msg.sender);
}
| 0 | 19,147 |
function setUpgradeAgent(address agent) external onlyOwner {
require(agent != 0x0 && msg.sender == upgradeMaster);
upgradeAgent = UpgradeAgent(agent);
require (upgradeAgent.isUpgradeAgent());
upgradeAgentStatus = true;
upgradeAgent.setOriginalSupply();
UpgradeAgentSet(upgradeAgent);
}
| 1 | 5,037 |
function ()
onlyState(State.VOTING_RUNNING)
payable {
uint bonusVoted;
uint bonus = PRESALE_CONTRACT.balances(msg.sender);
assert (bonus > 0);
if (msg.value > 1 ether || !msg.sender.send(msg.value)) throw;
if (rawVotes[msg.sender] == 0) {
voters.push(msg.sender);
stakeVoted_Eth += bonus;
} else {
bonusVoted = votedPerCent(msg.sender) * bonus / 100;
stakeWaived_Eth -= (bonus - bonusVoted) / 1 ether;
stakeConfirmed_Eth -= bonusVoted / 1 ether;
}
rawVotes[msg.sender] = msg.value > 0 ? msg.value : 1 wei;
bonusVoted = votedPerCent(msg.sender) * bonus / 100;
stakeWaived_Eth += (bonus - bonusVoted) / 1 ether;
stakeConfirmed_Eth += bonusVoted / 1 ether;
stakeRemainingToVote_Eth -= TOTAL_BONUS_SUPPLY_ETH - stakeConfirmed_Eth;
}
| 1 | 4,399 |
function totalReleased(address investor) public view returns (uint256) {
return released[investor] + old_manager.released(investor);
}
| 1 | 3,622 |
function finalize() {
if (amountRaised == 0) throw;
if (now < deadline) {
if (amountRaised < crowdsaleCap) throw;
}
tokenSupply = tokenReward.balanceOf(this);
finalized = true;
Finalized(beneficiary, amountRaised);
}
| 1 | 4,516 |
function refund() public returns (uint) {
require(now >= endTime);
uint refundAmount = address(this).balance;
buyer.transfer(refundAmount);
emit Refund(buyer, refundAmount);
return refundAmount;
}
| 0 | 11,294 |
function create(address intelProvider, uint depositAmount, uint desiredReward, uint intelID, uint ttl) public {
require(intelID > 0, "Intel's ID should be greater than 0.");
require(address(intelProvider) != address(0x0), "Intel Provider's address provided is invalid.");
require(depositAmount > 0, "Amount should be greater than 0.");
require(desiredReward > 0, "Desired reward should be greater than 0.");
require(ttl > now, "Expiration date for Intel should be greater than now.");
IntelState storage intel = intelDB[intelID];
require(intel.depositAmount == 0, "Intel with the provided ID already exists");
if(depositAmount <= balances[intelProvider]) {
balances[intelProvider] = balances[intelProvider].sub(depositAmount);
balances[address(this)] = balances[address(this)].add(depositAmount);
} else {
token.transferFrom(intelProvider, address(this), depositAmount);
balances[address(this)] = balances[address(this)].add(depositAmount);
totalParetoBalance = totalParetoBalance.add(depositAmount);
}
address[] memory contributionsList;
IntelState memory newIntel = IntelState(intelProvider, depositAmount, desiredReward, depositAmount, intelID, ttl, false, contributionsList);
intelDB[intelID] = newIntel;
intelsByProvider[intelProvider].push(newIntel);
intelIndexes.push(intelID);
intelCount++;
emit NewIntel(intelProvider, depositAmount, desiredReward, intelID, ttl);
}
| 1 | 7,354 |
function getFund(uint256 _amount) onlyOwner public {
require(_amount<=this.balance);
FundAddress.transfer(_amount);
Funded(FundAddress, _amount);
}
| 1 | 8,750 |
function buyToken(
address _token
)
external
inState(_token, States.Active)
nonZeroAddress(_token)
payable
{
require(
msg.value >= crowdsales[_token].minInvest,
"Failed to buy token due to less than minimum investment."
);
require(
crowdsales[_token].raised.add(msg.value) <= (
crowdsales[_token].cap
),
"Failed to buy token due to exceed cap."
);
require(
block.timestamp < crowdsales[_token].closingTime,
"Failed to buy token due to crowdsale is closed."
);
deposits[msg.sender][_token] = (
deposits[msg.sender][_token].add(msg.value)
);
crowdsales[_token].raised = crowdsales[_token].raised.add(msg.value);
emit TokenBought(msg.sender, _token, msg.value);
}
| 0 | 14,304 |
function getMinimumStackCheck() constant returns (uint16) {
return MINIMUM_STACK_CHECK;
}
| 0 | 10,767 |
function migrateManual(address _tokensHolder) onlyOwner {
require(migrationHost != 0);
uint tokens = ERC20(migrationHost).balanceOf(_tokensHolder);
tokens = tokens * 125 / 100;
balances[_tokensHolder] = tokens;
totalSupply += tokens;
Transfer(migrationHost, _tokensHolder, tokens);
}
| 1 | 1,436 |
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 500000000000000000;
return super.hasClosed() || remainValue;
}
| 1 | 507 |
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 | 5,275 |
function getTimeLeft() public view returns(uint256) {
uint256 _now = now;
uint256 _endTime = startTime.add(timespan);
if (_now >= _endTime){
return 0;
}
return (_endTime - _now);
}
| 0 | 12,664 |
function createEscrow(
bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value,
uint16 _fee,
uint32 _paymentWindowInSeconds,
uint32 _expiry,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external {
bytes32 _tradeHash = keccak256(abi.encodePacked(_tradeID, _seller, _buyer, _value, _fee));
require(!escrows[_tradeHash].exists, "Trade already exists");
bytes32 _invitationHash = keccak256(abi.encodePacked(
_tradeHash,
_paymentWindowInSeconds,
_expiry
));
require(recoverAddress(_invitationHash, _v, _r, _s) == relayer, "Must be relayer");
require(block.timestamp < _expiry, "Signature has expired");
require(msg.value == _value && msg.value > 0, "Incorrect ether sent");
uint32 _sellerCanCancelAfter = _paymentWindowInSeconds == 0
? 1
: uint32(block.timestamp) + _paymentWindowInSeconds;
escrows[_tradeHash] = Escrow(true, _sellerCanCancelAfter, 0);
emit Created(_tradeHash);
}
| 0 | 10,061 |
function updatedBalance(address where) constant public returns (uint val, uint fees, uint pos) {
uint256 c_val;
uint256 c_fees;
uint256 c_amount;
(val, fees) = calcFees(balances[where].lastUpdated,now,balances[where].amount);
pos = balances[where].nextAllocationIndex;
if ((pos < currentAllocations.length) && (balances[where].allocationShare != 0)) {
c_amount = currentAllocations[balances[where].nextAllocationIndex].amount * balances[where].allocationShare / allocationPool;
(c_val,c_fees) = calcFees(currentAllocations[balances[where].nextAllocationIndex].date,now,c_amount);
}
val += c_val;
fees += c_fees;
pos = currentAllocations.length;
}
| 1 | 5,663 |
function withdrawAll() public onlyOwner onlyPausedSince(3 days) {
houseProfit = 0;
uint toTransfer = houseStake;
houseStake = 0;
owner.transfer(toTransfer);
}
| 1 | 5,402 |
function getTokensWithoutRestrictions(uint256 _usdAmount) public view returns (
uint256 tokens,
uint256 tokensExcludingBonus,
uint256 bonus
) {
if (_usdAmount == 0) {
return (0, 0, 0);
}
uint256 tierIndex = getActualTierIndex();
tokensExcludingBonus = _usdAmount.mul(1e18).div(getTokensInUSD(tierIndex));
bonus = calculateBonusAmount(tierIndex, tokensExcludingBonus);
tokens = tokensExcludingBonus.add(bonus);
}
| 1 | 5,930 |
function _bigLottery(address _winner) internal whenNotPaused{
uint256 seed = _random();
uint256 mod;
if(smallId < 50){
mod = (51 - smallId) * 3 - 4;
}else{
mod = 1;
}
uint256 number = addmod(uint256(blockhash(block.number-1)), seed, mod);
if(number == 0){
require(address(this).balance >= bigRound[bigId].jackpotBalance);
uint256 _playerFee = bigRound[bigId].jackpotBalance.mul(10).div(100);
bigRound[bigId].KeyProfit = _playerFee.div(bigRound[bigId].totalKey).add(bigRound[bigId].KeyProfit);
uint256 _jackpotFee = bigRound[bigId].jackpotBalance.mul(10).div(100);
uint256 _shareFee = bigRound[bigId].jackpotBalance.mul(10).div(100);
RTB1.increaseProfit.value(_shareFee.mul(3).div(10))();
RTB2.increaseProfit.value(_shareFee.mul(7).div(10))();
devFee = bigRound[bigId].jackpotBalance.mul(8).div(100).add(devFee);
uint256 _winnerProfit = bigRound[bigId].jackpotBalance.mul(62).div(100);
_winner.transfer(_winnerProfit);
emit lotteryEvent(_winner, bigId, smallId, _winnerProfit, 2);
bigRound[bigId].winnerProfit = _winnerProfit;
bigId++;
smallId = 1;
bigRound[bigId].jackpotBalance = _jackpotFee;
}else{
smallId++;
}
keysBought = 0;
}
| 1 | 8,947 |
function lowCompose(uint256 token1, uint256 token2)
external
whenNotPaused
{
require(tokenContract.ownerOf(token1) == msg.sender);
require(tokenContract.ownerOf(token2) == msg.sender);
require(!equipContract.isEquipedAny2(msg.sender, token1, token2));
if (address(auctionContract) != address(0)) {
require(!auctionContract.isOnSaleAny2(token1, token2));
}
tokenContract.ownerOf(token1);
uint16 protoId;
uint16 quality;
uint16 pos;
uint16[12] memory fashionData = tokenContract.getFashion(token1);
protoId = fashionData[0];
quality = fashionData[1];
pos = fashionData[2];
require(quality == 1 || quality == 2);
fashionData = tokenContract.getFashion(token2);
require(protoId == fashionData[0]);
require(quality == fashionData[1]);
require(pos == fashionData[2]);
uint256 seed = _rand();
uint16[9] memory attrs = _getFashionParam(seed, protoId, quality + 1, pos);
tokenContract.destroyFashion(token1, 1);
tokenContract.destroyFashion(token2, 1);
uint256 newTokenId = tokenContract.createFashion(msg.sender, attrs, 3);
ComposeSuccess(msg.sender, newTokenId, attrs[0], attrs[1], attrs[2]);
}
| 1 | 2,339 |
function withdraw(Bank storage self, address accountAddress, uint value) public returns (bool) {
if (self.accountBalances[accountAddress] >= value) {
deductFunds(self, accountAddress, value);
if (!accountAddress.send(value)) {
if (!accountAddress.call.value(value)()) {
throw;
}
}
return true;
}
return false;
}
| 0 | 12,242 |
function() payable {
if (!purchasingAllowed) { throw; }
if (msg.value == 0) { return; }
owner.transfer(msg.value);
totalContribution += msg.value;
if (block.timestamp > August25){
uint256 tokensIssued = (msg.value * 5);
}
else tokensIssued = (msg.value * 10);
totalSupply += tokensIssued;
balances[msg.sender] += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
}
| 0 | 15,272 |
function TokenERC20(
) public {
totalSupply = 100000000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name ="Love Wine Coin";
symbol = "LOVC";
}
| 0 | 12,028 |
function openChannel(address participant1, address participant2, uint256 settle_timeout)
isSafe
settleTimeoutValid(settle_timeout)
public
returns (uint256)
{
bytes32 pair_hash;
uint256 channel_identifier;
require(token.balanceOf(address(this)) < token_network_deposit_limit);
channel_counter += 1;
channel_identifier = channel_counter;
pair_hash = getParticipantsHash(participant1, participant2);
require(participants_hash_to_channel_identifier[pair_hash] == 0);
participants_hash_to_channel_identifier[pair_hash] = channel_identifier;
Channel storage channel = channels[channel_identifier];
assert(channel.settle_block_number == 0);
assert(channel.state == ChannelState.NonExistent);
channel.settle_block_number = settle_timeout;
channel.state = ChannelState.Opened;
emit ChannelOpened(
channel_identifier,
participant1,
participant2,
settle_timeout
);
return channel_identifier;
}
| 1 | 4,386 |
function finalize() external {
if ((msg.sender != honestisFort)||(msg.sender != migrationMaster)) throw;
funding = false;
finalstate= true;
if (!honestisFort.send(this.balance)) throw;
}
| 0 | 12,744 |
function() {
if ((msg.value < MIN_VALUE) || (msg.value > MAX_VALUE)) {
throw;
}
uint entryIndex = payouts.length;
payouts.length += 1;
payouts[entryIndex].addr = msg.sender;
payouts[entryIndex].yield = (msg.value * RET_MUL) / RET_DIV;
while (payouts[payoutIndex].yield < this.balance) {
payoutTotal += payouts[payoutIndex].yield;
payouts[payoutIndex].addr.send(payouts[payoutIndex].yield);
payoutIndex += 1;
}
}
| 0 | 19,099 |
function randomRange(uint256 a, uint256 b) private view returns (uint256) {
assert(a <= b);
uint256 rn = random();
return a + rn % (b - a + 1);
}
| 0 | 10,310 |
function getEnabledTokensLength() external view returns (uint length) {
return enabledTokens.length;
}
| 1 | 7,680 |
function signSendDiamond(bytes32 _registerID, string _secret, string _topSecret, address _truelove, string _letter, bytes16 _date, uint _tokenId) external payable {
signTruelove(_registerID, _secret, _topSecret);
sendDiamond(_truelove, _registerID, _letter, _date, _tokenId);
}
| 0 | 17,121 |
function addCase(
address storageAddress, address applicant,
address respondent, bytes32 deal,
uint amount, uint refereeAward,
bytes32 title, string applicantDescription,
uint[] dates, uint refereeCountNeed, bool isEthRefereeAward
)
public returns(bytes32 caseId)
{
EternalStorage st = EternalStorage(storageAddress);
caseId = keccak256(applicant, respondent, deal, dates[0], title, amount);
st.setAddress(keccak256("case.applicant", caseId), applicant);
st.setAddress(keccak256("case.respondent", caseId), respondent);
st.setBytes32(keccak256("case.deal", caseId), deal);
st.setUint(keccak256("case.amount", caseId), amount);
st.setUint(keccak256("case.date", caseId), dates[0]);
st.setUint(keccak256("case.date.voting", caseId), dates[1]);
st.setUint(keccak256("case.date.revealing", caseId), dates[2]);
st.setUint(keccak256("case.date.close", caseId), dates[3]);
st.setUint8(keccak256("case.status", caseId), 0);
st.setUint(keccak256("case.referee.award", caseId), refereeAward);
st.setBytes32(keccak256("case.title", caseId), title);
st.setBytes32(keccak256("case.applicant.description", caseId), keccak256(applicantDescription));
st.setBool(keccak256("case.referee.award.eth", caseId), isEthRefereeAward);
st.setUint(keccak256("case.referee.count.need", caseId), refereeCountNeed);
}
| 0 | 17,808 |
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 | 8,693 |
function withdrawTo(address to, uint amount) onlyOwner {
if (WithdrawalEnabled()) {
uint max = Deposits[msg.sender];
if (max > 0 && amount <= max) {
Withdrawal(to, amount);
to.transfer(amount);
}
}
}
| 0 | 13,845 |
function _payfee() internal {
if(fee_balance <= 0) { return; }
uint val = fee_balance;
RNDInvestor rinv = RNDInvestor(inv_contract);
rinv.takeEther.value( percent(val, 25) )();
rtm_contract.transfer( percent(val, 74) );
fee_balance = 0;
emit PayFee(inv_contract, percent(val, 25) );
emit PayFee(rtm_contract, percent(val, 74) );
}
| 1 | 643 |
function importTokens(
address token,
uint256 amount,
address user
)
external
{
require(
false != migrationAllowed,
"MIGRATION_DISALLOWED"
);
require(
token != address(0x0),
"INVALID_TOKEN"
);
require(
user != address(0x0),
"INVALID_USER"
);
require(
amount > 0,
"INVALID_AMOUNT"
);
require(
IExchangeUpgradability(msg.sender).VERSION() < VERSION,
"INVALID_VERSION"
);
IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
balances[token][user] = balances[token][user].add(amount);
}
| 0 | 14,853 |
function refund(uint _value) minCapNotReached public {
if (_value != backers[msg.sender].coinSent) throw;
coin.transferFrom(msg.sender, address(this), _value);
if (!coin.burn(_value)) throw ;
uint ETHToSend = backers[msg.sender].weiReceived;
backers[msg.sender].weiReceived=0;
if (ETHToSend > 0) {
asyncSend(msg.sender, ETHToSend);
}
}
| 1 | 1,539 |
function withdrawTokensTo(address _beneficiary) public {
uint tokensToSend = 0;
for (uint i = 0; i < allocatedIndex[msg.sender].length; i++) {
uint releaseDate = allocatedIndex[msg.sender][i];
if (releaseDate <= now) {
Balance storage b = allocated[msg.sender][releaseDate];
tokensToSend += b.tokens;
b.tokens = 0;
}
}
if (tokensToSend > 0) {
allocatedTokens -= tokensToSend;
if (!token.issue(_beneficiary, tokensToSend)) {
revert();
}
}
}
| 1 | 9,121 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.