func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function getBurnedItemByIndex(uint256 _index) external view returns (uint256) {
require(_index < burnedItemIds.length, "out of boundary");
return burnedItemIds[_index];
}
| 0 | 10,145 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(this));
return super.transferFrom(_from, _to, _value);
}
| 0 | 13,828 |
function () payable stopOnPause{
require(now < deadline);
require(msg.value >= minInvestment);
uint amount = msg.value;
ethBalances[msg.sender] += amount;
weiRaised += amount;
if(!fundingGoalReached && weiRaised >= fundingGoal){goalReached();}
uint ABIOAmount = amount / weiPerABIO ;
abioToken.transfer(msg.sender, ABIOAmount);
abioSold += ABIOAmount;
emit FundsReceived(msg.sender, amount);
}
| 1 | 7,154 |
function UpdateEthBalance(uint256 bal, uint256 devf, uint256 rnkf, uint256 shpf) external payable
{
require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender));
worldData.ethBalance += bal + devf + rnkf + shpf;
worldData.ethDev += devf;
WORLDSNAPSHOT storage wss = ValidateWorldSnapshotInternal(nowday());
wss.ethDay += bal + devf + rnkf + shpf;
wss.ethBalance += bal;
wss.ethRankFund += rnkf;
wss.ethShopFund += shpf;
wss.ethRankFundRemain += rnkf;
wss.ethShopFundRemain += shpf;
wss.lasttime = block.timestamp;
ethBalance[owner] += devf;
}
| 0 | 17,904 |
function needs more 25300 gas than then they will NOT
bool sentOk = carefulSendWithFixedGas(
compensationAddress,
_compensationWei,
suggestedExtraGasToIncludeWithSends
);
if (sentOk) {
CompensationSentEvent(compensationAddress, _compensationWei);
}
| 1 | 6,610 |
function burn(uint256 _value) public {
require(canBurnWhiteList.onList(msg.sender));
require(_value >= burnMin);
require(_value <= burnMax);
uint256 fee = payStakingFee(msg.sender, _value, burnFeeNumerator, burnFeeDenominator, burnFeeFlat);
uint256 remaining = _value.sub(fee);
super.burn(remaining);
}
| 1 | 5,179 |
function setPlanLimit(uint256 _planId, uint256 _perInvestorLimit, uint256 _addAmount) public onlyOwner {
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
Objects.Plan storage plan = investmentPlans_[_planId];
plan.perInvestorLimit = _perInvestorLimit;
plan.leftAmount = plan.leftAmount.add(_addAmount);
plan.lastUpdateDate = block.timestamp;
}
| 0 | 12,330 |
function withdrawAmount (uint256 _amount) onlyOwner public {
msg.sender.transfer(_amount);
}
| 0 | 18,884 |
function __callback(bytes32 myid, string result, bytes proof) public
onlyOraclize
payoutsAreActive
{
require(userAddress[myid]!= 0x0);
require(oraclize_randomDS_proofVerify__returnCode(myid, result, proof) == 0);
uint maxRange = 100;
userDieResult[myid] = uint(sha3(result)) % maxRange + 1;
userTempAddress[myid] = userAddress[myid];
delete userAddress[myid];
userTempReward[myid] = userProfit[myid];
userProfit[myid] = 0;
maxPendingPayouts = safeSub(maxPendingPayouts, userTempReward[myid]);
userTempBetValue[myid] = userBetValue[myid];
userBetValue[myid] = 0;
totalBets += 1;
totalWeiWagered += userTempBetValue[myid];
if(userDieResult[myid] == 0 || bytes(result).length == 0 || bytes(proof).length == 0){
LogResult(userBetId[myid], userTempAddress[myid], userNumber[myid], userDieResult[myid], userTempBetValue[myid], 3, proof);
if(!userTempAddress[myid].send(userTempBetValue[myid])){
LogResult(userBetId[myid], userTempAddress[myid], userNumber[myid], userDieResult[myid], userTempBetValue[myid], 4, proof);
userPendingWithdrawals[userTempAddress[myid]] = safeAdd(userPendingWithdrawals[userTempAddress[myid]], userTempBetValue[myid]);
}
return;
}
if(userDieResult[myid] < userNumber[myid]){
contractBalance = safeSub(contractBalance, userTempReward[myid]);
totalWeiWon = safeAdd(totalWeiWon, userTempReward[myid]);
userTempReward[myid] = safeAdd(userTempReward[myid], userTempBetValue[myid]);
LogResult(userBetId[myid], userTempAddress[myid], userNumber[myid], userDieResult[myid], userTempReward[myid], 1, proof);
setMaxProfit();
if(!userTempAddress[myid].send(userTempReward[myid])){
LogResult(userBetId[myid], userTempAddress[myid], userNumber[myid], userDieResult[myid], userTempReward[myid], 2, proof);
userPendingWithdrawals[userTempAddress[myid]] = safeAdd(userPendingWithdrawals[userTempAddress[myid]], userTempReward[myid]);
}
return;
}
if(userDieResult[myid] >= userNumber[myid]){
LogResult(userBetId[myid], userTempAddress[myid], userNumber[myid], userDieResult[myid], userTempBetValue[myid], 0, proof);
contractBalance = safeAdd(contractBalance, (userTempBetValue[myid]-1));
setMaxProfit();
if(!userTempAddress[myid].send(1)){
userPendingWithdrawals[userTempAddress[myid]] = safeAdd(userPendingWithdrawals[userTempAddress[myid]], 1);
}
return;
}
}
| 1 | 2,494 |
function upgrade(uint size) public onlyOwner {
require(upgradableState.isUpgrading);
require(upgradableState.prevVersion != 0);
nextTaskId = TaskRegister(upgradableState.prevVersion).nextTaskId();
totalReward = token.balanceOf(upgradableState.prevVersion);
uint index = tasks.length;
uint tasksCount = TaskRegister(upgradableState.prevVersion).tasksCount();
for (uint i = index; i < index + size && i < tasksCount; i++) {
tasks.push(Task(TaskType.BITCOIN_ADDRESS_PREFIX,0,0,0,bytes32(0),0,0,0,0));
}
for (uint j = index; j < index + size && j < tasksCount; j++) {
(
tasks[j].taskType,
tasks[j].taskId,
tasks[j].creator,
tasks[j].reward,
tasks[j].data,
,
,
,
) = TaskRegister(upgradableState.prevVersion).tasks(j);
indexOfTaskId[tasks[j].taskId] = j + 1;
}
for (uint k = index; k < index + size && k < tasksCount; k++) {
(
,
,
,
,
,
tasks[k].dataLength,
tasks[k].requestPublicXPoint,
tasks[k].requestPublicYPoint,
tasks[k].answerPrivateKey
) = TaskRegister(upgradableState.prevVersion).tasks(k);
}
}
| 1 | 845 |
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
H3Ddatasets.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;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 8,734 |
function burnPrimordialFrom(address _from, uint256 _value) public returns (bool) {
require (primordialBalanceOf[_from] >= _value);
require (primordialAllowance[_from][msg.sender] >= _value);
require (calculateMaximumBurnAmount(_from) >= _value);
ownerWeightedMultiplier[_from] = calculateMultiplierAfterBurn(_from, _value);
primordialBalanceOf[_from] = primordialBalanceOf[_from].sub(_value);
primordialAllowance[_from][msg.sender] = primordialAllowance[_from][msg.sender].sub(_value);
primordialTotalSupply = primordialTotalSupply.sub(_value);
require (_aoIonLot.createBurnLot(_from, _value, ownerWeightedMultiplier[_from]));
emit PrimordialBurn(_from, _value);
return true;
}
| 0 | 11,916 |
function ConsultaRegistro(bytes32 hash) public constant returns (uint) {
require(registros[hash].existe);
return (registros[hash].block_number);
}
| 0 | 11,871 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
| 0 | 12,415 |
function doCoinage() returns (bool){
if (msg.sender != curator){ return false; }
if (usdAmount == 0 || xaurCoined == 0 || goldBought == 0){ return false; }
address[] memory tempAddressArray = new address[](1);
tempAddressArray[0] = defaultMintingAddress;
uint256[] memory tempAmountArray = new uint256[](1);
tempAmountArray[0] = xaurCoined;
tokenContract.doCoinage(tempAddressArray, tempAmountArray, usdAmount, xaurCoined, goldBought);
MintMade(usdAmount, xaurCoined, goldBought);
usdAmount = 0;
xaurCoined = 0;
goldBought = 0;
return true;
}
| 1 | 7,967 |
function buyBunny(uint32 _bunnyId) public payable {
require(isPauseSave());
require(checkContract());
require(publicContract.ownerOf(_bunnyId) != msg.sender);
lastmoney = currentPrice(_bunnyId);
require(msg.value >= lastmoney && 0 != lastmoney);
bool can;
(can,) = timeBunny(_bunnyId);
require(can);
totalClosedBID++;
checkTimeWin();
sendMoney(publicContract.ownerOf(_bunnyId), lastmoney);
publicContract.transferFrom(publicContract.ownerOf(_bunnyId), msg.sender, _bunnyId);
sendMoneyMother(_bunnyId);
stopMarket(_bunnyId);
changeReallyPrice();
lastOwner = msg.sender;
lastSaleTime = block.timestamp;
emit BunnyBuy(_bunnyId, lastmoney);
}
| 1 | 7,340 |
function getState() public constant returns (State) {
if (address(pricingStrategy) == 0)
return State.Preparing;
else if (block.timestamp < startsAt)
return State.PreFunding;
else if (block.timestamp <= endsAt && !isReservationFull())
return State.Funding;
else if (isMinimumGoalReached())
return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised)
return State.Refunding;
else
return State.Failure;
}
| 0 | 13,891 |
function release(address beneficiary)
external
{
require(msg.sender == distributor);
require(started);
require(block.timestamp >= releaseTime);
uint256 amount = buyers[beneficiary];
buyers[beneficiary] = 0;
Token.safeTransfer(beneficiary, amount);
emit TokenReleased(beneficiary, amount);
}
| 0 | 18,510 |
function getReferralTokenReward() public view returns (uint8){
return referralTokenReward;
}
| 0 | 17,741 |
function claimRefund() public {
require(isFinalized);
require(!goalReached() || forcedRefund);
vault.refund(msg.sender);
}
| 1 | 7,137 |
function createDefaultGen0EtherDog(uint256 _genes, address _owner, uint256 _time, uint256 _cooldownIndex) external onlyCOO {
require(_time == uint256(uint64(_time)));
require(_cooldownIndex == uint256(uint16(_cooldownIndex)));
require(_time > 0);
require(_cooldownIndex >= 0 && _cooldownIndex <= 13);
address EtherDogOwner = _owner;
if (EtherDogOwner == address(0)) {
EtherDogOwner = cooAddress;
}
require(defaultCreatedCount < DEFAULT_CREATION_LIMIT);
defaultCreatedCount++;
_createEtherDogWithTime(0, 0, 0, _genes, EtherDogOwner, _time, _cooldownIndex);
}
| 1 | 2,964 |
function setConfig(string _key, uint256 _value) onlyOwner {
chainyConfig[_key] = _value;
}
| 0 | 15,751 |
function isGoldenMin(
uint256 _slideEndTime
)
public
view
returns(bool)
{
uint256 _restTime1 = _slideEndTime.sub(block.timestamp);
if (_restTime1 > 6 hours) return false;
uint256 _min = (block.timestamp / 60) % 60;
return _min == 8;
}
| 0 | 15,476 |
function set_god_name (string new_name) public returns (bool){
address god_address = msg.sender;
require (add(gods_name[god_address].block_number, gods_name[god_address].block_duration) < block.number );
bytes memory bs = bytes(new_name);
require (bs.length <= valid_length);
for (uint i = 0; i < bs.length; i++){
for (uint j = 0; j < invalid_bytes.length; j++) {
if (bs[i] == invalid_bytes[j]){
return false;
}
}
}
gods_name[god_address].god_name = new_name;
emit set_name(god_address, new_name);
return true;
}
| 1 | 5,772 |
function totalSupply() external constant returns (uint256 _totalSupply);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event ERC223Transfer(address indexed _from, address indexed _to, uint256 _value, bytes _data);
event Approval(address indexed _owner, address indexed _spender, uint _value);
event Burn(address indexed burner, uint256 value);
event FrozenAccount(address indexed targets);
event UnfrozenAccount(address indexed target);
event LockedAccount(address indexed target, uint256 locked);
event UnlockedAccount(address indexed target);
}
contract ERC223ReceivingContract {
TKN internal fallback;
struct TKN {
address sender;
uint value;
bytes data;
bytes4 sig;
}
| 0 | 17,432 |
function removeUnitMultipliers(address player, uint256 upgradeClass, uint256 unitId, uint256 upgradeValue) internal {
uint256 productionLoss;
if (upgradeClass == 0) {
unitGooProductionIncreases[player][unitId] -= upgradeValue;
productionLoss = (unitsOwned[player][unitId] * upgradeValue * (10 + unitGooProductionMultiplier[player][unitId])) / 10;
reducePlayersGooProduction(player, productionLoss);
} else if (upgradeClass == 1) {
unitGooProductionMultiplier[player][unitId] -= upgradeValue;
productionLoss = (unitsOwned[player][unitId] * upgradeValue * (schema.unitGooProduction(unitId) + unitGooProductionIncreases[player][unitId])) / 10;
reducePlayersGooProduction(player, productionLoss);
} else if (upgradeClass == 2) {
unitAttackIncreases[player][unitId] -= upgradeValue;
} else if (upgradeClass == 3) {
unitAttackMultiplier[player][unitId] -= upgradeValue;
} else if (upgradeClass == 4) {
unitDefenseIncreases[player][unitId] -= upgradeValue;
} else if (upgradeClass == 5) {
unitDefenseMultiplier[player][unitId] -= upgradeValue;
} else if (upgradeClass == 6) {
unitGooStealingIncreases[player][unitId] -= upgradeValue;
} else if (upgradeClass == 7) {
unitGooStealingMultiplier[player][unitId] -= upgradeValue;
}
}
| 1 | 2,530 |
function setPercentage(uint referrerPercentage1,uint referrerPercentage2, uint referrerPercentage3, uint bankrollPercentage)
onlyAdministrator()
public
{
require (referrerPercentage1 >= 0);
require (referrerPercentage2 >= 0);
require (referrerPercentage3 >= 0);
require (bankrollPercentage >= 0);
referrer_percentage1 = referrerPercentage1;
referrer_percentage2 = referrerPercentage2;
referrer_percentage3 = referrerPercentage3;
bankroll_percentage = bankrollPercentage;
}
| 0 | 11,138 |
function claimRefund() external {
uint256 depositedValue = 0;
if (isCrowdsaleFinalized && !crowdsaleGoalReached()) {
require(crowdsaleDeposited[msg.sender] > 0);
depositedValue = crowdsaleDeposited[msg.sender];
crowdsaleDeposited[msg.sender] = 0;
} else if (isPresaleFinalized && !presaleGoalReached()) {
require(presaleDeposited[msg.sender] > 0);
depositedValue = presaleDeposited[msg.sender];
presaleDeposited[msg.sender] = 0;
}
require(depositedValue > 0);
msg.sender.transfer(depositedValue);
emit Refunded(msg.sender, depositedValue);
}
| 0 | 19,449 |
function multiTransfer(address[] _to, uint256[] _value) public returns(bool) {
require(_to.length == _value.length);
for(uint i = 0; i < _to.length; i++) {
transfer(_to[i], _value[i]);
}
return true;
}
| 0 | 14,716 |
function ClockAuction(address _nftAddress, uint256 _cut) public {
require(_cut <= 10000);
ownerCut = _cut;
ERC721 candidateContract = ERC721(_nftAddress);
require(candidateContract.supportsInterface(INTERFACE_SIGNATURE_ERC721));
nonFungibleContract = candidateContract;
}
| 1 | 8,429 |
function settle() public {
require(court.disputeStatus(disputeID) == Arbitrator.DisputeStatus.Solved);
require(!settled);
settled = true;
var (, , appeals, choices, , , ,) = court.disputes(disputeID);
if (court.currentRuling(disputeID) != desiredOutcome){
uint amountShift = court.getStakePerDraw();
uint winningChoice = court.getWinningChoice(disputeID, appeals);
for (uint i=0; i <= (appeals > maxAppeals ? maxAppeals : appeals); i++){
if (winningChoice != 0){
uint votesLen = 0;
for (uint c = 0; c <= choices; c++) {
votesLen += court.getVoteCount(disputeID, i, c);
}
emit Log(amountShift, 0x0 ,"stakePerDraw");
emit Log(votesLen, 0x0, "votesLen");
uint totalToRedistribute = 0;
uint nbCoherent = 0;
for (uint j=0; j < votesLen; j++){
uint voteRuling = court.getVoteRuling(disputeID, i, j);
address voteAccount = court.getVoteAccount(disputeID, i, j);
emit Log(voteRuling, voteAccount, "voted");
if (voteRuling != winningChoice){
totalToRedistribute += amountShift;
if (voteRuling == desiredOutcome){
withdraw[voteAccount] += amountShift + epsilon;
remainingWithdraw += amountShift + epsilon;
emit AmountShift(amountShift, epsilon, voteAccount);
}
} else {
nbCoherent++;
}
}
uint toRedistribute = (totalToRedistribute - amountShift) / (nbCoherent + 1);
for (j = 0; j < votesLen; j++){
voteRuling = court.getVoteRuling(disputeID, i, j);
voteAccount = court.getVoteAccount(disputeID, i, j);
if (voteRuling == desiredOutcome){
withdraw[voteAccount] += toRedistribute;
remainingWithdraw += toRedistribute;
emit AmountShift(toRedistribute, 0, voteAccount);
}
}
}
}
}
}
| 1 | 4,917 |
function buywithRCC(uint _weaponId, address _buyer) internal {
(address seller, uint spOfWeapon, uint commssion) = getWeaponDetails(_weaponId);
uint allowance = RCCToken.allowance(_buyer, address(this));
uint sellersPrice = spOfWeapon.sub(commssion);
require(allowance >= spOfWeapon, '5');
removeWeaponFromSale(_weaponId);
if(spOfWeapon > 0){
RCCToken.transferFrom(_buyer, seller, sellersPrice);
}
if(commssion > 0){
RCCToken.transferFrom(_buyer, owner, commssion);
}
totalOrdersMatched = totalOrdersMatched.add(1);
weaponTokenize.updateOwnerOfWeapon(_weaponId, _buyer);
emit OrderMatched(_buyer, seller, spOfWeapon, msg.sender, commssion, 'RCC');
}
| 1 | 5,901 |
function addCancellation (address _participant) external onlyOwner returns (bool success) {
mainCancelledList[_participant] = true;
return true;
}
| 1 | 8,286 |
function setETHUSDrate(uint256 x) public returns (bool) {
require(msg.sender == fundsWallet);
ETHUSDrate = x;
return true;
}
| 0 | 18,073 |
function buyTokens(address _beneficiary) public whenNotPaused payable returns (uint256) {
require(!hasEnded());
require(_beneficiary != address(0));
require(validPurchase());
require(minimumInvest(msg.value));
address beneficiary = _beneficiary;
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
bool isLess = false;
if (!hasEnoughTokensLeft(weiAmount)) {
isLess = true;
uint256 percentOfValue = tokensLeft().mul(100).div(tokens);
require(percentOfValue <= 100);
tokens = tokens.mul(percentOfValue).div(100);
weiAmount = weiAmount.mul(percentOfValue).div(100);
beneficiary.transfer(msg.value.sub(weiAmount));
}
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokens);
if(contributions[beneficiary] == 0) {
contributors = contributors.add(1);
}
contributions[beneficiary] = contributions[beneficiary].add(weiAmount);
this.transfer(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
return (tokens);
}
| 1 | 5,656 |
function totalSupply() public view returns (uint256) {
if (rewardStartTime == 0) {
return;
}
uint256 totalDays = block.timestamp.sub(rewardStartTime).mul(PRECISION).div(1 days);
return BASE_REWARD.mul(totalDays).div(PRECISION);
}
| 0 | 16,127 |
function getAllEntityIds() public returns (address[] entityList)
{
require(token.getTokenBalance(msg.sender)>=perTransactionRate);
token.mint(msg.sender, wallet, perTransactionRate);
require(freezedTokens[msg.sender] == false);
MakeTokenCreditAndDebitEntry(msg.sender);
EmitEntityIds(entities);
return entities;
}
| 1 | 5,907 |
function setExchangeRatePrivate(
IERC223Token numeratorToken,
IERC223Token denominatorToken,
uint256 rateFraction
)
private
{
require(numeratorToken != denominatorToken, "NF_SEX_SAME_N_D");
assert(rateFraction > 0);
assert(rateFraction < 2**128);
uint256 invRateFraction = proportion(10**18, 10**18, rateFraction);
require(denominatorToken.decimals() == numeratorToken.decimals(), "NF_SEX_DECIMALS");
if (_rates[denominatorToken][numeratorToken].timestamp > 0) {
_rates[denominatorToken][numeratorToken] = TokenRate({
rateFraction: uint128(invRateFraction),
timestamp: uint128(block.timestamp)
});
}
else {
_rates[numeratorToken][denominatorToken] = TokenRate({
rateFraction: uint128(rateFraction),
timestamp: uint128(block.timestamp)
});
}
emit LogSetExchangeRate(numeratorToken, denominatorToken, rateFraction);
emit LogSetExchangeRate(denominatorToken, numeratorToken, invRateFraction);
}
| 1 | 7,373 |
function getRiskParameters(bytes32 _riskId) public returns (bytes32 _carrierFlightNumber, bytes32 _departureYearMonthDay, uint _arrivalTime) {
Risk storage r = risks[_riskId];
_carrierFlightNumber = r.carrierFlightNumber;
_departureYearMonthDay = r.departureYearMonthDay;
_arrivalTime = r.arrivalTime;
}
| 1 | 6,721 |
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
assert(b <= a);
c = a - b;
}
| 0 | 18,773 |
function isSupplyLessThan10Million() public view returns(bool){
uint256 tenMillion = 1000000000000000;
if(_totalSupply <= tenMillion){
return true;
}
return false;
}
| 0 | 12,686 |
function payDiff(address backer, uint totalNxcBought){
if (msg.sender != owner) throw;
if (paid[backer] == 0) paidAddress[paidAddress.length++] = msg.sender;
uint totalToPay = bonusCalculation(totalNxcBought);
if(totalToPay <= paid[backer]) throw;
totalToPay -= paid[backer];
if (!nexium.transfer(backer, totalToPay)) throw;
paid[backer] += totalToPay;
totalDistributed += totalToPay;
Paid(backer);
}
| 1 | 8,264 |
function freeCar(uint16 _equipmentId)
external
payable
whenNotPaused
{
require(freeCarCount[msg.sender] != 1);
uint256 payBack = 0;
uint16[] storage buyArray = presellLimit[msg.sender];
if(_equipmentId == 10007){
require(msg.value >= 0.0 ether);
payBack = (msg.value - 0.0 ether);
uint16[13] memory param0 = [10007, 7, 9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0];
tokenContract.createFashion(msg.sender, param0, 1);
raceCoinContract.increasePlayersAttribute(msg.sender, param0);
buyArray.push(10007);
if (payBack > 0) {
msg.sender.transfer(payBack);
}
freeCarCount[msg.sender] = 1;
raceCoinContract.addPlayerToList(msg.sender);
FreeCarsObtained(msg.sender,_equipmentId);
}
}
| 1 | 7,693 |
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[4] memory addresses = [address(0xc6e5f9ab377de4c622aa419c3b10e1eed5854357),address(0x85b9bd107615337c67709bcaad91afdf0f9b185c),address(0x15c994510e3c2f2340adf97370d3a108a95c812a),address(0xcb2cee394f1b92b61d1438b5f7807171ac452a93)];
uint[4] memory amounts = [uint(15000000000000000000000000),uint(15000000000000000000000000),uint(60000000000000000000000000),uint(30000000000000000000000000)];
uint64[4] memory freezes = [uint64(1559336461),uint64(1559336461),uint64(1559336461),uint64(1559336461)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
emit Initialized();
}
| 1 | 8,325 |
function canSort()
{
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
balance += amount - (amount/100)*3;
while (balance > persons[payoutIdx].amount / 100 * exchangemod )
{
uint transactionAmount = persons[payoutIdx].amount / 100 * exchangemod;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 19,385 |
function getPlayers() external view returns(address[]) {
return players;
}
| 0 | 12,265 |
function dInit(address defaultErc20, address initOwner, bool disableErc20OwnerClaim) only_editors() external returns (bytes32 democHash) {
democHash = keccak256(abi.encodePacked(democList.length, blockhash(block.number-1), defaultErc20, now));
_addDemoc(democHash, defaultErc20, initOwner, disableErc20OwnerClaim);
}
| 0 | 11,421 |
function () payable {
uint amount = msg.value;
if (crowdsaleClosed || amount < 0.1 ether) throw;
price = discount();
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokensForSending = amount / ((price * allTimeDiscount(amount)) / 100);
tokenReward.transfer(msg.sender, tokensForSending);
tokensCounter += tokensForSending;
FundTransfer(msg.sender, amount, true);
if (beneficiary.send(amount)) {
FundTransfer(beneficiary, amount, false);
}
}
| 1 | 1,826 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Registry {
struct AttributeData {
uint256 value;
bytes32 notes;
address adminAddr;
uint256 timestamp;
}
| 0 | 12,329 |
function buySpaceshipUpgrade(uint256 _tokenId, uint16 _model, uint8 _position) public payable onlyOwnerOf(_tokenId) {
require(msg.value > 0);
uint256 upgradePrice = upgradeContract.getSpaceshipUpgradePriceByModel(_model, _position);
require(msg.value == upgradePrice);
require(getPlayerSpaceshipBattleModeById(_tokenId) == false);
bytes5 currentUpgrades = spaceships[_tokenId].upgrades;
upgradeContract.isSpaceshipUpgradeAllowed(currentUpgrades, _model, _position);
spaceships[_tokenId].upgrades = upgradeContract.buySpaceshipUpgrade(currentUpgrades, _model, _position);
balances[owner] += upgradePrice;
emit EventBuySpaceshipUpgrade(msg.sender, _tokenId, _model, _position);
}
| 1 | 560 |
function tradeBalances(address tokenGet, uint amountGet, address tokenGive, uint amountGive, address user, uint amount) private {
uint feeMakeXfer = safeMul(amount, feeMake) / (1 ether);
uint feeTakeXfer = safeMul(amount, feeTake) / (1 ether);
uint feeRebateXfer = 0;
if (accountLevelsAddr != 0x0) {
uint accountLevel = AccountLevels(accountLevelsAddr).accountLevel(user);
if (accountLevel==1) feeRebateXfer = safeMul(amount, feeRebate) / (1 ether);
if (accountLevel==2) feeRebateXfer = feeTakeXfer;
}
tokens[tokenGet][msg.sender] = safeSub(tokens[tokenGet][msg.sender], safeAdd(amount, feeTakeXfer));
tokens[tokenGet][user] = safeAdd(tokens[tokenGet][user], safeSub(safeAdd(amount, feeRebateXfer), feeMakeXfer));
tokens[tokenGet][feeAccount] = safeAdd(tokens[tokenGet][feeAccount], safeSub(safeAdd(feeMakeXfer, feeTakeXfer), feeRebateXfer));
tokens[tokenGive][user] = safeSub(tokens[tokenGive][user], safeMul(amountGive, amount) / amountGet);
tokens[tokenGive][msg.sender] = safeAdd(tokens[tokenGive][msg.sender], safeMul(amountGive, amount) / amountGet);
}
| 1 | 4,107 |
function expressReloadNums(uint256 _affID, uint256 _eth, uint256[] _nums)
public
isActivated()
isHuman()
isWithinLimits(_eth)
inSufficient(_eth, _nums)
{
uint256 compressData = checkRoundAndDraw(msg.sender);
reloadCore(msg.sender, _affID, _eth);
convertCore(msg.sender, _nums.length, TicketCompressor.encode(_nums));
emit onEndTx(
rID_,
msg.sender,
compressData,
_eth,
round_[rID_].pot,
playerTickets_[msg.sender],
block.timestamp
);
}
| 1 | 5,435 |
function buyTokens(address _investor) public payable returns (uint256){
require(_investor != address(0));
uint256 weiAmount = msg.value;
uint256 tokens = validPurchaseTokens(weiAmount);
if (tokens == 0) {revert();}
weiRaised = weiRaised.add(weiAmount);
tokenAllocated = tokenAllocated.add(tokens);
if(whitelist[_investor]) {
tokenContract.mint(_investor, tokens, owner);
} else {
tokenContract.mint(addressFundNonKYCReserv, tokens, owner);
paidTokens[_investor] = paidTokens[_investor].add(tokens);
emit NonWhitelistPurchase(_investor, tokens);
}
emit TokenPurchase(_investor, weiAmount, tokens);
if (deposited[_investor] == 0) {
countInvestor = countInvestor.add(1);
}
deposit(_investor);
checkReferalLink(tokens);
wallet.transfer(weiAmount);
return tokens;
}
| 1 | 4,437 |
function burnRemainder(uint) public onlyOwner {
uint value = balances[this];
totalSupply = totalSupply.sub(value);
balances[this] = 0;
}
| 0 | 10,382 |
function executeProposal(
uint256 id,
bytes transactionBytecode
)
onlyMembers
{
Proposal p = proposals[id];
if (now < p.votingDeadline
|| p.executed
|| p.proposalHash != sha3(p.recipient, p.amount, transactionBytecode)
|| p.numberOfVotes < minimumQuorum)
throw;
if (p.currentResult > majorityMargin) {
p.executed = true;
if (!p.recipient.call.value(p.amount)(transactionBytecode))
throw;
p.proposalPassed = true;
} else {
p.proposalPassed = false;
}
ProposalTallied(id, p.numberOfVotes, p.proposalPassed);
}
| 1 | 4,406 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances_[msg.sender]);
balances_[msg.sender] = balances_[msg.sender].sub(_value);
balances_[_to] = balances_[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 19,023 |
function getAuction(uint256 _tokenId)
external
view
returns
(
address seller,
uint256 price,
uint256 startedAt
) {
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
return (
auction.seller,
auction.price,
auction.startedAt
);
}
| 0 | 9,917 |
function released(address token) public view returns (uint256) {
return _released[token];
}
| 0 | 18,493 |
function resolveDispute(
bytes16 _jobId,
address _hirer,
address _contractor,
uint256 _value,
uint256 _fee,
uint8 _contractorPercent
) external onlyArbitrator
{
bytes32 jobHash = getJobHash(
_jobId,
_hirer,
_contractor,
_value,
_fee);
require(jobEscrows[jobHash].exists);
require(jobEscrows[jobHash].status == STATUS_JOB_IN_DISPUTE);
require(_contractorPercent <= 100);
uint256 jobValue = hirerEscrowMap[_hirer][jobHash];
require(jobValue > 0 && jobValue == _value);
require(jobValue >= jobValue.sub(_fee));
require(totalInEscrow >= jobValue && totalInEscrow > 0);
totalInEscrow = totalInEscrow.sub(jobValue);
feesAvailableForWithdraw = feesAvailableForWithdraw.add(_fee);
delete jobEscrows[jobHash];
delete hirerEscrowMap[_hirer][jobHash];
uint256 contractorAmount = jobValue.sub(_fee).mul(_contractorPercent).div(100);
uint256 hirerAmount = jobValue.sub(_fee).mul(100 - _contractorPercent).div(100);
emit DisputeResolved(
jobHash,
msg.sender,
hirerAmount,
contractorAmount);
emit AddFeesToCoinSparrowPool(jobHash, _fee);
_contractor.transfer(contractorAmount);
_hirer.transfer(hirerAmount);
}
| 0 | 15,096 |
function upper(string _base) internal pure returns (string) {
bytes memory _baseBytes = bytes(_base);
for (uint i = 0; i < _baseBytes.length; i++) {
bytes1 b1 = _baseBytes[i];
if (b1 >= 0x61 && b1 <= 0x7A) {
b1 = bytes1(uint8(b1)-32);
}
_baseBytes[i] = b1;
}
return string(_baseBytes);
}
| 1 | 2,817 |
function() payable public {
if (msg.sender == address(leverage)) {
return;
}
uint value = uint(msg.value / minInvestment) * minInvestment;
if (value < minInvestment) {
withdrawInterest(msg.sender);
} else {
doInvest(msg.sender, value);
doBet(msg.sender, value, WagerType.Conservative);
}
}
| 0 | 16,724 |
function getTiersData(uint256 _type) public view returns (
uint256[26] tiersData
) {
_type = _type;
uint256[12] memory tiers = pricing.getArrayOfTiers();
uint256 length = tiers.length / 6;
uint256 j = 0;
for (uint256 i = 0; i < length; i++) {
tiersData[j++] = uint256(1e23).div(tiers[i.mul(6)]);
tiersData[j++] = 0;
tiersData[j++] = uint256(tiers[i.mul(6).add(1)]);
tiersData[j++] = uint256(tiers[i.mul(6).add(2)]);
tiersData[j++] = 0;
tiersData[j++] = 0;
tiersData[j++] = uint256(tiers[i.mul(6).add(3)]);
tiersData[j++] = 0;
tiersData[j++] = 0;
tiersData[j++] = 0;
tiersData[j++] = uint256(tiers[i.mul(6).add(4)]);
tiersData[j++] = uint256(tiers[i.mul(6).add(5)]);
tiersData[j++] = 1;
}
tiersData[25] = 2;
}
| 1 | 5,782 |
function withdraw(uint amount) onlyOwner {
ownerAddress.send(amount);
}
| 0 | 16,163 |
function updateUintConfigs(uint256[] _uintConfigs)
external
{
require(sender_is(CONTRACT_DAO_SPECIAL_VOTING_CLAIMS));
uintConfigs[CONFIG_LOCKING_PHASE_DURATION] = _uintConfigs[0];
uintConfigs[CONFIG_VOTING_COMMIT_PHASE] = _uintConfigs[2];
uintConfigs[CONFIG_VOTING_PHASE_TOTAL] = _uintConfigs[3];
uintConfigs[CONFIG_INTERIM_COMMIT_PHASE] = _uintConfigs[4];
uintConfigs[CONFIG_INTERIM_PHASE_TOTAL] = _uintConfigs[5];
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_NUMERATOR] = _uintConfigs[6];
uintConfigs[CONFIG_DRAFT_QUORUM_FIXED_PORTION_DENOMINATOR] = _uintConfigs[7];
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_NUMERATOR] = _uintConfigs[8];
uintConfigs[CONFIG_DRAFT_QUORUM_SCALING_FACTOR_DENOMINATOR] = _uintConfigs[9];
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_NUMERATOR] = _uintConfigs[10];
uintConfigs[CONFIG_VOTING_QUORUM_FIXED_PORTION_DENOMINATOR] = _uintConfigs[11];
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_NUMERATOR] = _uintConfigs[12];
uintConfigs[CONFIG_VOTING_QUORUM_SCALING_FACTOR_DENOMINATOR] = _uintConfigs[13];
uintConfigs[CONFIG_DRAFT_QUOTA_NUMERATOR] = _uintConfigs[14];
uintConfigs[CONFIG_DRAFT_QUOTA_DENOMINATOR] = _uintConfigs[15];
uintConfigs[CONFIG_VOTING_QUOTA_NUMERATOR] = _uintConfigs[16];
uintConfigs[CONFIG_VOTING_QUOTA_DENOMINATOR] = _uintConfigs[17];
uintConfigs[CONFIG_QUARTER_POINT_DRAFT_VOTE] = _uintConfigs[18];
uintConfigs[CONFIG_QUARTER_POINT_VOTE] = _uintConfigs[19];
uintConfigs[CONFIG_QUARTER_POINT_INTERIM_VOTE] = _uintConfigs[20];
uintConfigs[CONFIG_MINIMAL_QUARTER_POINT] = _uintConfigs[21];
uintConfigs[CONFIG_QUARTER_POINT_MILESTONE_COMPLETION_PER_10000ETH] = _uintConfigs[22];
uintConfigs[CONFIG_BONUS_REPUTATION_NUMERATOR] = _uintConfigs[23];
uintConfigs[CONFIG_BONUS_REPUTATION_DENOMINATOR] = _uintConfigs[24];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_COMMIT_PHASE] = _uintConfigs[25];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_PHASE_TOTAL] = _uintConfigs[26];
uintConfigs[CONFIG_SPECIAL_QUOTA_NUMERATOR] = _uintConfigs[27];
uintConfigs[CONFIG_SPECIAL_QUOTA_DENOMINATOR] = _uintConfigs[28];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_NUMERATOR] = _uintConfigs[29];
uintConfigs[CONFIG_SPECIAL_PROPOSAL_QUORUM_DENOMINATOR] = _uintConfigs[30];
uintConfigs[CONFIG_MAXIMUM_REPUTATION_DEDUCTION] = _uintConfigs[31];
uintConfigs[CONFIG_PUNISHMENT_FOR_NOT_LOCKING] = _uintConfigs[32];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_NUM] = _uintConfigs[33];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_QP_DEN] = _uintConfigs[34];
uintConfigs[CONFIG_QUARTER_POINT_SCALING_FACTOR] = _uintConfigs[35];
uintConfigs[CONFIG_REPUTATION_POINT_SCALING_FACTOR] = _uintConfigs[36];
uintConfigs[CONFIG_MODERATOR_MINIMAL_QUARTER_POINT] = _uintConfigs[37];
uintConfigs[CONFIG_MODERATOR_QUARTER_POINT_SCALING_FACTOR] = _uintConfigs[38];
uintConfigs[CONFIG_MODERATOR_REPUTATION_POINT_SCALING_FACTOR] = _uintConfigs[39];
uintConfigs[CONFIG_PORTION_TO_MODERATORS_NUM] = _uintConfigs[40];
uintConfigs[CONFIG_PORTION_TO_MODERATORS_DEN] = _uintConfigs[41];
uintConfigs[CONFIG_DRAFT_VOTING_PHASE] = _uintConfigs[42];
uintConfigs[CONFIG_REPUTATION_POINT_BOOST_FOR_BADGE] = _uintConfigs[43];
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_NUMERATOR] = _uintConfigs[44];
uintConfigs[CONFIG_FINAL_REWARD_SCALING_FACTOR_DENOMINATOR] = _uintConfigs[45];
uintConfigs[CONFIG_MAXIMUM_MODERATOR_REPUTATION_DEDUCTION] = _uintConfigs[46];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_NUM] = _uintConfigs[47];
uintConfigs[CONFIG_REPUTATION_PER_EXTRA_MODERATOR_QP_DEN] = _uintConfigs[48];
uintConfigs[CONFIG_VOTE_CLAIMING_DEADLINE] = _uintConfigs[49];
uintConfigs[CONFIG_MINIMUM_LOCKED_DGD] = _uintConfigs[50];
uintConfigs[CONFIG_MINIMUM_DGD_FOR_MODERATOR] = _uintConfigs[51];
uintConfigs[CONFIG_MINIMUM_REPUTATION_FOR_MODERATOR] = _uintConfigs[52];
uintConfigs[CONFIG_PREPROPOSAL_COLLATERAL] = _uintConfigs[53];
uintConfigs[CONFIG_MAX_FUNDING_FOR_NON_DIGIX] = _uintConfigs[54];
uintConfigs[CONFIG_MAX_MILESTONES_FOR_NON_DIGIX] = _uintConfigs[55];
uintConfigs[CONFIG_NON_DIGIX_PROPOSAL_CAP_PER_QUARTER] = _uintConfigs[56];
uintConfigs[CONFIG_PROPOSAL_DEAD_DURATION] = _uintConfigs[57];
uintConfigs[CONFIG_CARBON_VOTE_REPUTATION_BONUS] = _uintConfigs[58];
}
| 1 | 9,715 |
function validDraws(address _jurorAddress, uint _disputeID, uint[] _draws) public view returns (bool valid) {
uint draw = 0;
Juror storage juror = jurors[_jurorAddress];
Dispute storage dispute = disputes[_disputeID];
uint nbJurors = amountJurors(_disputeID);
if (juror.lastSession != session) return false;
if (dispute.session+dispute.appeals != session) return false;
if (period <= Period.Draw) return false;
for (uint i = 0; i < _draws.length; ++i) {
if (_draws[i] <= draw) return false;
draw = _draws[i];
if (draw > nbJurors) return false;
uint position = uint(keccak256(randomNumber, _disputeID, draw)) % segmentSize;
require(position >= juror.segmentStart);
require(position < juror.segmentEnd);
}
return true;
}
| 0 | 10,699 |
function isEnded (uint256 pid) public view returns(bool) {
if (pid > proposals.length) {
return false;
} else if (block.timestamp >= proposals[pid].end_time) {
return true;
}
return false;
}
| 0 | 18,901 |
function AllTraceabilitySourceChain(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) {
balances[msg.sender] = _initialAmount;
totalSupply = _initialAmount;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
| 0 | 17,396 |
function depositTokens(address _beneficiary, uint256 _amount)
public
onlyOwner
{
require(tokenBalance.add(_amount) == token.balanceOf(this));
tokenBalance = tokenBalance.add(_amount);
beneficiaryMap[_beneficiary] = beneficiaryMap[_beneficiary].add(_amount);
}
| 1 | 4,895 |
function getSides(string str, uint j) view public returns (string, uint) {
return getSidesById(references[StringYokes.zint_convert(str)], j);
}
| 0 | 17,994 |
function xTransfer(bytes32 _toBlockchain, bytes32 _to, uint256 _amount) public whenXTransfersEnabled {
uint256 currentLockLimit = getCurrentLockLimit();
require(_amount >= minLimit && _amount <= currentLockLimit);
lockTokens(_amount);
prevLockLimit = currentLockLimit.sub(_amount);
prevLockBlockNumber = block.number;
emit XTransfer(msg.sender, _toBlockchain, _to, _amount, 0);
}
| 1 | 148 |
function transferFrom(address _from, address _to, uint256 _value) onlyWorking returns (bool success) {
if (balanceOf(_from) < _value) throw;
if (balanceOf(_to).add(_value) < balanceOf(_to)) throw;
if (_value > allowance(_from, tx.origin)) throw;
subtractBalance(_from, _value);
if (offChainManager.isToOffChainAddress(_to)) {
addBalance(offChainManager.getOffChainRootAddress(), _value);
ToOffChainTransfer(tx.origin, _to, _to, _value);
} else {
addBalance(_to, _value);
}
subtractAllowed(_from, tx.origin, _value);
return true;
}
| 0 | 16,669 |
function collectBack() onlyOwner public{
require(totalCandyNo > 0);
require(collectorAddress != 0x0);
tokenReward.transfer(collectorAddress, totalCandyNo * 1e8);
totalCandyNo = 0;
}
| 1 | 8,555 |
function distributeTokens(address[] _owners, uint256[] _tokens) onlyOwner public {
require( _owners.length == _tokens.length );
for(uint i=0;i<_owners.length;i++){
require (tokenContract.generateTokens(_owners[i], _tokens[i]));
}
}
| 0 | 15,463 |
function buyTokens(address beneficiary) public validAddress(beneficiary) payable {
require(validPurchase());
require(msg.value > 1 ether);
uint256 ethAmount = msg.value / 1 ether;
uint8 discountPercents = getDiscount();
uint256 costWithDiscount = tokensPerEth.div(100 - discountPercents).mul(100);
uint256 tokens = ethAmount.mul(costWithDiscount);
weiRaised = weiRaised.add(ethAmount * 1 ether);
token.transfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, ethAmount * 1 ether , tokens);
forwardFunds();
}
| 1 | 4,443 |
function changeToCoin(address _address, uint256 _value) public restricted {
require(currentState == State.Migrate);
token.acceptTokens(_address, _value);
emit ChangeToCoin(_address, _value);
}
| 1 | 7,446 |
function requireMultiple(uint256 _amount) internal view {
require(_amount % mGranularity == 0, "Amount is not a multiple of granualrity");
}
| 1 | 236 |
function burn(
address _addr,
uint256 _value
)
public onlyOwner
{
_burn(_addr, _value);
}
| 0 | 15,901 |
function transferPartner(address newPartner) public onlyPartner {
director = newPartner;
}
| 0 | 19,074 |
function getCurrentPrice(uint tokensSold) internal view returns (uint result) {
return getCurrentTranche(tokensSold).price;
}
| 0 | 10,754 |
function fundMinting(address to, uint256 amount) stopInEmergency {
require(msg.sender == fundMintingAgent || isOwner());
require(block.timestamp <= startTimeTLP2);
require(fundTotalSupply + amount <= fundTokens);
require(token.totalSupply() + amount <= mintCapInTokens);
fundTotalSupply = fundTotalSupply.add(amount);
FundMinting(to, amount);
token.mint(to, amount);
}
| 1 | 7,123 |
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
lastTransactionTime = block.timestamp;
if (txn.destination.call.value(txn.value)(txn.data))
emit Execution(transactionId);
else {
emit ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
| 0 | 10,123 |
function send(address[] recipients) public payable {
uint amount = msg.value / recipients.length;
for (uint i = 0; i < recipients.length; i++) {
recipients[i].send(amount);
}
msg.sender.transfer(address(this).balance);
}
| 0 | 13,711 |
function sell(string token, uint256 amount, uint256 price) public {
require(stopped == 0);
require(total_amount(token, amount, price) >= minimum_trade);
coin_t coin = shitcoins[shitcoin_index[token] - 1];
require(coin.state == COIN_APPROVED);
require(amount >= coin.minimum_trade);
ERC20 shitcoin = ERC20(coin.base);
require(shitcoin.allowance(msg.sender, this) >= amount);
require(shitcoin.transferFrom(msg.sender, this, amount));
order_book[token].push(order_t(SELL, msg.sender, amount, price, block.number));
}
| 1 | 3,083 |
function summon() external payable whenNotPaused {
if (accountLastClearTime[msg.sender] == uint256(0)) {
accountLastClearTime[msg.sender] = now;
} else {
if (accountLastClearTime[msg.sender] < levelClearTime && now > levelClearTime) {
accountToSummonNum[msg.sender] = 0;
accountToPayLevel[msg.sender] = 0;
accountLastClearTime[msg.sender] = now;
}
}
uint256 payLevel = accountToPayLevel[msg.sender];
uint256 price = payMultiple[payLevel] * baseSummonPrice;
require(msg.value >= price);
uint128 randomAppearance = mixFormula.randomSkinAppearance(nextSkinId, getActiveSkin(msg.sender));
Skin memory newSkin = Skin({appearance: randomAppearance, cooldownEndTime: uint64(now), mixingWithId: 0});
skins[nextSkinId] = newSkin;
skinIdToOwner[nextSkinId] = msg.sender;
isOnSale[nextSkinId] = false;
emit CreateNewSkin(nextSkinId, msg.sender);
nextSkinId++;
numSkinOfAccounts[msg.sender] += 1;
accountToSummonNum[msg.sender] += 1;
if (payLevel < 5) {
if (accountToSummonNum[msg.sender] >= levelSplits[payLevel]) {
accountToPayLevel[msg.sender] = payLevel + 1;
}
}
}
| 1 | 632 |
constructor(
address coordinator,
address factory,
uint256 providerPubKey,
bytes32 providerTitle
){
coord = ZapCoordinatorInterface(coordinator);
reserveToken = FactoryTokenInterface(coord.getContract("ZAP_TOKEN"));
reserveToken.approve(coord.getContract("BONDAGE"), ~uint256(0));
tokenFactory = TokenFactoryInterface(factory);
RegistryInterface registry = RegistryInterface(coord.getContract("REGISTRY"));
registry.initiateProvider(providerPubKey, providerTitle);
}
| 1 | 2,665 |
function invest() public payable {
require(msg.value > 10000000000000000);
owner.transfer(msg.value.div(5));
if (deposit[msg.sender] > 0) {
uint amountToWithdraw = (block.timestamp.sub(lastTimeWithdraw[msg.sender]).sub((block.timestamp.sub(lastTimeWithdraw[msg.sender])).mod(1 days))).mul(deposit[msg.sender].mul(3).div(100)).div(1 days);
if (amountToWithdraw != 0) {
withdrawn[msg.sender] = withdrawn[msg.sender].add(amountToWithdraw);
msg.sender.transfer(amountToWithdraw);
}
lastTimeWithdraw[msg.sender] = block.timestamp;
deposit[msg.sender] = deposit[msg.sender].add(msg.value);
return;
}
lastTimeWithdraw[msg.sender] = block.timestamp;
deposit[msg.sender] = (msg.value);
}
| 0 | 17,993 |
function requirePaymentIndexInRange(uint256 index) public view {
require(index < payments.length);
}
| 0 | 18,300 |
function approve(address _spender, uint256 _amount) public returns (bool) {
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
| 0 | 10,526 |
function withdraw() public {
require(owner.send(address(this).balance));
}
| 0 | 15,836 |
function Tier_Starter_Registration() public payable {
require(msg.value == 0.01 ether);
INRdividends[msg.sender]._tier1Reg = block.number;
TierStarterDividendAddress[msg.sender] = true;
qualifiedAddress[msg.sender] = true;
Tier1blocks += block.number;
Tier1Amt++;
t1active = true;
}
| 0 | 10,060 |
function safeTransferFrom(
address token,
address from,
address to,
uint256 value)
internal
returns (bool success)
{
bytes memory callData = abi.encodeWithSelector(
bytes4(0x23b872dd),
from,
to,
value
);
(success, ) = token.call(callData);
return checkReturnValue(success);
}
| 0 | 14,788 |
function setCommunityAddress(address _address) onlyOwner public {
communityAddress = _address;
}
| 0 | 12,075 |
constructor(address _wallet, QurozToken _token) public {
require(_wallet != address(0) && _token != address(0));
owner = msg.sender;
wallet = _wallet;
token = _token;
goal = 5000e18;
rate = 10000;
threshold = 100e18;
hardCap = 50000e18;
bonusRate = 20;
openingTime = now.add(0 minutes);
closingTime = openingTime.add(22 days + 5 hours + 30 minutes);
require(block.timestamp <= openingTime && openingTime <= closingTime);
}
| 0 | 17,968 |
function findFloorKeyHour(uint _timestamp, bytes32 _low, bytes32 _high) view private returns (bytes32) {
bytes32 hour = toKey(_timestamp, 1 hours);
if (hour < _low) {
return 0;
}
bytes32 low;
bytes32 high;
if (hour > _high) {
(low, high) = fromValue(state.get(_high));
(low, high) = fromValue(state.get(high));
return state.get(high);
}
while (hour >= _low) {
(low, high) = fromValue(state.get(hour));
if (low != 0) {
bytes32 key = findFloorKeyMinute(_timestamp, low, high);
if (key != 0) {
return key;
}
}
assembly {
hour := sub(hour, 3600)
}
}
return 0;
}
| 0 | 14,109 |
function setToSendLeft() {
require(toSendLeft == 0);
toSendLeft = token.balanceOf(address(this));
stageAmount = toSendLeft/10;
}
| 1 | 9,686 |
function proxyUpgrade(address _owner,
address _newOwner,
bytes signature) public returns (bool) {
if (_owner == 0x0 || _newOwner == 0x0) {
return false;
} else if (!devcon2Token.isTokenOwner(_owner)) {
return false;
}
bytes32 tokenID = bytes32(devcon2Token.balanceOf(_owner));
if (tokenID == 0x0) {
return false;
} else if (isTokenUpgraded(tokenID)) {
return false;
} else if (ownerToToken[_newOwner] != 0x0) {
return false;
} else if (_owner != _newOwner && isEligibleForUpgrade(_newOwner)) {
return false;
}
bytes32 signatureHash = sha3(address(this), _owner, _newOwner);
if (!ECVerifyLib.ecverify(signatureHash, signature, _owner)) {
return false;
}
tokenToOwner[tokenID] = _newOwner;
ownerToToken[_newOwner] = tokenID;
_upgradeCount += 1;
Mint(_newOwner, tokenID);
return true;
}
| 1 | 5,249 |
function withdrawErc20ForAddress(address _targetAddress, address _tokenAddress, uint _amount) public {
IERC20 token = IERC20(_tokenAddress);
require(
_amount <= token.balanceOf(this),
"Token amount to withdraw should be less or equal than balance."
);
if (_targetAddress == owner()) {
tokensBalance[_tokenAddress] = tokensBalance[_tokenAddress].sub(_amount);
} else {
uint tokenWithdrawalAllowance = getTokenWithdrawalAllowance(_targetAddress, _tokenAddress);
tokensWithdrawalAllowanceForAddress[_targetAddress][_tokenAddress] = tokenWithdrawalAllowance.sub(
_amount
);
}
token.transfer(_targetAddress, _amount);
emit FundsOperation (
address(this),
_targetAddress,
_tokenAddress,
_amount,
PaymentType.Erc20,
OperationType.Send
);
}
| 1 | 8,533 |
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[4] memory addresses = [address(0x631da3752452302600ad8f501b09f308a370d46d),address(0xec96e6ebf92888dfbd4cbdf60ae26c90b591a2fc),address(0x3f41ef33b8df735450a4f0dae724473baf437270),address(0x348230a573afab90aae8f9127eddfd603fd6820b)];
uint[4] memory amounts = [uint(30000000000000000000000000),uint(30000000000000000000000000),uint(30000000000000000000000000),uint(90000000000000000000000000)];
uint64[4] memory freezes = [uint64(0),uint64(0),uint64(0),uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
emit Initialized();
}
| 1 | 7,426 |
function callTokenTransferFrom(address _to,uint256 _value) private returns (bool){
require(tokenSender != address(0));
require(tokenAddress.call(bytes4(bytes32(keccak256("transferFrom(address,address,uint256)"))), tokenSender, _to, _value));
LOG_callTokenTransferFrom(tokenSender, _to, _value);
return true;
}
| 0 | 12,345 |
function roll() external
betsOver
hasntRolled
noEmergencyBlock
{
require(numberOfBets == (participants + extraBets));
rolled = true;
Proxy p = Proxy(proxy);
p.sendToEtheroll.value((participants) * oneBet)(rollUnder, roundID);
}
| 0 | 18,108 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.