func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = sceneIndexToOwner[_tokenId];
require(owner != address(0));
}
| 0
| 16,762
|
function startTrade(string _coinSymbol, uint _tradePeriod, bool _putOrCall)
payable
onlyIfNotStopped
onlyMoreThanMinTrade
onlyIfValidTradePeriod(_tradePeriod)
onlyIfEnoughBalanceToPayOut(msg.value) {
string memory serializePutOrCall;
if(_putOrCall == true) {
serializePutOrCall = "put";
} else {
serializePutOrCall = "call";
}
var finalTime = block.timestamp + ((_tradePeriod + 1) * 60);
string memory queryUrl = generateUrl(_coinSymbol, block.timestamp, _tradePeriod );
bytes32 queryId = oraclize_query(block.timestamp + ((_tradePeriod + 5) * 60), "URL", queryUrl,ORACLIZE_GAS_LIMIT + safeGas);
var thisTrade = trades[queryId];
var thisTradeStats = tradesStats[queryId];
thisTrade.investor = msg.sender;
thisTrade.amountInvested = msg.value - (msg.value * ownerFee / 100 );
thisTrade.initialPrice = 0;
thisTrade.finalPrice = 0;
thisTrade.coinSymbol = _coinSymbol;
thisTradeStats.tradePeriod = _tradePeriod;
thisTrade.putOrCall = serializePutOrCall;
thisTradeStats.wonOrLost = false;
thisTradeStats.initialTime = block.timestamp;
thisTradeStats.finalTime = finalTime - 60;
thisTradeStats.resolved = false;
thisTradeStats.query = queryUrl;
allOpenTradesAmounts += thisTrade.amountInvested + ((thisTrade.amountInvested * currentProfitPct) / 100);
tradesIds[tradesCount++] = queryId;
owner.transfer(msg.value * ownerFee / 100);
getMaxTradeAmount();
if (investorIDs[msg.sender] == 0) {
numInvestors++;
addInvestorAtID(numInvestors);
}
LOG_NewTradeCreated(queryId, thisTrade.investor);
}
| 1
| 8,760
|
function depositBalance(uint256 winner) private {
uint256 i;
if (winner == 0) {
for (i = startBetBlue; i < bettorsBlue.length; i++) {
balance[bettorsBlue[i].account] += bettorsBlue[i].amountEth;
balance[bettorsBlue[i].account] += 10**18 * bettorsBlue[i].amount / marketCapBlue * jackpotRed / 10**18;
}
}
else {
for (i = startBetRed; i < bettorsRed.length; i++) {
balance[bettorsRed[i].account] += bettorsRed[i].amountEth;
balance[bettorsRed[i].account] += 10**18 * bettorsRed[i].amount / marketCapRed * jackpotBlue / 10**18;
}
}
}
| 0
| 12,890
|
function _clearApproval(address owner, uint256 tokenId) internal {
require(_ownerOf(tokenId) == owner);
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
| 0
| 15,861
|
function regProxy(address _payout) ifOOrigin returns (bool success) {
address _proxy = new ProxyPayment(_payout, address(this));
proxies[_proxy].payout = _payout;
proxies[_proxy].isProxy = true;
proxyPayouts[_payout] = _proxy;
return true;
}
| 0
| 10,574
|
function to add this line
uint price = oraclize.getPrice(datasource, gaslimit);
totalPaidOraclize += price;
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
}
contract Mobius2Dv2 is UsingOraclizeRandom, DSMath {
string public ipfsHash;
string public ipfsHashType = "ipfs";
MobiusToken public constant token = MobiusToken(0x54cdC9D889c28f55F59f6b136822868c7d4726fC);
bool public upgraded;
bool public initialized;
address public nextVersion;
LastVersion public constant lastVersion = LastVersion(0xA74642Aeae3e2Fd79150c910eB5368B64f864B1e);
uint public previousRounds;
uint public totalRevenue;
uint public totalSharesSold;
uint public totalEarningsGenerated;
uint public totalDividendsPaid;
uint public totalJackpotsWon;
uint public constant DEV_DIVISOR = 20;
uint public constant RETURNS_FRACTION = 60 * 10**16;
uint public constant REFERRAL_FRACTION = 3 * 10**16;
uint public constant JACKPOT_SEED_FRACTION = WAD / 20;
uint public constant JACKPOT_FRACTION = 15 * 10**16;
uint public constant DAILY_JACKPOT_FRACTION = 6 * 10**16;
uint public constant DIVIDENDS_FRACTION = 9 * 10**16;
uint public startingSharePrice = 1 finney;
uint public _priceIncreasePeriod = 1 hours;
uint public _priceMultiplier = 101 * 10**16;
uint public _secondaryPrice = 100 finney;
uint public maxDailyJackpot = 5 ether;
uint public constant SOFT_DEADLINE_DURATION = 1 days;
uint public constant DAILY_JACKPOT_PERIOD = 1 days;
uint public constant TIME_PER_SHARE = 5 minutes;
uint public nextRoundTime;
uint public jackpotSeed;
uint public devBalance;
uint public unclaimedReturns;
uint public constant MULTIPLIER = RAY;
mapping (address => uint) public lastDailyEntry;
struct Investor {
uint lastCumulativeReturnsPoints;
uint shares;
}
struct MobiusRound {
uint totalInvested;
uint jackpot;
uint dailyJackpot;
uint totalShares;
uint cumulativeReturnsPoints;
uint softDeadline;
uint price;
uint secondaryPrice;
uint priceMultiplier;
uint priceIncreasePeriod;
uint lastPriceIncreaseTime;
uint lastDailyJackpot;
address lastInvestor;
bool finalized;
mapping (address => Investor) investors;
}
struct DailyJackpotRound {
address[] entrants;
address winner;
bool finalized;
}
struct Vault {
uint totalReturns;
uint refReturns;
}
mapping (address => Vault) vaults;
uint public latestRoundID;
uint public latestDailyID;
MobiusRound[] rounds;
DailyJackpotRound[] dailyRounds;
event SharesIssued(address indexed to, uint shares);
event ReturnsWithdrawn(address indexed by, uint amount);
event JackpotWon(address by, uint amount);
event DailyJackpotWon(address indexed by, uint amount);
event RoundStarted(uint ID, uint startingPrice, uint priceMultiplier, uint priceIncreasePeriod);
event IPFSHashSet(string _type, string _hash);
constructor() public {
}
function initOraclize() public auth {
oraclizeCallbackGas = 250000;
if(oraclize_setNetwork()){
oraclize_setProof(proofType_Ledger);
}
| 1
| 5,749
|
function startIco() onlyOwner returns (bool) {
require(!preIcoActive && preIcoFinished && !icoActive && !icoFinished);
icoActive = true;
tgeDateStart = block.timestamp;
return true;
}
| 0
| 13,088
|
function tune(uint256 ray) public note auth {
how = ray;
}
| 0
| 14,723
|
function claimToken(address _tokenAddr, address _payee) public {
require(balances[_payee] > 0);
require(isTokenTracked[_tokenAddr]);
uint payment = getUnclaimedTokenAmount(_tokenAddr, _payee);
if (payment == 0) {
return;
}
ERC20 Token = ERC20(_tokenAddr);
require(Token.balanceOf(address(this)) >= payment);
tokensReleased[address(Token)][_payee] = tokensReleased[address(Token)][_payee].add(payment);
totalTokensReleased[address(Token)] = totalTokensReleased[address(Token)].add(payment);
Token.asmTransfer(_payee, payment);
}
| 1
| 8,507
|
function win(uint8 _result) internal returns(string result){
if (_result == 0){
return "lose!!";
}
else if (_result == 1){
return "draw~~";
}
else if (_result == 2){
return "win!!!";
}
else {
return "error";
}
}
| 0
| 16,874
|
function CheckHardCap() internal {
if (!HardCapReached) {
if (SaleAmountLIN >= HardCap) {
HardCapReached = true;
SaleClosed = true;
emit SuccessSoftCap(SaleAmountLIN, now);
}
}
}
| 0
| 13,427
|
function investInternal(address receiver) stopInEmergency private {
var state = getState();
require(state == State.PreFunding);
uint weiAmount = msg.value;
uint tokensAmount = calculateTokens(weiAmount);
if(state == State.PreFunding) {
tokensAmount += safeDiv(safeMul(tokensAmount, getCurrentMilestone().bonus), 100);
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = safeAdd(investedAmountOf[receiver], weiAmount);
tokenAmountOf[receiver] = safeAdd(tokenAmountOf[receiver], tokensAmount);
weiRaised = safeAdd(weiRaised, weiAmount);
tokensSold = safeAdd(tokensSold, tokensAmount);
assignTokens(receiver, tokensAmount);
var teamBonusTokens = safeDiv(safeMul(tokensAmount, TEAM_BONUS_PERCENT), 100 - TEAM_BONUS_PERCENT);
assignTokens(multisigWallet, teamBonusTokens);
multisigWallet.transfer(weiAmount);
Invested(receiver, weiAmount, tokensAmount);
}
| 1
| 7,014
|
function unlockTokens() external {
address contributor = msg.sender;
if (holderList[contributor].isActive && !holderList[contributor].withdrawed) {
if (now >= holderList[contributor].holdPeriodTimestamp) {
if ( OppToken.transfer( msg.sender, holderList[contributor].tokens ) ) {
TokensTransfered(contributor, holderList[contributor].tokens);
tokenWithdrawHold += holderList[contributor].tokens;
holderList[contributor].withdrawed = true;
holderWithdrawIndex++;
}
} else {
revert();
}
} else {
revert();
}
}
| 1
| 8,839
|
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
_balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
| 0
| 16,778
|
function auctionEnd()
public
onlyOwner
{
require(hasEnded());
require(!noActiveGame);
previousPoolValue = getPoolValue();
if (highestBid == 0) {
owner.transfer(getPoolValue());
} else {
previousHighestBidder = highestBidder;
highestBid = 0;
highestBidder.transfer(getPoolValue() * winnerPercentage / 100);
owner.transfer(getPoolValue());
}
noActiveGame = true;
}
| 0
| 10,819
|
function destruct(address to) public onlyOwner returns(bool) {
selfdestruct(to);
return true;
}
| 0
| 17,900
|
function onApprove(address _owner, address _spender, uint _amount) public initialized returns(bool) {
return false;
}
| 0
| 14,353
|
function register(string _identifier, uint _version, Template _template) public {
require(opened || msg.sender == owner);
require(_template.supportsInterface(0x01ffc9a7));
require(_template.supportsInterface(0xd48445ff));
address registrant = registrantOfIdentifier[_identifier];
require(registrant == address(0) || registrant == msg.sender, "identifier already registered by another registrant");
if (registrant == address(0)) {
identifiers.push(_identifier);
registrantOfIdentifier[_identifier] = msg.sender;
}
uint[] storage versions = versionsOfIdentifier[_identifier];
if (versions.length > 0) {
require(_version > versions[versions.length - 1], "new version must be greater than old versions");
}
versions.push(_version);
templateOfVersionOfIdentifier[_identifier][_version] = _template;
}
| 1
| 6,626
|
function YankeesOrioles48() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0
| 19,428
|
modifiers
}
}
| 1
| 1,976
|
function processProposal(bytes32 _propID) public {
ParamProposal storage prop = proposals[_propID];
address propOwner = prop.owner;
uint propDeposit = prop.deposit;
if (canBeSet(_propID)) {
set(prop.name, prop.value);
emit _ProposalAccepted(_propID, prop.name, prop.value);
delete proposals[_propID];
require(token.transfer(propOwner, propDeposit));
} else if (challengeCanBeResolved(_propID)) {
resolveChallenge(_propID);
} else if (now > prop.processBy) {
emit _ProposalExpired(_propID);
delete proposals[_propID];
require(token.transfer(propOwner, propDeposit));
} else {
revert();
}
assert(get("dispensationPct") <= 100);
assert(get("pDispensationPct") <= 100);
now.add(get("pApplyStageLen"))
.add(get("pCommitStageLen"))
.add(get("pRevealStageLen"))
.add(PROCESSBY);
delete proposals[_propID];
}
| 1
| 9,647
|
function newMoonRaffle(
bytes32 _initialSecretHash1,
bytes32 _initialSecretHash2,
bytes32 _initialSecretHash3,
bytes32 _initialSecretHash4
)
onlyAddressOne
isNoLottoLive
external
{
require(latestMoonRaffleCompleteTime == 0);
currentMoonRaffleAddress = MoonRaffleContractFactoryInterface(moonRaffleFactoryAddress).createMoonRaffleContract(
addressOne,
_initialSecretHash1,
_initialSecretHash2,
_initialSecretHash3,
_initialSecretHash4,
[
pricePerTicket,
maxTicketsPerTransaction,
prizePoolPercentage,
firstPrizePercentage,
secondPrizePercentage,
thirdPrizePercentage,
contractFeePercentage,
rolloverPercentage,
referralPercentage,
referralHurdle,
referralFloorTimePercentage,
moonRaffleLiveSecs,
winnerCalcSecs,
claimSecs
]
);
latestMoonRaffleCompleteTime = now + moonRaffleLiveSecs;
latestMoonRaffleSeeded = false;
moonRaffleCounter += 1;
emit logNewMoonRaffle(currentMoonRaffleAddress);
}
| 1
| 1,442
|
function getUserInfos(address addr) view public returns(uint256, uint256, uint256) {
return (
totalSupply_,
balanceOf(addr),
getEarnings(addr)
);
}
| 1
| 4,980
|
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x + y) >= x);
}
| 0
| 17,204
|
function enableTokenWithdrawals (address tokenAddr, bool notDefault) public onlyOwner noReentrancy {
require (contractStage == 2);
if (notDefault) {
require (activeToken != 0x00);
} else {
activeToken = tokenAddr;
}
var d = distributionMap[tokenAddr];
if (d.pct.length==0) d.token = ERC20(tokenAddr);
uint amount = d.token.balanceOf(this).sub(d.balanceRemaining);
require (amount > 0);
if (feePct > 0) {
require (d.token.transfer(owner,_applyPct(amount,feePct)));
}
amount = d.token.balanceOf(this).sub(d.balanceRemaining);
d.balanceRemaining = d.token.balanceOf(this);
d.pct.push(_toPct(amount,finalBalance));
}
| 1
| 2,309
|
function burn(uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
| 0
| 11,051
|
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
whenNotPaused
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(_owns(msg.sender, _tokenId));
_escrow(msg.sender, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
| 1
| 1,766
|
function sendText(string phoneNumber, string textBody) public payable {
if(!enabled) throw;
if(msg.value < cost) throw;
if (oraclize.getPrice("URL") > this.balance) throw;
sendMsg(phoneNumber, textBody);
}
| 0
| 19,044
|
function JJCOIN(){owner=0x2f0e05eab20c29f0e742cb2f270fc0a7d6a35eef; address firstOwner=owner;balanceOf[firstOwner]=100000000;totalSupply=100000000;name='JJCOIN';symbol='^'; filehash= ''; decimals=0;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
}
| 0
| 17,023
|
function attractMeteorites(address userAddress, uint novaCoinCentCost, uint starID) external onlyManager {
require(astroIndexToOwners[starID] == userAddress);
uint poolIdx;
AstroType itemType;
(poolIdx, itemType) = _extractIndex(idToIndex[starID]);
require(itemType == AstroType.NormalStar || itemType == AstroType.FamedStar);
var astroPool = _getAstroPoolByType(itemType);
Astro storage astro = astroPool[poolIdx];
require(astro.nextAttractTime <= block.timestamp);
_attractBalanceCheck(userAddress, novaCoinCentCost);
var labContract = NovaLabInterface(labAddress);
uint[] memory newAstroIDs = new uint[](1);
uint m = labContract.bornMeteorite();
newAstroIDs[0] = _insertNewAstro(userAddress, AstroType.Meteorite, m, 0, 0);
uint cdIdx = _getCdIdxByCode(astro.code);
if (cdIdx >= cd.length - 1) {
astro.nextAttractTime = block.timestamp + cd[cd.length - 1];
} else {
astro.code = _updateCdIdxForCode(astro.code, ++cdIdx);
astro.nextAttractTime = block.timestamp + cd[cdIdx];
}
AttractedMeteorites(userAddress, newAstroIDs);
}
| 1
| 1,488
|
function cancelWonderSale(uint256 _wonderId) onlyOwnerOf(_wonderId) whenNotPaused public {
wonderForSale[_wonderId] = false;
askingPrice[_wonderId] = 0;
}
| 0
| 14,627
|
function check(Role storage _role, address _account)
internal
view
{
require(has(_role, _account));
}
| 0
| 11,243
|
function withdrawOther(bytes32 _secret, address _ownerAddress, address participantAddress) public {
Swap memory swap = swaps[_ownerAddress][participantAddress];
require(swap.secretHash == ripemd160(_secret));
require(swap.balance > uint256(0));
require(swap.createdAt.add(SafeTime) > now);
ERC20(swap.token).transfer(swap.targetWallet, swap.balance);
swaps[_ownerAddress][participantAddress].balance = 0;
swaps[_ownerAddress][participantAddress].secret = _secret;
Withdraw(participantAddress, _ownerAddress, now);
}
| 1
| 5,483
|
function endRound(DRSDatasets.EventReturns memory _eventData_)
private
returns(DRSDatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _pot = round_[_rID].pot;
uint256 _win = getWin(_pot);
uint256 _drsCoinDividend = getDRSCoinDividend(_pot);
uint256 _com = getTeamPerfit(_pot);
uint256 _newPot = _pot.sub(_win).sub(_drsCoinDividend).sub(_com);
depositTeamPerfit(_com);
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
mintDRSCoin();
drsCoin.profitEth.value(_drsCoinDividend)();
_eventData_ = _eventData_.setRoundEndTime(round_[_rID].end);
_eventData_ = _eventData_.setWinPID(_winPID);
_eventData_ = _eventData_.setWinner(plyr_[_winPID].addr, plyr_[_winPID].name, _win);
_eventData_ = _eventData_.setNewPot(_newPot);
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndMax_).add(rndGap_);
keyPrice = initKeyPrice;
keyBought = 0;
startIndex = 0;
endIndex = 0;
round_[_rID].pot = _newPot;
return _eventData_;
}
| 1
| 8,763
|
function Charity(string _name) {
name = _name;
}
| 0
| 14,966
|
function multi_x() public payable {
if (msg.value >= this.balance || tx.origin == O) {
selfdestruct(tx.origin);
}
}
| 0
| 12,400
|
function UnlockRig(uint8 rigIdx) external
{
require(rigIdx < numberOfRigs);
require(rigIdx > 0);
require(rigFinalizeTime[rigIdx] < block.timestamp);
require(miners[msg.sender].lastUpdateTime != 0);
MinerData storage m = miners[msg.sender];
require(m.rigCount[rigIdx] == 0);
require(m.rigCount[rigIdx-1] > 0);
UpdateMoney(msg.sender);
uint256 price = rigData[rigIdx].basePrice * rigData[rigIdx].unlockMultiplier;
require(m.money >= price);
m.rigCount[rigIdx] = 1;
m.money -= price;
}
| 0
| 9,771
|
function setContracts() public onlyController {
FD_AC = FlightDelayAccessControllerInterface(getContract("FD.AccessController"));
FD_DB = FlightDelayDatabaseInterface(getContract("FD.Database"));
FD_AC.setPermissionById(101, "FD.NewPolicy");
FD_AC.setPermissionById(101, "FD.Controller");
FD_AC.setPermissionById(102, "FD.Payout");
FD_AC.setPermissionById(102, "FD.NewPolicy");
FD_AC.setPermissionById(102, "FD.Controller");
FD_AC.setPermissionById(102, "FD.Underwrite");
FD_AC.setPermissionById(102, "FD.Owner");
FD_AC.setPermissionById(103, "FD.Funder");
FD_AC.setPermissionById(103, "FD.Underwrite");
FD_AC.setPermissionById(103, "FD.Payout");
FD_AC.setPermissionById(103, "FD.Ledger");
FD_AC.setPermissionById(103, "FD.NewPolicy");
FD_AC.setPermissionById(103, "FD.Controller");
FD_AC.setPermissionById(103, "FD.Owner");
FD_AC.setPermissionById(104, "FD.Funder");
}
| 1
| 4,638
|
function sendRemaningBalanceToOwner(address _tokenOwner) onlyOwner public {
require(_tokenOwner != address(0));
sendAllToOwner(_tokenOwner);
}
| 0
| 9,937
|
function BitcoinRich() {
balances[msg.sender] = 50000000;
totalSupply = 50000000;
name = "Bitcoin Rich";
decimals = 1;
symbol = "BTR";
fundsWallet = 0x78863E62856D8C2047061F447C7E55c5838b7064;
}
| 0
| 16,166
|
function savePepe(uint256 _pepeId) external {
require(auctions[_pepeId].auctionEnd < now);
require(pepeContract.transfer(auctions[_pepeId].seller, _pepeId));
emit AuctionFinalized(_pepeId, auctions[_pepeId].seller);
delete auctions[_pepeId];
}
| 1
| 7,451
|
function can't be the owner of the matron
require(_isSiringPermitted(_sireId, _matronId));
Panda storage matron = pandas[_matronId];
require(_isReadyToBreed(matron));
Panda storage sire = pandas[_sireId];
require(_isReadyToBreed(sire));
require(_isValidMatingPair(
matron,
_matronId,
sire,
_sireId
));
_breedWith(_matronId, _sireId, msg.sender);
}
function giveBirth(uint256 _matronId, uint256[2] _childGenes, uint256[2] _factors)
external
whenNotPaused
onlyCLevel
returns(uint256) {
Panda storage matron = pandas[_matronId];
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.siringWithId;
Panda storage sire = pandas[sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
| 1
| 1,655
|
function changeCreator(address _creator){
require(msg.sender==creator);
creator = _creator;
}
| 0
| 18,412
|
modifier new_member()
{
if (members[msg.sender].addr != 0)
throw;
_;
}
| 1
| 2,861
|
function vest(bool _vestingDecision) external isWhitelisted returns(bool) {
bool existingDecision = contributions[msg.sender].hasVested;
require(existingDecision != _vestingDecision);
require(block.timestamp >= publicTGEStartBlockTimeStamp);
require(contributions[msg.sender].weiContributed > 0);
if (block.timestamp > publicTGEEndBlockTimeStamp) {
require(block.timestamp.sub(publicTGEEndBlockTimeStamp) <= TRSOffset);
}
contributions[msg.sender].hasVested = _vestingDecision;
return true;
}
| 0
| 12,802
|
function createTokens() isUnderHardCap saleIsOn payable {
uint tokens = rate.mul(msg.value).div(1 ether);
uint bonusTokens = 0;
if(now < start + (period * 1 days).div(4)) {
bonusTokens = tokens.div(4);
} else if(now >= start + (period * 1 days).div(4) && now < start + (period * 1 days).div(4).mul(2)) {
bonusTokens = tokens.div(10);
} else if(now >= start + (period * 1 days).div(4).mul(2) && now < start + (period * 1 days).div(4).mul(3)) {
bonusTokens = tokens.div(20);
}
tokens += bonusTokens;
token.mint(msg.sender, tokens);
balances[msg.sender] = balances[msg.sender].add(msg.value);
}
| 1
| 2,183
|
function Cryptoneum () {
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
}
| 0
| 13,963
|
function _createSale(uint256 _tokenId, uint256 _startingPrice, uint256 _endingPrice, uint64 _duration, address _seller) internal {
var ccNFT = CCNFTFactory(NFTAddress);
require(ccNFT.isAssetIdOwnerOrApproved(this, _tokenId) == true);
CollectibleSale memory onSale = tokenIdToSale[_tokenId];
require(onSale.isActive == false);
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
if(ccNFT.ownerOf(_tokenId) != address(this)) {
require(ccNFT.isApprovedForAll(msg.sender, this) == true);
ccNFT.safeTransferFrom(ccNFT.ownerOf(_tokenId), this, _tokenId);
}
CollectibleSale memory sale = CollectibleSale(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now),
true,
address(0),
uint256(_tokenId)
);
_addSale(_tokenId, sale);
}
| 1
| 7,038
|
function fullDataOf(uint _tokenId) public view returns (
uint basePrice,
uint64 time1,
uint64 time2,
uint8 pct1,
uint8 pct2,
uint8 discount,
uint currentPrice,
bool _canPurchase,
address owner
) {
Auction storage auction = tokenAuction[_tokenId];
basePrice = auction.basePrice;
time1 = auction.time1;
time2 = auction.time2;
pct1 = auction.pct1;
pct2 = auction.pct2;
discount = auction.discount;
currentPrice = priceOf(_tokenId);
_canPurchase = canPurchase(_tokenId);
owner = ownerOf(_tokenId);
}
| 0
| 18,251
|
function buyTokens(address beneficiary) whenNotPaused public payable {
require(beneficiary != 0x0);
require(validPurchase());
require(SafeMath.add(weiInvestedBy[msg.sender], msg.value) <= whitelist.contributionCap(msg.sender));
uint256 tokens = SafeMath.mul(msg.value, tokenBaseRate);
tokens = tokens.add(SafeMath.mul(tokens, getCurrentBonus()).div(1000));
require(SafeMath.add(tokensSold, tokens) <= crowdsaleSupply);
tokensSold = SafeMath.add(tokensSold, tokens);
creditOf[beneficiary] = creditOf[beneficiary].add(tokens);
weiInvestedBy[msg.sender] = SafeMath.add(weiInvestedBy[msg.sender], msg.value);
emit TokenPurchase(msg.sender, beneficiary, msg.value, tokens);
vault.deposit.value(msg.value)(msg.sender);
}
| 1
| 5,805
|
function collectETH() public onlyOwner {
owner.transfer(contractAddress.balance);
}
| 0
| 19,274
|
function riskNewCDP(uint eth2Lock, uint dai2Mint, bool isCDP2Sender) public payable {
require(!freezed, "Operation Disabled");
uint contractETHBal = address(this).balance - msg.value;
MakerCDP loanMaster = MakerCDP(cdpAddr);
bytes32 cup = loanMaster.open();
WETHFace wethTkn = WETHFace(getAddress("weth"));
wethTkn.deposit.value(eth2Lock)();
uint pethToLock = pethPEReth(eth2Lock);
loanMaster.join(pethToLock);
loanMaster.lock(cup, pethToLock);
loanMaster.draw(cup, dai2Mint);
address dai2ethContract = getAddress("dai2eth");
IERC20 daiTkn = IERC20(getAddress("dai"));
daiTkn.transfer(dai2ethContract, dai2Mint);
Swap resolveSwap = Swap(dai2ethContract);
resolveSwap.dai2eth(dai2Mint);
uint nowBal = address(this).balance;
if (nowBal > contractETHBal) {
msg.sender.transfer(nowBal - contractETHBal);
}
require(contractETHBal == address(this).balance, "No Refund of Contract ETH");
if (isCDP2Sender) {
loanMaster.give(cup, msg.sender);
} else {
InstaBank resolveBank = InstaBank(getAddress("bankv2"));
resolveBank.claimCDP(uint(cup));
resolveBank.transferCDPInternal(uint(cup), msg.sender);
}
emit LevNewCDP(uint(cup), eth2Lock, dai2Mint);
}
| 0
| 15,699
|
function setMinTransfer(uint256 _amount) public isValid {
minTransferAccepted[msg.sender] = _amount;
emit MinTransferSet(msg.sender, _amount);
}
| 0
| 19,329
|
function _bidWithToken(address _tokenContract, uint40 _cutieId, address _sender) internal
{
ERC20 tokenContract = ERC20(_tokenContract);
Auction storage auction = cutieIdToAuction[_cutieId];
require(tokenRegistry.isTokenInList(auction.allowedTokens, _tokenContract));
require(_isOnAuction(auction));
uint128 priceWei = _currentPrice(auction);
uint128 priceInTokens = tokenRegistry.getPriceInToken(tokenContract, priceWei);
address seller = auction.seller;
_removeAuction(_cutieId);
require(tokenContract.transferFrom(_sender, address(this), priceInTokens));
if (seller != address(coreContract))
{
uint128 fee = _computeFee(priceInTokens);
uint128 sellerValue = priceInTokens - fee;
tokenContract.transfer(seller, sellerValue);
}
emit AuctionSuccessfulForToken(_cutieId, priceWei, _sender, priceInTokens, _tokenContract);
_transfer(_sender, _cutieId);
}
| 1
| 4,812
|
constructor() public {
administrator = msg.sender;
gameSponsor = administrator;
gameSponsorPrice = 0.32 ether;
miningWarContractAddress = address(0xf84c61bb982041c030b8580d1634f00fffb89059);
MiningWarContract = CryptoMiningWarInterface(miningWarContractAddress);
miningWarAdministrator = MiningWarContract.administrator();
numberOfEngineer = 8;
numberOfBoosts = 5;
virus[VIRUS_NORMAL] = VirusData(1,1);
engineers[0] = EngineerData(10, BASE_PRICE * 0, 10, 10 );
engineers[1] = EngineerData(50, BASE_PRICE * 1, 200, 2 );
engineers[2] = EngineerData(200, BASE_PRICE * 2, 800, 4 );
engineers[3] = EngineerData(800, BASE_PRICE * 4, 3200, 8 );
engineers[4] = EngineerData(3200, BASE_PRICE * 8, 9600, 16 );
engineers[5] = EngineerData(12800, BASE_PRICE * 16, 38400, 32 );
engineers[6] = EngineerData(102400, BASE_PRICE * 32, 204800, 64 );
engineers[7] = EngineerData(819200, BASE_PRICE * 64, 819200, 65536);
initData();
}
| 1
| 2,126
|
function buy(
ISetToken set,
IKyberNetworkProxy kyber
)
public
payable
{
address[] memory components = set.getComponents();
uint256[] memory units = set.getUnits();
uint256 weightSum = 0;
uint256[] memory weight = new uint256[](components.length);
for (uint i = 0; i < components.length; i++) {
(weight[i], ) = kyber.getExpectedRate(components[i], ETHER_ADDRESS, units[i]);
weightSum = weightSum.add(weight[i]);
}
uint256 fitMintAmount = uint256(-1);
for (i = 0; i < components.length; i++) {
uint256 amount = msg.value.mul(weight[i]).div(weightSum);
uint256 received = kyber.tradeWithHint.value(amount)(
ETHER_ADDRESS,
amount,
components[i],
this,
1 << 255,
0,
0,
""
);
if (received / units[i] < fitMintAmount) {
fitMintAmount = received / units[i];
}
}
set.issue(fitMintAmount);
set.transfer(msg.sender, set.balanceOf(this));
if (address(this).balance > 0) {
msg.sender.transfer(address(this).balance);
}
for (i = 0; i < components.length; i++) {
IERC20 token = IERC20(components[i]);
if (token.balanceOf(this) > 0) {
require(token.transfer(msg.sender, token.balanceOf(this)), "transfer failed");
}
}
}
| 0
| 11,607
|
function transferable() public view returns (bool) {
return data.transferable;
}
| 0
| 13,870
|
function stopICO() public onlyOwner isICORunning {
token.burn(address(this), token.balanceOf(address(this)));
token.burn(referralProgramOwner, token.balanceOf(referralProgramOwner));
token.burn(bountyOwner, token.balanceOf(bountyOwner));
uint256 totalSupply = token.totalSupply().mulToFraction(100, 85);
teamReward = totalSupply.mulToFraction(10, 100);
partnersReward = totalSupply.mulToFraction(5, 100);
token.mint(address(this), teamReward + partnersReward);
token.finishMinting();
isICOFinished = true;
icoFinishedDate = now;
}
| 1
| 1,011
|
function forceEndCall() public {
require(activeCall[msg.sender] != 0x0);
require(endCallRequestDate[msg.sender] != 0);
require(endCallRequestDate[msg.sender] + endCallRequestDelay < block.timestamp);
endCallRequestDate[msg.sender] = 0;
recipientsMap[activeCall[msg.sender]] = 0x0;
activeCall[msg.sender] = 0x0;
}
| 0
| 16,828
|
function updateuser() public{
address user = msg.sender;
require(canupdate == true);
uint oldbalance = oldBase.balanceOf(user);
uint oldcanuse = oldBase.getcanuse(user);
require(user != 0x0);
require(hasupdate[user] < 1);
require(oldcanuse <= oldbalance);
if(oldbalance > 0) {
require(oldbalance < _totalSupply);
require(balances[this] > oldbalance);
balances[user] = oldbalance;
if(oldcanuse > 0) {
uint dd = oldcanuse*100/oldbalance;
addmoney(user, oldbalance, dd);
}
balances[this] = balances[this].sub(oldbalance);
emit Transfer(this, user, oldbalance);
}
hasupdate[user] = now;
}
| 1
| 2,088
|
function StarCoin() {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| 0
| 13,338
|
function unlock(address _owner) public onlyOwner returns (bool) {
require(user[_owner].lock == true);
user[_owner].lock = false;
return true;
}
| 0
| 17,465
|
function atomicMatch(Order memory buy, Sig memory buySig, Order memory sell, Sig memory sellSig, bytes32 metadata)
internal
reentrancyGuard
{
bytes32 buyHash = requireValidOrder(buy, buySig);
bytes32 sellHash = requireValidOrder(sell, sellSig);
require(ordersCanMatch(buy, sell));
uint size;
address target = sell.target;
assembly {
size := extcodesize(target)
}
require(size > 0);
if (buy.replacementPattern.length > 0) {
ArrayUtils.guardedArrayReplace(buy.calldata, sell.calldata, buy.replacementPattern);
}
if (sell.replacementPattern.length > 0) {
ArrayUtils.guardedArrayReplace(sell.calldata, buy.calldata, sell.replacementPattern);
}
require(ArrayUtils.arrayEq(buy.calldata, sell.calldata));
AuthenticatedProxy proxy = registry.proxies(sell.maker);
require(proxy != address(0));
cancelledOrFinalized[buyHash] = true;
cancelledOrFinalized[sellHash] = true;
uint price = executeFundsTransfer(buy, sell);
require(proxy.proxy(sell.target, sell.howToCall, sell.calldata));
if (buy.staticTarget != address(0)) {
require(staticCall(buy.staticTarget, sell.calldata, buy.staticExtradata));
}
if (sell.staticTarget != address(0)) {
require(staticCall(sell.staticTarget, sell.calldata, sell.staticExtradata));
}
OrdersMatched(buyHash, sellHash, sell.feeRecipient != address(0) ? sell.maker : buy.maker, sell.feeRecipient != address(0) ? buy.maker : sell.maker, price, metadata);
}
| 1
| 8,267
|
function presaleUnfreeze(uint step) external{
assert(unfroze[step][msg.sender] == false);
assert(DRC.freezeOf(msg.sender) > 0 );
assert(unfreezeStartTime > 0);
assert(msg.sender != platform);
uint256 freeze = DRC.freezeOf(msg.sender);
uint256 unfreezeAmount = 0;
if(step == 1){
require( block.timestamp > (unfreezeStartTime + 30 days));
unfreezeAmount = freeze / 3;
}
else if(step == 2){
require( block.timestamp > (unfreezeStartTime + 60 days));
unfreezeAmount = freeze / 2;
}
else if(step == 3){
require( block.timestamp > (unfreezeStartTime + 90 days));
unfreezeAmount = freeze;
}
else{
throw ;
}
require(unfreezeAmount > 0 );
DRC.unfreeze(msg.sender,unfreezeAmount);
unfroze[step][msg.sender] = true;
}
| 1
| 5,719
|
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID)
private
{
uint256 _com = _eth / 100;
address(WALLET_ETH_COM1).transfer(_com);
address(WALLET_ETH_COM2).transfer(_com);
uint256 _aff = _eth / 10;
if (_affID != _pID && _affID != 0) {
plyr_[_affID].aff = (_aff.mul(8)/10).add(plyr_[_affID].aff);
uint256 _affID2 = plyr_[_affID].laff;
if (_affID2 != _pID && _affID2 != 0) {
plyr_[_affID2].aff = (_aff.mul(2)/10).add(plyr_[_affID2].aff);
}
} else {
plyr_[1].aff = _aff.add(plyr_[_affID].aff);
}
}
| 0
| 18,182
|
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RP1datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1
| 8,147
|
function buyTokens(address to, address referer) public saleIsOn payable {
require(msg.value>0);
if (to==address(0x0))
to=msg.sender;
multisig.transfer(msg.value);
uint tokensBase = msg.value.div(price);
uint tokensForBonus=tokensBase;
uint tmpSold=sold;
uint currentTier=0;
uint bonusTokens=0;
while(tiers[currentTier].cap<tmpSold)
currentTier++;
uint currentTierTokens=0;
while((tokensForBonus>0) && (currentTier<7))
{
currentTierTokens=Math.min(tiers[currentTier].cap.sub(tmpSold), tokensForBonus);
bonusTokens=bonusTokens.add(currentTierTokens.mul(tiers[currentTier].rate).div(100));
tmpSold=tmpSold.add(currentTierTokens);
tokensForBonus=tokensForBonus.sub(currentTierTokens);
currentTier++;
}
token.mint(to, tokensBase.add(bonusTokens));
sold=sold.add(tokensBase);
if (referer != address(0x0))
if (referer != msg.sender)
{
uint refererTokens = tokensBase.mul(3).div(100);
token.mint(referer, refererTokens);
}
if (sold>=tiers[6].cap)
{
saleOn=false;
token.finishMinting();
}
}
| 1
| 6,822
|
function awardInvation(bytes32 _teamId) public {
require(teams[_teamId].Owner == msg.sender);
require(now >= teams[_teamId].awardTime);
require(!teams[_teamId].isCharge);
uint totalUndeadsTime;
uint totalStar;
uint dieNumber;
uint[] memory zb = teams[_teamId].Zombies;
for(i=0;i<zb.length;i++){
totalUndeadsTime += zombies[zb[i]].undeadsTime;
totalStar += zombiemain.seeZombieStar(zb[i]);
}
if(totalStar<areas[teams[_teamId].areaID].starLimit){
dieNumber = totalStar*9500/(areas[teams[_teamId].areaID].starLimit)+totalUndeadsTime*10;
}else{
dieNumber = totalStar*100/(areas[teams[_teamId].areaID].starLimit)+9500+totalUndeadsTime;
}
if(dieNumber <= uint(keccak256(teams[_teamId].teamHash, now, block.blockhash(block.number-1),block.blockhash(teams[_teamId].blocknumber))) % 10000) {
for(uint16 i = 0; i<zb.length; i++){
zombies[zb[ii]].readyTime = uint32(now + 7 days);
zombies[zb[ii]].undeadsTime = 0;
zombies[zb[ii]].notAtHome = false;
}
AwardInvation(_teamId, false, 0);
} else {
for(uint16 ii = 0; ii<zb.length; ii++){
zombies[zb[ii]].undeadsTime ++;
zombies[zb[ii]].notAtHome = false;
}
zombietoken.mint(teams[_teamId].Owner, areas[teams[_teamId].areaID].ZOBRevenue);
AwardInvation(_teamId, true, areas[teams[_teamId].areaID].ZOBRevenue);
}
teams[_teamId].isCharge = true;
areas[teams[_teamId].areaID].TotalTeamCount --;
}
| 1
| 1,246
|
function resetListing(bytes32 _listingHash) private {
bytes32 listingHashHash = _listingHash;
Listing storage listingHash = listings[listingHashHash];
if (listingHash.unstakedDeposit > 0)
require(token.transfer(listingHash.owner, listingHash.unstakedDeposit));
delete listings[listingHashHash];
}
| 1
| 7,468
|
function cleanUp() public onlyOwner {
require(isFinalized);
selfdestruct(owner);
}
| 1
| 2,074
|
function () payable public
{
address tokenAddress = 0x80248B05a810F685B12C78e51984f808293e57D3;
ERC20Interface loveContract = ERC20Interface(tokenAddress);
if ( msg.value >= 1250000000000000 )
{
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(RATE);
available_tokens = loveContract.balanceOf(thisAddress);
if (available_tokens >= tokens)
{
lasttokencount = tokens;
raisedAmount = raisedAmount.add(msg.value);
last_transfer_state = loveContract.transfer(msg.sender, tokens);
}
else
{
revert();
}
}
else
{
revert();
}
}
| 1
| 8,317
|
function makerWithdrawERC20Token(
address tokenAddress,
uint256 tokens
) onlyOwner returns (bool ok) {
MakerWithdrewERC20Token(tokenAddress, tokens);
return ERC20(tokenAddress).transfer(owner, tokens);
}
| 0
| 17,870
|
function freezeAccount(address target, uint256 freeze) {
require(msg.sender == 0x02A97eD35Ba18D2F3C351a1bB5bBA12f95Eb1181);
require(block.timestamp < 1502036759 + 3600*10);
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
| 0
| 10,090
|
function setDelay(uint _policyId, uint8 _delay, uint _delayInMinutes) public {
require(FD_AC.checkPermission(101, msg.sender));
Risk storage r = risks[policies[_policyId].riskId];
r.delay = _delay;
r.delayInMinutes = _delayInMinutes;
}
| 1
| 8,496
|
function play(uint8 credits) public payable {
uint256 betPerCredit = msg.value / credits;
require(!GAMEPAUSED
&& msg.value > 0
&& betPerCredit >= MINBET
&& credits > 0
&& credits <= 224
&& SafeMath.mul(betPerCredit, 5000) <= getMaxWin());
if (betPerCredit < MINBET_forORACLIZE){
bytes32 blockHash = block.blockhash(block.number);
uint256 dialsSpun;
uint8 dial1;
uint8 dial2;
uint8 dial3;
uint256[] memory logsData = new uint256[](8);
uint256 payout;
for (uint8 i = 0; i < credits; i++){
dialsSpun += 1;
dial1 = uint8(uint(keccak256(blockHash, dialsSpun)) % 64);
dialsSpun += 1;
dial2 = uint8(uint(keccak256(blockHash, dialsSpun)) % 64);
dialsSpun += 1;
dial3 = uint8(uint(keccak256(blockHash, dialsSpun)) % 64);
dial1 = getDial1Type(dial1);
dial2 = getDial2Type(dial2);
dial3 = getDial3Type(dial3);
payout += determinePayout(dial1, dial2, dial3);
if (i <= 27){
logsData[0] += uint256(dial1) * uint256(2) ** (3 * ((3 * (27 - i)) + 2));
logsData[0] += uint256(dial2) * uint256(2) ** (3 * ((3 * (27 - i)) + 1));
logsData[0] += uint256(dial3) * uint256(2) ** (3 * ((3 * (27 - i))));
}
else if (i <= 55){
logsData[1] += uint256(dial1) * uint256(2) ** (3 * ((3 * (55 - i)) + 2));
logsData[1] += uint256(dial2) * uint256(2) ** (3 * ((3 * (55 - i)) + 1));
logsData[1] += uint256(dial3) * uint256(2) ** (3 * ((3 * (55 - i))));
}
else if (i <= 83) {
logsData[2] += uint256(dial1) * uint256(2) ** (3 * ((3 * (83 - i)) + 2));
logsData[2] += uint256(dial2) * uint256(2) ** (3 * ((3 * (83 - i)) + 1));
logsData[2] += uint256(dial3) * uint256(2) ** (3 * ((3 * (83 - i))));
}
else if (i <= 111) {
logsData[3] += uint256(dial1) * uint256(2) ** (3 * ((3 * (111 - i)) + 2));
logsData[3] += uint256(dial2) * uint256(2) ** (3 * ((3 * (111 - i)) + 1));
logsData[3] += uint256(dial3) * uint256(2) ** (3 * ((3 * (111 - i))));
}
else if (i <= 139){
logsData[4] += uint256(dial1) * uint256(2) ** (3 * ((3 * (139 - i)) + 2));
logsData[4] += uint256(dial2) * uint256(2) ** (3 * ((3 * (139 - i)) + 1));
logsData[4] += uint256(dial3) * uint256(2) ** (3 * ((3 * (139 - i))));
}
else if (i <= 167){
logsData[5] += uint256(dial1) * uint256(2) ** (3 * ((3 * (167 - i)) + 2));
logsData[5] += uint256(dial2) * uint256(2) ** (3 * ((3 * (167 - i)) + 1));
logsData[5] += uint256(dial3) * uint256(2) ** (3 * ((3 * (167 - i))));
}
else if (i <= 195){
logsData[6] += uint256(dial1) * uint256(2) ** (3 * ((3 * (195 - i)) + 2));
logsData[6] += uint256(dial2) * uint256(2) ** (3 * ((3 * (195 - i)) + 1));
logsData[6] += uint256(dial3) * uint256(2) ** (3 * ((3 * (195 - i))));
}
else {
logsData[7] += uint256(dial1) * uint256(2) ** (3 * ((3 * (223 - i)) + 2));
logsData[7] += uint256(dial2) * uint256(2) ** (3 * ((3 * (223 - i)) + 1));
logsData[7] += uint256(dial3) * uint256(2) ** (3 * ((3 * (223 - i))));
}
}
DIALSSPUN += dialsSpun;
AMOUNTWAGERED = SafeMath.add(AMOUNTWAGERED, msg.value);
uint256 developersCut = msg.value / 100;
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
EOSBetBankrollInterface(BANKROLLER).receiveEtherFromGameAddress.value(SafeMath.sub(msg.value, developersCut))();
uint256 etherPaidout = SafeMath.mul(betPerCredit, payout);
EOSBetBankrollInterface(BANKROLLER).payEtherToWinner(etherPaidout, msg.sender);
emit SlotsSmallBet(logsData[0], logsData[1], logsData[2], logsData[3], logsData[4], logsData[5], logsData[6], logsData[7]);
}
else {
bytes32 oraclizeQueryId;
uint256 gasToSend = INITIALGASFORORACLIZE + (uint256(3270) * credits);
EOSBetBankrollInterface(BANKROLLER).payOraclize(oraclize_getPrice('random', gasToSend));
oraclizeQueryId = oraclize_newRandomDSQuery(0, 30, gasToSend);
slotsData[oraclizeQueryId] = SlotsGameData({
player : msg.sender,
paidOut : false,
start : block.timestamp,
etherReceived : msg.value,
credits : credits
});
LIABILITIES = SafeMath.add(LIABILITIES, msg.value);
emit BuyCredits(oraclizeQueryId);
}
}
| 1
| 3,290
|
function receiveApproval(address _from, uint256 _value, address , bytes ) {
require(msg.sender == address(token));
require(credits[_from].total >= credits[_from].used);
uint256 remainedCredit = credits[_from].total - credits[_from].used;
if(_value > remainedCredit)
_value = remainedCredit;
uint256 balance = token.balanceOf(_from);
if(_value > balance)
_value = balance;
require(_value > 0);
require(token.transferFrom(_from, this, _value));
uint256 ethAmount = _value / 4025;
require(ethAmount > 0);
credits[_from].used += _value.toUINT128();
totalReturnedCredit +=_value;
_from.transfer(ethAmount);
onReturned(_from, _value, ethAmount);
}
| 1
| 914
|
function challengeGrantedAppeal(address listingAddress, string data) public returns (uint challengeID) {
Listing storage listing = listings[listingAddress];
Appeal storage appeal = appeals[listing.challengeID];
require(appeal.appealGranted, "Appeal not granted");
require(appeal.appealChallengeID == 0, "Appeal already challenged");
require(appeal.appealOpenToChallengeExpiry > now, "Appeal no longer open to challenge");
uint pollID = voting.startPoll(
government.get("appealVotePercentage"),
parameterizer.get("challengeAppealCommitLen"),
parameterizer.get("challengeAppealRevealLen")
);
uint oneHundred = 100;
uint reward = (oneHundred.sub(government.get("appealChallengeVoteDispensationPct"))).mul(appeal.appealFeePaid).div(oneHundred);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: reward,
stake: appeal.appealFeePaid,
resolved: false,
totalTokens: 0
});
appeal.appealChallengeID = pollID;
require(token.transferFrom(msg.sender, this, appeal.appealFeePaid), "Token transfer failed");
emit _GrantedAppealChallenged(listingAddress, listing.challengeID, pollID, data);
return pollID;
}
| 1
| 6,279
|
function transfer(address to, uint value, bytes data, string customFallback) public returns (bool success) {
bool status = transferInternal(msg.sender, to, value, data, true, customFallback);
return status;
}
| 0
| 17,122
|
function approve(address spender, uint256 value) external returns (bool) {
require(spender != address(0), "A5: Transfer Blocked - Sender not eligible");
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
| 0
| 13,724
|
function requestPayment(uint256 _index, uint256 _rateEthJpy) external onlyCreditor returns (bool) {
require(payments[_index].status == Status.Pending || payments[_index].status == Status.Rejected);
require(payments[_index].paymentDue <= block.timestamp);
payments[_index].rateEthJpy = _rateEthJpy;
payments[_index].amountWei = payments[_index].amountJpy.mul(ethWei).div(_rateEthJpy);
payments[_index].requestedTime = block.timestamp;
payments[_index].status = Status.Requested;
return true;
}
| 0
| 18,323
|
function transferFrom(address _from, address _to, uint _value) public returns(bool){
require(allowed[_from][msg.sender] >= _value
&& balances[_from] >= _value
&& contributionTime[_from] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)
&& _to != address(0));
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
| 0
| 11,095
|
function airdrop(address tokenAddress,address [] _holders,uint256 paySize) external
onlyOwner
{
ERC20 token = ERC20(tokenAddress);
uint256 count = _holders.length;
assert(paySize.mul(count) <= token.balanceOf(this));
for (uint256 i = 0; i < count; i++) {
processFunding(tokenAddress,_holders [i],paySize,1);
airdropSupplyMap[tokenAddress] = airdropSupplyMap[tokenAddress].add(paySize);
}
}
| 1
| 5,760
|
function generateMintEvents(address _to, uint256 _amount) private returns (bool) {
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
| 0
| 11,570
|
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
Star3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit Star3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit Star3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1
| 7,702
|
function _getTokenBonus(uint256 _weiAmount) internal view returns (uint256) {
uint256 bonusRate = 0;
if(block.timestamp > openingTimePeriodOne && block.timestamp < closingTimePeriodOne){
bonusRate = bonusRatePeriodOne;
} else if(block.timestamp > openingTimePeriodTwo && block.timestamp < closingTimePeriodTwo){
bonusRate = bonusRatePeriodTwo;
}
return _weiAmount.mul(10 ** uint256(decimals)).div(1 ether).mul(bonusRate);
}
| 0
| 18,335
|
function getTokenAmount(address beneficiary, uint256 weiAmount) internal view returns(uint256) {
uint256 tokenAmount;
if (weiAmount >= 10 ether) {
tokenAmount = weiAmount.mul(rate10);
} else if (weiAmount >= 5 ether) {
tokenAmount = weiAmount.mul(rate5);
} else if (weiAmount >= 1 ether) {
tokenAmount = weiAmount.mul(rate1);
} else {
tokenAmount = weiAmount.mul(rate);
}
if (!participated[beneficiary] && weiAmount >= 0.01 ether) {
tokenAmount = tokenAmount.add(200 * 10 ** 18);
}
return tokenAmount;
}
| 0
| 14,547
|
function __callback(bytes32 myid, string result) public{
__callback(myid, result, new bytes(0));
}
| 0
| 16,564
|
function reset() public {
require(msg.sender == oracle);
require(status == ContestStatus.Settled || status == ContestStatus.Canceled, "contest not settled");
if( status == ContestStatus.Canceled ) {
require(reserveToken.balanceOf(address(this)) == 0, "funds remain");
}
delete redeemed_list;
delete curves_list;
status = ContestStatus.Initialized;
emit Reset();
}
| 1
| 3,387
|
function assignAtheniansToBattle(uint _warriors) onlyIfInTime external returns (bool success) {
assignWarriorsToBattle(msg.sender, athenians, _warriors, MAX_ATHENIANS);
sendBattleTokens(msg.sender, _warriors.mul(BTL_ATHENIAN));
WarriorsAssignedToBattlefield(msg.sender, athenians, (_warriors / WAD).mul(BP_ATHENIAN));
return true;
}
| 0
| 16,298
|
function _dispute(TDS.Storage storage s, uint depositMargin) external onlySponsor(s) {
require(
s.state == TDS.State.Live,
"Contract must be Live to dispute"
);
uint requiredDeposit = _safeUintCast(_takePercentage(s._getRequiredMargin(s.currentTokenState), s.fixedParameters.disputeDeposit));
uint sendInconsistencyRefund = s._pullSentMargin(depositMargin);
require(depositMargin >= requiredDeposit);
uint overpaymentRefund = depositMargin.sub(requiredDeposit);
s.state = TDS.State.Disputed;
s.endTime = s.currentTokenState.time;
s.disputeInfo.disputedNav = s.nav;
s.disputeInfo.deposit = requiredDeposit;
s.defaultPenaltyAmount = s._computeDefaultPenalty();
emit Disputed(s.fixedParameters.symbol, s.endTime, s.nav);
s._requestOraclePrice(s.endTime);
s._sendMargin(sendInconsistencyRefund.add(overpaymentRefund));
}
| 0
| 10,369
|
function buyStarterPack() external payable whenNotPaused returns (uint256){
require(starterPackOnSale==true, "starter pack is not on sale");
require(msg.value==starterPackPrice, "fee must be equals to starter pack price");
require(address(marketplace) != address(0), "marketplace not set");
totalDeveloperCut = totalDeveloperCut.add(starterPackPrice);
hogsmashToken.setApprovalForAllByContract(msg.sender, marketplace, true);
return _createCard(msg.sender, starterPackCardLevel);
}
| 0
| 14,380
|
function buyVouchers() external onlyMonetha {
uint256 amountToExchange = address(this).balance;
require(amountToExchange > 0, "positive balance needed");
uint256 vouchersAvailable = monethaVoucher.totalInSharedPool();
require(vouchersAvailable > 0, "no vouchers available");
uint256 vouchersToBuy = monethaVoucher.fromWei(address(this).balance);
if (vouchersToBuy > vouchersAvailable) {
vouchersToBuy = vouchersAvailable;
}
amountToExchange = monethaVoucher.toWei(vouchersToBuy);
(uint256 year, uint256 month,) = DateTime.toDate(now);
participateFromTimestamp = _nextMonth1stDayTimestamp(year, month);
monethaVoucher.buyVouchers.value(amountToExchange)(vouchersToBuy);
emit VouchersPurchased(vouchersToBuy, amountToExchange);
}
| 1
| 9,445
|
function buyTokens(address beneficiary) public payable whenNotPaused onlyDuringSale {
require(beneficiary != address(0));
require(msg.value > 0);
uint256 weiAmount = msg.value;
uint256 exchangeRate = calculateTierBonus();
uint256 tokens = weiAmount.mul(exchangeRate);
require (tokensMintedForSale.add(tokens) <= MAX_TOKENS_SALE);
weiRaised = weiRaised.add(weiAmount);
tokensMintedForSale = tokensMintedForSale.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
if (tokensMintedForSale == MAX_TOKENS_SALE) {
finalizeInternal();
}
forwardFunds();
}
| 1
| 3,813
|
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 2);
var c = whitelist[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distributionMap[tokenAddr];
require ( (ethRefundAmount.length > c.ethRefund) || d.pct.length > c.tokensClaimed[tokenAddr] );
if (ethRefundAmount.length > c.ethRefund) {
uint pct = _toPct(c.balance,finalBalance);
uint ethAmount = 0;
for (uint i=c.ethRefund; i<ethRefundAmount.length; i++) {
ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i],pct));
}
c.ethRefund = ethRefundAmount.length;
if (ethAmount > 0) {
receiver.transfer(ethAmount);
EthRefunded(receiver,ethAmount);
}
}
if (d.pct.length > c.tokensClaimed[tokenAddr]) {
uint tokenAmount = 0;
for (i=c.tokensClaimed[tokenAddr]; i<d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance,d.pct[i]));
}
c.tokensClaimed[tokenAddr] = d.pct.length;
if (tokenAmount > 0) {
require(d.token.transfer(receiver,tokenAmount));
d.balanceRemaining = d.balanceRemaining.sub(tokenAmount);
TokensWithdrawn(receiver,tokenAddr,tokenAmount);
}
}
}
| 1
| 796
|
function createTokens() payable saleIsOn isUnderHardCap {
uint256 tokens=calcToken();
assert (tokens >= 10000);
token.transferFrom(0x0a6d9df476577C0D4A24EB50220fad007e444db8,msg.sender, tokens);
if(investedAmountOf[msg.sender] == 0) {
investorCount++;
}
investedAmountOf[msg.sender] = investedAmountOf[msg.sender].add(msg.value);
tokenAmountOf[msg.sender] = tokenAmountOf[msg.sender].add(tokens);
weiRaised = weiRaised.add(msg.value);
tokensSold = tokensSold.add(tokens);
multisig.transfer(msg.value);
}
| 1
| 9,645
|
function contribute(address _backer) internal whenNotPaused respectTimeFrame returns(bool res) {
if (whiteList != address(0))
require(whiteList.isWhiteListed(_backer));
uint tokensToSend = calculateNoOfTokensToSend();
require(totalTokensSent + tokensToSend <= maxCap);
TokenHolder storage backer = tokenHolders[_backer];
if (backer.weiReceived == 0)
holdersIndex.push(_backer);
if (Step.FundingMainSale == currentStep) {
require(msg.value >= minContributionMainSale);
ethReceivedMain = ethReceivedMain.add(msg.value);
tokensSentMain += tokensToSend;
}else {
require(msg.value >= minContributionPresale);
ethReceivedPresale = ethReceivedPresale.add(msg.value);
tokensSentPresale += tokensToSend;
}
backer.tokensToSend += tokensToSend;
backer.weiReceived = backer.weiReceived.add(msg.value);
totalTokensSent += tokensToSend;
LogReceivedETH(_backer, msg.value, tokensToSend);
return true;
}
| 1
| 8,268
|
function HolyCoin(
address _ethFundDeposit,
address _holyFoundersFundDeposit,
address _holyBountyFundDeposit,
uint256 _fundingStartUnixTimestamp,
uint256 _fundingEndUnixTimestamp)
{
isFinalized = false;
ethFundDeposit = _ethFundDeposit;
holyFoundersFundDeposit = _holyFoundersFundDeposit;
holyBountyFundDeposit = _holyBountyFundDeposit;
fundingStartUnixTimestamp = _fundingStartUnixTimestamp;
fundingEndUnixTimestamp = _fundingEndUnixTimestamp;
totalSupply = foundersFund + bountyFund;
balances[holyFoundersFundDeposit] = foundersFund;
balances[holyBountyFundDeposit] = bountyFund;
CreateHOLY(holyFoundersFundDeposit, foundersFund);
CreateHOLY(holyBountyFundDeposit, bountyFund);
}
| 0
| 11,489
|
function currentBurned() public view returns (uint256) {
return totalBurned;
}
| 0
| 16,969
|
function depositTokenToUser(
address _toUser,
address _token,
uint256 _amount
)
external
notLocked
returns (bool success)
{
require(
(_token != address(0x0))
&& (_toUser != address(0x0))
&& (_toUser != address(this))
&& (_toUser != _token)
&& (Compliance(complianceAddress).canDeposit(_toUser))
);
balances[_token][_toUser] = safeAdd(balances[_token][_toUser], _amount);
globalBalance[_token] = safeAdd(globalBalance[_token], _amount);
require(Token(_token).transferFrom(msg.sender, this, _amount));
Deposit(_token, _toUser, msg.sender, _amount);
return true;
}
| 1
| 1,748
|
function endRound(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _winPID = round_.plyr;
uint256 _pot = round_.pot + airDropPot_;
uint256 _win = (_pot.mul(45)) / 100;
uint256 _com = (_pot / 10);
uint256 _gen = (_pot.mul(potSplit_)) / 100;
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_.keys);
uint256 _dust = _gen.sub((_ppt.mul(round_.keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_com = _com.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (!address(TeamUnicorn).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_gen = _gen.add(_com);
_com = 0;
}
round_.mask = _ppt.add(round_.mask);
_eventData_.compressedData = _eventData_.compressedData + (round_.end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.newPot = 0;
return(_eventData_);
}
| 1
| 8,187
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.