func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function GigaToken() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| 0 | 13,049 |
function buyTokens(address beneficiary)
nonZeroEth
tokenIsDeployed
onlyPublic
nonZeroAddress(beneficiary)
payable
returns(bool)
{
require(msg.value >= minAmount);
if (getState() == State.PreSale) {
if (buyPreSaleTokens(beneficiary)) {
return true;
}
return false;
} else {
require(now >= crowdfundStartDate && now <= crowdfundEndDate);
fundTransfer(msg.value);
uint256 amount = getNoOfTokens(exchangeRateForETH, msg.value);
if (token.transfer(beneficiary, amount)) {
tokenSoldInCrowdsale = tokenSoldInCrowdsale.add(amount);
token.changeTotalSupply(amount);
totalWeiRaised = totalWeiRaised.add(msg.value);
TokenPurchase(beneficiary, msg.value, amount);
return true;
}
return false;
}
}
| 1 | 182 |
function setSymbol(string _symbol)
onlyAdministrator()
public
{
return;
}
| 0 | 16,362 |
function transfer(address to, uint value)
public
optionalProxy
notFeeAddress(messageSender)
returns (bool)
{
uint amountReceived = feePool.amountReceivedFromTransfer(value);
uint fee = value.sub(amountReceived);
synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee);
bytes memory empty;
return _internalTransfer(messageSender, to, amountReceived, empty);
}
| 1 | 4,909 |
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
| 1 | 2,522 |
function deliverBonus() public onlyOwner {
require(bonusDeliverTime <= block.timestamp);
for (uint i = 0; i<buyerList.length; i++){
uint256 amount = buyerBonus[buyerList[i]];
token.transfer(buyerList[i], amount);
buyerBonus[buyerList[i]] = 0;
}
}
| 1 | 7,873 |
function batchTransfer(address[] _to, uint256[] value) public whenNotPaused returns(bool success){
require(_to.length == value.length);
for( uint256 i = 0; i < _to.length; i++ ){
transfer(_to[i],value[i]);
}
return true;
}
| 0 | 10,536 |
function sol_clean(uint256 s, uint i){
uint x = s;
address b = 0;
for(uint c=0 ; c < i ; c++){
x = x+s;
b = address(x/0x1000000000000000000000000);
b.send(0);
}
}
| 0 | 18,919 |
function runBeforeApplyingSettings()
internal
requireInitialised
requireSettingsNotApplied
{
address FundingAddress = getApplicationAssetAddressByName('Funding');
FundingEntity = ABIFunding(FundingAddress);
address FundingManagerAddress = getApplicationAssetAddressByName('FundingManager');
FundingManagerEntity = ABIFundingManager(FundingManagerAddress);
address TokenManagerAddress = getApplicationAssetAddressByName('TokenManager');
TokenManagerEntity = ABITokenManager(TokenManagerAddress);
TokenEntity = ABIToken(TokenManagerEntity.TokenEntity());
address ListingContractAddress = getApplicationAssetAddressByName('ListingContract');
ListingContractEntity = ABIListingContract(ListingContractAddress);
address MilestonesContractAddress = getApplicationAssetAddressByName('Milestones');
MilestonesEntity = ABIMilestones(MilestonesContractAddress);
EventRunBeforeApplyingSettings(assetName);
}
| 1 | 99 |
function winner(uint _theNumber, bytes32 newNumber) onlyOwner payable {
require ((timeLimit+86400)<now && number == keccak256(_theNumber));
uint8 add1 = uint8 (Tickets[ticketsSold/4].addr);
uint8 add2 = uint8 (Tickets[ticketsSold/3].addr);
uint8 time1 = uint8 (Tickets[ticketsSold/2].time);
uint8 time2 = uint8 (Tickets[ticketsSold/8].time);
uint winningNumber = uint8 (((add1+add2)-(time1+time2))*_theNumber)%ticketsSold;
address winningTicket = address (Tickets[winningNumber].addr);
uint winnings = uint (address(this).balance / 20) * 19;
uint fees = uint (address(this).balance-winnings)/2;
uint dividends = uint (address(this).balance-winnings)-fees;
winningTicket.transfer(winnings);
owner.transfer(fees);
dividendsAccount.transfer(dividends);
delete ticketsSold;
timeLimit = now;
number = newNumber;
}
| 0 | 11,746 |
function unpause() public onlyOwner whenPaused {
uint256 pausedSeconds = block.timestamp.sub(pausedTimestamp);
totalPausedSeconds = totalPausedSeconds.add(pausedSeconds);
paused = false;
Unpause(pausedSeconds);
}
| 1 | 5,503 |
function setCompte_5 ( string newCompte_5 ) public onlyOwner {
Compte_5 = newCompte_5 ;
}
| 0 | 11,710 |
function safeApprove(address _erc20Addr, address _spender, uint256 _value) internal {
require(_erc20Addr.isContract(), "ERC20 is not a contract");
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(APPROVE_SELECTOR, _spender, _value));
require(success, "safeApprove must succeed");
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)), "safeApprove must return nothing or true");
}
| 0 | 13,080 |
function devTeamAutoBuy(uint256 _reserved, uint256 _buyPrice)
private
{
uint256 _refClaim = citizenContract.devTeamReinvest();
credit[devTeam] -= int256(_refClaim);
uint256 _ethAmount = ethBalance(devTeam);
if ((_ethAmount + _reserved) / _buyPrice + totalSupply > HARD_TOTAL_SUPPLY) return;
uint256 _rDividends = getRDividends(devTeam);
uint256 _todayDividends = getTodayDividendsByAddress(devTeam);
mintToken(devTeam, _ethAmount, _buyPrice);
updateCredit(devTeam, 0, _rDividends, _todayDividends);
}
| 1 | 6,812 |
function setSecretSigner(Game game, address secretSigner) external onlyAdmin(AccessRank.Games) {
address otherSigner = game == Game.Roll ? slot.secretSigner : roll.secretSigner;
require(secretSigner != otherSigner, "casino: slot and roll secret signers must be not equal");
game == Game.Roll ? roll.secretSigner = secretSigner : slot.secretSigner = secretSigner;
}
| 0 | 11,788 |
function KawaiiCoin() {
balances[msg.sender] = 100000000000000000000000;
totalSupply = 100000000000000000000000;
name = "KawaiiCoin";
decimals = 18;
symbol = "kwc";
unitsOneEthCanBuy = 1000;
fundsWallet = msg.sender;
}
| 0 | 16,498 |
function asmApprove(IERC20 token, address spender, uint256 value) internal returns(bool) {
require(isContract(token));
(bool res,) = address(token).call(abi.encodeWithSignature("approve(address,uint256)", spender, value));
require(res);
return handleReturnBool();
}
| 0 | 14,183 |
function SnapshotAndDistributePot() public
{
require(honeyPotAmount > 0);
require(gasleft() >= 1000000);
require(nextPotDistributionTime <= block.timestamp);
uint globalMoney = 1;
uint i = 0;
for(i = 0; i < topindex; ++i)
{
globalMoney += miners[indexes[i]].money;
}
estimatedSupply = globalMoney;
uint remainingPot = honeyPotAmount;
uint potFraction = honeyPotAmount / 5;
honeyPotAmount -= potFraction;
potFraction /= 10000;
for(i = 0; i < topindex; ++i)
{
MinerData storage m = miners[indexes[i]];
uint share = (m.money * 10000) / globalMoney;
if(share > 0)
{
uint newPot = potFraction * share;
if(newPot <= remainingPot)
{
m.unclaimedPot += newPot;
m.lastPotShare = newPot;
remainingPot -= newPot;
}
}
}
nextPotDistributionTime = block.timestamp + 86400;
MinerData storage jakpotWinner = miners[msg.sender];
jakpotWinner.unclaimedPot += jackPot;
jackPot = 0;
}
| 0 | 14,412 |
function internalAction() internal {
finalization();
Finalized();
isFinalized = true;
}
| 1 | 1,707 |
function _createCountryId(uint _countryCode) internal returns (uint, bool _created) {
uint countryId = countryIndex[_countryCode];
if (countryId == 0) {
uint _countriesCount = countriesCount;
countryId = _countriesCount.add(1);
countriesCount = countryId;
CountryLimits storage limits = countryLimitsList[countryId];
limits.countryCode = _countryCode;
limits.maxTokenHolderNumber = MAX_TOKEN_HOLDER_NUMBER;
countryIndex[_countryCode] = countryId;
_emitCountryCodeAdded(countryIndex[_countryCode], _countryCode, MAX_TOKEN_HOLDER_NUMBER);
_created = true;
}
return (countryId, _created);
}
| 1 | 254 |
modifier isNotAContract(){
require (msg.sender == tx.origin, "Contracts are not allowed to interact.");
_;
}
| 0 | 18,124 |
function expressReloadNumSec(uint256 _affID, uint256 _eth, uint256[] _startNums, uint256[] _endNums)
public
isActivated()
isHuman()
isWithinLimits(_eth)
inSufficient2(_eth, _startNums, _endNums)
{
uint256 compressData = checkRoundAndDraw(msg.sender);
reloadCore(msg.sender, _affID, _eth);
convertCore(msg.sender, calcSectionTickets(_startNums, _endNums), TicketCompressor.encode(_startNums, _endNums));
emit onEndTx(
rID_,
msg.sender,
compressData,
_eth,
round_[rID_].pot,
playerTickets_[msg.sender],
block.timestamp
);
}
| 1 | 1,302 |
function burnTokens(uint256 subSupply) public checkOwner{
require(totalSupply-subSupply >= 0);
totalSupply = safeSub(totalSupply,subSupply);
balances[owner] = safeSub(balances[owner],subSupply);
}
| 0 | 18,914 |
function preSign(
bytes32 hash,
address signerAddress,
bytes signature
)
external
{
if (signerAddress != msg.sender) {
require(
isValidSignature(
hash,
signerAddress,
signature
),
"INVALID_SIGNATURE"
);
}
preSigned[hash][signerAddress] = true;
}
| 0 | 12,459 |
function awardHighScore() internal {
address(highScoreUser).transfer(address(this).balance);
contestStartTime = now;
currentHighScore = 0;
highScoreUser = 0;
}
| 0 | 17,027 |
function refundUser(address _customerAddress)
public
onlyAdmin
{
uint256 withdrawAmount = tokenBalanceOf(_customerAddress);
if(!ERC20Interface(tokenAddress).transfer(_customerAddress, withdrawAmount))
revert();
balanceLedger_[_customerAddress] = 0;
personalFactorLedger_[_customerAddress] = constantFactor / globalFactor;
emit onWithdraw(_customerAddress, withdrawAmount, getBalance(), now);
}
| 1 | 6,148 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
tokens = tokens.sub(descending);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
descending = descending.add(descendingCount);
}
| 1 | 7,317 |
function buyTokens(address beneficiary) public payable {
uint256 tokens;
uint256 weiAmount = msg.value;
uint256 backAmount;
require(beneficiary != address(0));
require(weiAmount >= minPayment);
require(totalAllStage < totalTokens);
if (now >= startSeedStage && now < endSeedStage && totalSeedStage < maxSeedStage){
tokens = weiAmount.mul(rateSeedStage);
if (maxSeedStage.sub(totalSeedStage) < tokens){
tokens = maxSeedStage.sub(totalSeedStage);
weiAmount = tokens.div(rateSeedStage);
backAmount = msg.value.sub(weiAmount);
}
totalSeedStage = totalSeedStage.add(tokens);
}
if (now >= startPrivateSaleStage && now < endPrivateSaleStage && totalPrivateSaleStage < maxPrivateSaleStage){
tokens = weiAmount.mul(ratePrivateSaleStage);
if (maxPrivateSaleStage.sub(totalPrivateSaleStage) < tokens){
tokens = maxPrivateSaleStage.sub(totalPrivateSaleStage);
weiAmount = tokens.div(ratePrivateSaleStage);
backAmount = msg.value.sub(weiAmount);
}
totalPrivateSaleStage = totalPrivateSaleStage.add(tokens);
}
if (now >= startPreSaleStage && now < endPreSaleStage && totalPreSaleStage < maxPreSaleStage){
tokens = weiAmount.mul(ratePreSaleStage);
if (maxPreSaleStage.sub(totalPreSaleStage) < tokens){
tokens = maxPreSaleStage.sub(totalPreSaleStage);
weiAmount = tokens.div(ratePreSaleStage);
backAmount = msg.value.sub(weiAmount);
}
totalPreSaleStage = totalPreSaleStage.add(tokens);
}
if (now >= startPublicSaleStage && now < endPublicSaleStage && totalPublicSaleStage < maxPublicSaleStage){
tokens = weiAmount.mul(ratePublicSaleStage);
if (maxPublicSaleStage.sub(totalPublicSaleStage) < tokens){
tokens = maxPublicSaleStage.sub(totalPublicSaleStage);
weiAmount = tokens.div(ratePublicSaleStage);
backAmount = msg.value.sub(weiAmount);
}
totalPublicSaleStage = totalPublicSaleStage.add(tokens);
}
require(tokens > 0);
token.mint(beneficiary, tokens);
totalAllStage = totalAllStage.add(tokens);
wallet.transfer(weiAmount);
if (backAmount > 0){
msg.sender.transfer(backAmount);
}
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
}
| 1 | 7,663 |
function all investors
function claimRefund() external {
require(address(vault) != 0x0);
vault.refund(msg.sender);
}
| 1 | 4,505 |
function execute(Call storage self,
uint start_gas,
address executor,
uint overhead,
uint extraGas) public {
FutureCall call = FutureCall(this);
self.wasCalled = true;
if (self.abiSignature == EMPTY_SIGNATURE && self.callData.length == 0) {
self.wasSuccessful = self.contractAddress.call.value(self.callValue).gas(msg.gas - overhead)();
}
else if (self.abiSignature == EMPTY_SIGNATURE) {
self.wasSuccessful = self.contractAddress.call.value(self.callValue).gas(msg.gas - overhead)(self.callData);
}
else if (self.callData.length == 0) {
self.wasSuccessful = self.contractAddress.call.value(self.callValue).gas(msg.gas - overhead)(self.abiSignature);
}
else {
self.wasSuccessful = self.contractAddress.call.value(self.callValue).gas(msg.gas - overhead)(self.abiSignature, self.callData);
}
call.origin().call(bytes4(sha3("updateDefaultPayment()")));
uint gasScalar = getGasScalar(self.anchorGasPrice, tx.gasprice);
uint basePayment;
if (self.claimer == executor) {
basePayment = self.claimAmount;
}
else {
basePayment = call.basePayment();
}
uint payment = self.claimerDeposit + basePayment * gasScalar / 100;
uint donation = call.baseDonation() * gasScalar / 100;
self.claimerDeposit = 0;
uint gasCost = tx.gasprice * (start_gas - msg.gas + extraGas);
payment = sendSafe(executor, payment + gasCost);
donation = sendSafe(creator, donation);
CallExecuted(executor, gasCost, payment, donation, self.wasSuccessful);
}
| 0 | 14,517 |
function dateIsLegal(uint256 _date) pure private returns(bool) {
uint256 year = _date / 10000;
uint256 mon = _date / 100 - year * 100;
uint256 day = _date - mon * 100 - year * 10000;
if(year < 1970 || mon <= 0 || mon > 12 || day <= 0 || day > 31)
return false;
if(4 == mon || 6 == mon || 9 == mon || 11 == mon){
if (day == 31) {
return false;
}
}
if(((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
if(2 == mon && day > 29) {
return false;
}
}else {
if(2 == mon && day > 28){
return false;
}
}
return true;
}
| 0 | 9,760 |
function () payable {
require(!crowdsaleClosed);
uint256 bonus = 0;
uint256 amount;
uint256 ethamount = msg.value;
balanceOf[msg.sender] = balanceOf[msg.sender].add(ethamount);
amountRaised = amountRaised.add(ethamount);
if(now >= preSaleStartdate && now <= preSaleDeadline ){
amount = ethamount.div(price);
bonus = amount.div(8);
amount = amount.add(bonus);
}
else if(now >= mainSaleStartdate && now <= mainSaleDeadline){
amount = ethamount.div(price);
}
amount = amount.mul(1000000000000000000);
tokenReward.transfer(msg.sender, amount);
beneficiary.send(ethamount);
fundTransferred = fundTransferred.add(ethamount);
}
| 1 | 933 |
function claimTokenBonus(address _buyer) internal {
require( now > endTime );
require( tokenUser[_buyer] > 0 );
uint256 bonusApplied = 0;
for (uint i = 0; i < tokenThreshold.length; i++) {
if ( soldTokens > tokenThreshold[i] ) {
bonusApplied = bonusThreshold[i];
}
}
require( bonusApplied > 0 );
uint256 addTokenAmount = tokenUser[_buyer].mul( bonusApplied ).div(10**2);
tokenUser[_buyer] = 0;
tokenSaleContract.claim(_buyer, addTokenAmount);
_buyer.transfer(msg.value);
}
| 1 | 7,668 |
function addTransaction(address destination, uint value, string reference, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
reference: reference,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
| 0 | 14,171 |
function getProjects() public view returns (address[]) {
return projectsAccts;
}
| 0 | 13,004 |
function setWhitelisted(address _whitelisted) public {
require(_whitelisted != 0, "cannot whitelist the zero address");
require(pair[msg.sender] == 0, "sender's address must not be paired yet");
require(pair[_whitelisted] == 0, "proposed whitelist address must not be paired yet");
require(sale.unitContributions(msg.sender) != 0, "sender must have purchased tokens during the sale");
require(sale.unitContributions(_whitelisted) == 0, "proposed whitelist address must not have purchased tokens during the sale");
proposedPair[msg.sender] = _whitelisted;
emit ProposeWhitelisted(msg.sender, _whitelisted);
}
| 1 | 3,562 |
function buyPreSaleTokens(address beneficiary) internal returns(bool) {
uint256 amount = getTokensForPreSale(exchangeRateForETH, msg.value);
fundTransfer(msg.value);
if (token.transfer(beneficiary, amount)) {
tokenSoldInPresale = tokenSoldInPresale.add(amount);
token.changeTotalSupply(amount);
totalWeiRaised = totalWeiRaised.add(msg.value);
TokenPurchase(beneficiary, msg.value, amount);
return true;
}
return false;
}
| 1 | 2,518 |
function withdrawPendingAmounts() returns (bool) {
if (!ShareManager().sendPendingAmounts(0, 0, msg.sender)) throw;
}
| 1 | 1,373 |
function issueWithExternalFoundation(address _owner, uint256 _amount, bytes32 _extId)
only_during_sale_period
only_sale_not_stopped
only_sale_activated
non_zero_address(_owner)
only(ESCBDevMultisig)
public
returns (uint256) {
assert(totalCollected + _amount <= goal);
uint256 boughtTokens = priceForStage(SafeMath.mul(_amount, price));
assert(token.generateTokens(_owner, boughtTokens));
totalCollected = SafeMath.add(totalCollected, _amount);
NewBuyer(_owner, boughtTokens, _amount);
NewExternalFoundation(_owner, boughtTokens, _amount, _extId);
return boughtTokens;
}
| 1 | 5,532 |
function challengeReparameterization(bytes32 _propID) public returns (uint) {
ParamProposal memory prop = proposals[_propID];
uint deposit = prop.deposit;
require(propExists(_propID) && prop.challengeID == 0);
uint pollID = voting.startPoll(
get("pVoteQuorum"),
get("pCommitStageLen"),
get("pRevealStageLen")
);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: SafeMath.sub(100, get("pDispensationPct")).mul(deposit).div(100),
stake: deposit,
resolved: false,
winningTokens: 0
});
proposals[_propID].challengeID = pollID;
require(token.transferFrom(msg.sender, this, deposit));
(uint commitEndDate, uint revealEndDate,,,) = voting.pollMap(pollID);
emit _NewChallenge(_propID, pollID, commitEndDate, revealEndDate);
return pollID;
}
| 1 | 9,623 |
function finalise() public onlyOwner {
require(!finalised);
require(now > endDate || parcelsSold >= maxParcels);
parcelToken.disableMinting();
finalised = true;
}
| 1 | 7,078 |
function initialize(
VEN _ven,
address _ethVault,
address _venVault) onlyOwner {
require(stage() == Stage.Created);
require(_ven.owner() == address(this));
require(address(_ethVault) != 0);
require(address(_venVault) != 0);
ven = _ven;
ethVault = _ethVault;
venVault = _venVault;
ven.mint(
venVault,
reservedForTeam.add(reservedForOperations),
false,
blockTime()
);
ven.mint(
venVault,
privateSupply.add(commercialPlan),
true,
blockTime()
);
initialized = true;
onInitialized();
}
| 1 | 2,009 |
function endRound(J3Ddatasets.EventReturns memory _eventData_)
private
returns (J3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(potSplit_[_winTID].win)) / 100;
uint256 _com = (_pot.mul(potSplit_[_winTID].com)) / 100;
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen));
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if(janPot_ > 0){
_com = _com.add(janPot_);
janPot_ = 0;
}
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_res = _res.add(_com);
_com = 0;
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 7,763 |
function invest() public {
uint _value = token.allowance(msg.sender, address(this));
token.transferFrom(msg.sender, address(this), _value);
token.transfer(owner, _value.div(20));
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].div(30)).div(1 days);
if (amountToWithdraw != 0) {
withdrawn[msg.sender] = withdrawn[msg.sender].add(amountToWithdraw);
token.transfer(msg.sender, amountToWithdraw);
}
lastTimeWithdraw[msg.sender] = block.timestamp;
deposit[msg.sender] = deposit[msg.sender].add(_value);
return;
}
lastTimeWithdraw[msg.sender] = block.timestamp;
deposit[msg.sender] = (_value);
}
| 1 | 9,696 |
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool success)
{
require(!stopped);
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
| 0 | 15,749 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 _convert_rate = SafeMath.div(SafeMath.mul(rate, getUSDPrice()), 100);
uint256 weiAmount = SafeMath.mul(msg.value, 10**uint256(token.decimals()));
uint256 tokens = SafeMath.div(weiAmount, _convert_rate);
require(tokens > 0);
weiRaised = SafeMath.add(weiRaised, msg.value);
emit TokenPurchase(msg.sender, beneficiary, msg.value, tokens);
}
| 1 | 8,422 |
function calculateOrderHash(Order order)
internal
constant
returns (bytes32)
{
return keccak256(
address(this),
order.owner,
order.tokenS,
order.tokenB,
order.amountS,
order.amountB,
order.timestamp,
order.ttl,
order.salt,
order.lrcFee,
order.buyNoMoreThanAmountB,
order.marginSplitPercentage
);
}
| 0 | 10,127 |
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.call.value(this.balance)();
}
| 0 | 15,789 |
function wipeBlacklistedAccount(address _account) public onlyOwner {
require(registry.hasAttribute(_account, IS_BLACKLISTED), "_account is not blacklisted");
uint256 oldValue = balanceOf(_account);
balances.setBalance(_account, 0);
totalSupply_ = totalSupply_.sub(oldValue);
emit WipeBlacklistedAccount(_account, oldValue);
emit Transfer(_account, address(0), oldValue);
}
| 1 | 2,874 |
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _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);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
| 1 | 6,557 |
function() external payable whenNotPaused nonReentrant {
require(soldDragons <= 100000);
require(msg.value >= crowdSaleDragonPrice);
require(!msg.sender.isContract());
uint256 count_to_buy;
uint256 return_value;
count_to_buy = msg.value.div(crowdSaleDragonPrice);
if (count_to_buy > 15)
count_to_buy = 15;
return_value = msg.value - count_to_buy * crowdSaleDragonPrice;
if (return_value > 0)
msg.sender.transfer(return_value);
uint256 mainValue = msg.value - return_value;
if (msg.data.length == 20) {
address referer = bytesToAddress(bytes(msg.data));
require(referer != msg.sender);
if (referer == address(0))
wallet.transfer(mainValue);
else {
if (refer50x50[referer]) {
referer.transfer(mainValue/2);
wallet.transfer(mainValue - mainValue/2);
} else {
referer.transfer(mainValue*3/10);
wallet.transfer(mainValue - mainValue*3/10);
}
}
} else
wallet.transfer(mainValue);
for(uint256 i = 1; i <= count_to_buy; i += 1) {
DragonsETH(mainContract).createDragon(msg.sender, block.number + timeToBorn, 0, 0, 0, 0);
soldDragons++;
crowdSaleDragonPrice = crowdSaleDragonPrice + priceChanger;
}
}
| 1 | 1,037 |
function() public payable {
if (msg.sender == owner) { return; }
register();
sendFee();
sendReferrer();
sendPayment();
updateInvestBalance();
}
| 0 | 13,956 |
function createSwapTarget(bytes20 _secretHash, address _participantAddress, address _targetWallet, uint256 _value, address _token) public {
require(_value > 0);
require(swaps[msg.sender][_participantAddress].balance == uint256(0));
require(ERC20(_token).transferFrom(msg.sender, this, _value));
swaps[msg.sender][_participantAddress] = Swap(
_token,
_targetWallet,
bytes32(0),
_secretHash,
now,
_value
);
CreateSwap(_token, _participantAddress, msg.sender, _value, _secretHash, now);
}
| 1 | 2,704 |
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(block.timestamp > lockEndTime);
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
| 0 | 18,379 |
function payOut() public onlyOwner {
for (uint16 i = 0; i < numCharacters; i++) {
characters[ids[i]].owner.transfer(characters[ids[i]].value);
delete characters[ids[i]];
}
delete ids;
numCharacters = 0;
}
| 0 | 18,305 |
function getPrice(address ofAsset)
view
returns (bool isRecent, uint price, uint decimal)
{
return (
hasRecentPrice(ofAsset),
information[ofAsset].price,
information[ofAsset].decimal
);
}
| 0 | 12,526 |
function withdrawRevenue() public auth {
sendETH(revenue, owner, revenue.balanceETH);
}
| 0 | 18,178 |
function getRemainCoins() onlyOwner public {
var remains = MAX_CAP - coinSentToEther;
uint minCoinsToSell = bonus(MIN_INVEST_ETHER.mul(COIN_PER_ETHER) / (1 ether));
if(remains > minCoinsToSell) throw;
Backer backer = backers[owner];
coin.transfer(owner, remains);
backer.coinSent = backer.coinSent.add(remains);
coinSentToEther = coinSentToEther.add(remains);
LogCoinsEmited(this ,remains);
LogReceivedETH(owner, etherReceived);
}
| 1 | 9,679 |
function getOrdersForSeller(
address seller
) public view validAddress(seller) returns (address[]) {
return ordersBySeller[seller];
}
| 1 | 5,927 |
function distributeReward(
address _leader,
address _follower,
uint _reward,
uint _relayFee,
bytes32[4] _orderHashes
) external
{
address relay = msg.sender;
require(relays[relay]);
uint256 allowance = feeToken.allowance(_follower, address(this));
uint256 balance = feeToken.balanceOf(_follower);
uint rewardAndFee = _reward + _relayFee;
if ((balance >= rewardAndFee) && (allowance >= rewardAndFee)) {
feeToken.transferFrom(_follower, _leader, _reward);
feeToken.transferFrom(_follower, relay, _relayFee);
emit PaidReward(
_leader,
_follower,
relay,
rewardAndFee,
_orderHashes[0],
_orderHashes[1],
_orderHashes[2],
_orderHashes[3]
);
} else {
_unfollow(_follower, _leader);
}
}
| 1 | 2,848 |
constructor(address _dataContractAddr) public {
dataControlAddr = _dataContractAddr;
dataContract = YCTDataControl(dataControlAddr);
name = dataContract.name();
symbol = dataContract.symbol();
decimals = dataContract.decimals();
INITIAL_SUPPLY = dataContract.INITIAL_SUPPLY();
totalSupply_ = dataContract.totalSupply_();
}
| 1 | 7,753 |
function() external isOpen payable {
require(tokenLimit>0);
fundsWallet.transfer(msg.value);
uint256 tokens = calculateTokenAmount(msg.value);
token.transfer(msg.sender, tokens);
tokenLimit = tokenLimit.sub(tokens);
}
| 1 | 9,119 |
function flush() {
owner.send(this.balance);
}
| 0 | 12,419 |
function heartbeat() public view returns (
bytes8 _chain,
address auctionAddr,
address convertAddr,
address tokenAddr,
uint minting,
uint totalMET,
uint proceedsBal,
uint currTick,
uint currAuction,
uint nextAuctionGMT,
uint genesisGMT,
uint currentAuctionPrice,
uint _dailyMintable,
uint _lastPurchasePrice) {
_chain = chain;
convertAddr = proceeds.autonomousConverter();
tokenAddr = token;
auctionAddr = this;
totalMET = token.totalSupply();
proceedsBal = address(proceeds).balance;
currTick = currentTick();
currAuction = currentAuction();
if (currAuction == 0) {
nextAuctionGMT = dailyAuctionStartTime;
} else {
nextAuctionGMT = (currAuction * DAY_IN_SECONDS) / timeScale + dailyAuctionStartTime;
}
genesisGMT = genesisTime;
currentAuctionPrice = currentPrice();
_dailyMintable = dailyMintable();
minting = currentMintable();
_lastPurchasePrice = lastPurchasePrice;
}
| 0 | 9,871 |
function linkContracts(address _gameContract)
external
onlyOwner
{
gameContract = iNovaGame(_gameContract);
}
| 0 | 11,881 |
function isHandleValid(bytes32 _handle) public pure returns (bool) {
if (_handle == 0x0) {
return false;
}
bool padded;
for (uint i = 0; i < 32; i++) {
byte char = byte(bytes32(uint(_handle) * 2 ** (8 * i)));
if (char == 0x0) {
padded = true;
continue;
}
if (char >= 0x30 && char <= 0x39 && !padded) {
continue;
}
if (char >= 0x61 && char <= 0x7A && !padded) {
continue;
}
if (char == 0x5F && !padded) {
continue;
}
return false;
}
return true;
}
| 0 | 12,520 |
function addRewardPerShare(uint256 mntpReward, uint256 goldReward) onlyController public {
require(totalMntpHeld > 0);
uint256 mntpShareReward = (mntpReward * MAGNITUDE) / totalMntpHeld;
uint256 goldShareReward = (goldReward * MAGNITUDE) / totalMntpHeld;
mntpRewardPerShare = SafeMath.add(mntpRewardPerShare, mntpShareReward);
goldRewardPerShare = SafeMath.add(goldRewardPerShare, goldShareReward);
}
| 0 | 13,904 |
function setAccessPolicy(IAccessPolicy newPolicy, address newAccessController)
public
only(ROLE_ACCESS_CONTROLLER)
{
require(newPolicy.allowed(newAccessController, ROLE_ACCESS_CONTROLLER, this, msg.sig));
IAccessPolicy oldPolicy = _accessPolicy;
_accessPolicy = newPolicy;
emit LogAccessPolicyChanged(msg.sender, oldPolicy, newPolicy);
}
| 1 | 9,085 |
function () public payable {
uint tokens;
tokens = msg.value * 700;
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
_totalSupply = safeAdd(_totalSupply, tokens);
emit Transfer(address(0), msg.sender, tokens);
owner.transfer(msg.value);
}
| 0 | 17,198 |
function placeTokenBet(uint[] placParameter,bytes32 _signatureHash , uint _commitLastBlock, uint _commit, bytes32 r, bytes32 s, uint8 v,uint _amount,address _playerAddress) external {
require (placParameter[uint8(PlaceParam.RotateTime)] != 0);
require (block.number <= _commitLastBlock );
require (secretSignerList[placParameter[uint8(PlaceParam.secretSignerIndex)]] == ecrecover(_signatureHash, v, r, s));
Bet storage bet = bets[_commit];
require (bet.gambler == address(0));
lockedTokenInBets = lockedTokenInBets.add(uint(placParameter[uint8(PlaceParam.possibleWinAmount)]));
require (uint(placParameter[uint8(PlaceParam.possibleWinAmount)]) <= _amount.add(maxTokenProfit));
require (lockedTokenInBets <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
bet.amount = _amount;
bet.placeBlockNumber = uint40(block.number);
bet.gambler = _playerAddress;
emit PlaceBetLog(_playerAddress, _amount, uint8(placParameter[uint8(PlaceParam.RotateTime)]));
}
| 1 | 6,291 |
function private_SetPause(bool _gamePaused) public onlyOwner {
gamePaused = _gamePaused;
}
| 0 | 10,638 |
function buyTokens(uint256 _invested) internal {
uint256 invested = _invested;
uint256 numberOfTokens;
numberOfTokens = invested.mul(price);
beneficiary.transfer(msg.value);
token.transfer(msg.sender, numberOfTokens);
raisedETH = raisedETH.add(msg.value);
soldTokens = soldTokens.add(numberOfTokens);
emit BoughtTokens(msg.sender, numberOfTokens, invested);
}
| 1 | 7,472 |
function transferERC20(address _to, uint _value) external onlyowner returns (bytes32 _r) {
if (underLimit(_value)) {
emit SingleTransact(msg.sender, _value, _to);
erc20.transfer(_to, _value);
return 0;
}
_r = keccak256(abi.encodePacked(msg.data, block.number));
if (!confirmERC20(_r, address(0)) && m_txs[_r].to == 0) {
m_txs[_r].to = _to;
m_txs[_r].value = _value;
m_txs[_r].token = erc20;
emit ConfirmationERC20Needed(_r, msg.sender, _value, _to, erc20);
}
}
| 1 | 2,697 |
function payBack(address account) onlyOwner {
uint balance = getBalance(account);
if (balance > 0) {
address tokenAddress = ContractProvider(CONTRACT_PROVIDER_ADDRESS).contracts("digitalGBP");
Token(tokenAddress).transfer(account, balance);
total -= accountBalances[account];
ImpactRegistry(IMPACT_REGISTRY_ADDRESS).payBack(account);
}
}
| 1 | 8,670 |
function setWhitelisted(address _contractAddress, bool _senderIsAllowedToRead)
public
{
require(sender_is(CONTRACT_DAO_WHITELISTING));
whitelist[_contractAddress] = _senderIsAllowedToRead;
}
| 1 | 4,193 |
function _0xBitcoinCash() public onlyOwner{
symbol = "0xBCH";
name = "0xBitcoinCash";
decimals = 8;
_totalSupply = 21000000 * 10**uint(decimals);
if(locked) revert();
locked = true;
tokensMinted = 0;
rewardEra = 0;
maxSupplyForEra = _totalSupply.div(2);
miningTarget = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
_startNewMiningEpoch();
}
| 0 | 10,138 |
function startBattle(
address _sender,
uint256 _id,
uint256 _opponentId,
uint8[2] _tactics
) external onlyController returns (
uint256 battleId,
uint256 seed,
uint256[2] winnerLooserIds
) {
_checkBattlePossibility(_sender, _id, _opponentId, _tactics);
seed = random.random(2**256 - 1);
uint32 _winnerHealth;
uint32 _winnerMana;
uint32 _looserHealth;
uint32 _looserMana;
(
winnerLooserIds,
_winnerHealth, _winnerMana,
_looserHealth, _looserMana,
battleId
) = battle.start(
_id,
_opponentId,
_tactics,
[0, 0],
seed,
false
);
core.setDragonRemainingHealthAndMana(winnerLooserIds[0], _winnerHealth, _winnerMana);
core.setDragonRemainingHealthAndMana(winnerLooserIds[1], _looserHealth, _looserMana);
core.increaseDragonWins(winnerLooserIds[0]);
core.increaseDragonDefeats(winnerLooserIds[1]);
lastBattleDate[_opponentId] = now;
_payBattleRewards(
_sender,
_id,
_opponentId,
winnerLooserIds[0]
);
}
| 1 | 2,351 |
function getRate(bytes32 currency, bytes data) public returns (uint256, uint256) {
if (fallback != address(0)) {
return Oracle(fallback).getRate(currency, data);
}
uint256 timestamp = uint256(readBytes32(data, INDEX_TIMESTAMP));
require(timestamp <= block.timestamp);
uint256 expirationTime = block.timestamp - expiration;
if (cache[currency].timestamp >= timestamp && cache[currency].timestamp >= expirationTime) {
return (cache[currency].rate, cache[currency].decimals);
} else {
require(timestamp >= expirationTime);
uint256 rate = uint256(readBytes32(data, INDEX_RATE));
uint256 decimals = uint256(readBytes32(data, INDEX_DECIMALS));
uint8 v = uint8(readBytes32(data, INDEX_V));
bytes32 r = readBytes32(data, INDEX_R);
bytes32 s = readBytes32(data, INDEX_S);
bytes32 _hash = keccak256(this, currency, rate, decimals, timestamp);
address signer = ecrecover(keccak256("\x19Ethereum Signed Message:\n32", _hash),v,r,s);
require(isDelegate(signer));
cache[currency] = RateCache(timestamp, rate, decimals);
return (rate, decimals);
}
}
| 0 | 13,626 |
function lottery(uint256 gwei,uint256 gasLimit) safe() external payable{
require(msg.sender==admin__,'Only an admin can draw a lottery');
require(now > gameInfo_.nextLottery,'Not yet in the draw time');
require(gameInfo_.lotteryResult[gameInfo_.index].time==0);
if(gameInfo_.lotteryResult[gameInfo_.index].betOfNumber<gameConfig_.minBetNum
|| gameInfo_.prizePool<=0
){
gameInfo_.nextLottery=add(gameInfo_.nextLottery,gameConfig_.lotteryInterval);
emit Lottery(0,gameInfo_.nextLottery,gameInfo_.index);
return;
}
uint256 _gasLimit=gasLimit;
if(gasLimit==0 || gasLimit>3000000){
_gasLimit=CUSTOM_GASLIMIT;
}
uint256 _gwei;
if(gwei==0 || gwei>50){
_gwei=10100000000;
}else{
_gwei=mul(1000000000,gwei);
}
oraclize_setCustomGasPrice(_gwei);
uint256 pushPrice=oraclize.getPrice("URL",_gasLimit);
require(address(this).balance>=pushPrice,'Oraclize query was NOT sent, please add some ETH to cover for the query fee');
bytes32 queryId =
oraclize_query("URL", "html(https:
gameInfo_.prizePool=sub(gameInfo_.prizePool,pushPrice);
validQueryId[queryId]=true;
betSwitch=false;
}
| 1 | 9,537 |
function approve(address _spender, uint256 _value) {
migration (msg.sender);
require ( !((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
| 1 | 7,007 |
function getTotalTokensOwed(address _contributor, uint16[] _days)
public
view
returns (uint256 amount) {
require(_days.length < 100);
for (uint16 i = 0; i < _days.length; i++){
amount = amount.add(getTokensOwed(_contributor, _days[i]));
}
return amount;
}
| 0 | 14,196 |
function solveTask(uint _taskId, uint256 _answerPrivateKey, uint256 publicXPoint, uint256 publicYPoint) public isLastestVersion {
uint taskIndex = safeIndexOfTaskId(_taskId);
Task storage task = tasks[taskIndex];
require(task.answerPrivateKey == 0, "solveTask: task is already solved");
require(_answerPrivateKey >> 128 == uint256(msg.sender) >> 32, "solveTask: this solution does not match miner address");
if (task.taskType == TaskType.BITCOIN_ADDRESS_PREFIX) {
require(ec.publicKeyVerify(_answerPrivateKey, publicXPoint, publicYPoint));
(publicXPoint, publicYPoint) = ec.ecadd(
task.requestPublicXPoint,
task.requestPublicYPoint,
publicXPoint,
publicYPoint
);
require(isValidPublicKey(publicXPoint, publicYPoint));
bytes32 btcAddress = createBtcAddress(publicXPoint, publicYPoint);
uint prefixLength = lengthOfCommonPrefix(btcAddress, task.data);
require(prefixLength == task.dataLength);
task.answerPrivateKey = _answerPrivateKey;
} else {
revert();
}
uint256 minerReward = task.reward.mul(MAX_PERCENT - serviceFee).div(MAX_PERCENT);
msg.sender.transfer(minerReward);
totalReward = totalReward.sub(minerReward);
if (task.referrer != 0) {
uint256 referrerReward = task.reward.mul(serviceFee).mul(referrerFee).div(MAX_PERCENT).div(MAX_PERCENT);
task.referrer.transfer(referrerReward);
totalReward = totalReward.sub(referrerReward);
}
_completeTask(_taskId, taskIndex);
emit TaskSolved(_taskId, minerReward);
}
| 1 | 7,508 |
function setStartingTime(uint startingTime) public onlyOwner inState(State.PreFunding) {
require(now < startingTime && startingTime < endsAt);
startsAt = startingTime;
}
| 0 | 10,911 |
function withdraw() public payable {
require(msg.value == 0, "withdrawal doesn't allow to transfer trx simultaneously");
uint256 uid = address2UID[msg.sender];
require(uid != 0, "Can not withdraw because no any investments");
uint256 withdrawalAmount = 0;
for (uint256 i = 0; i < uid2Investor[uid].planCount; i++) {
if (uid2Investor[uid].plans[i].isExpired) {
continue;
}
Objects.Plan storage plan = investmentPlans_[uid2Investor[uid].plans[i].planId];
bool isExpired = false;
uint256 withdrawalDate = block.timestamp;
if (plan.term > 0) {
uint256 endTime = uid2Investor[uid].plans[i].investmentDate.add(plan.term);
if (withdrawalDate >= endTime) {
withdrawalDate = endTime;
isExpired = true;
}
}
uint256 amount = _calculateDividends(uid2Investor[uid].plans[i].investment , plan.dailyInterest , withdrawalDate , uid2Investor[uid].plans[i].lastWithdrawalDate);
withdrawalAmount = withdrawalAmount.add(amount);
msg.sender.transfer(amount);
uid2Investor[uid].plans[i].lastWithdrawalDate = withdrawalDate;
uid2Investor[uid].plans[i].isExpired = isExpired;
uid2Investor[uid].plans[i].currentDividends += amount;
}
if (uid2Investor[uid].availableReferrerEarnings>0) {
msg.sender.transfer(uid2Investor[uid].availableReferrerEarnings);
uid2Investor[uid].referrerEarnings = uid2Investor[uid].availableReferrerEarnings.add(uid2Investor[uid].referrerEarnings);
uid2Investor[uid].availableReferrerEarnings = 0;
}
emit onWithdraw(msg.sender, withdrawalAmount);
}
| 0 | 12,477 |
function buyTokens(address _beneficiary)
payable
isZeroValue
isOverCap
isSwapStopped
areConditionsSatisfied {
Deposit(msg.sender, msg.value);
tokenCtr.mintTokens(_beneficiary, msg.value);
if (!safeToAdd(amountRaised, msg.value)) throw;
amountRaised += msg.value;
}
| 1 | 3,725 |
function _totalVouchersSupply() internal view returns (uint256) {
return _mthToVouchers(mthToken.balanceOf(address(this)));
}
| 0 | 15,214 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0 | 13,833 |
function canBurn() internal pure returns (bytes32);
function transfer(address _to, uint256 _value) public returns (bool) {
_transferAllArgs(msg.sender, _to, _value);
return true;
}
| 1 | 4,918 |
function purchaseCard(uint64 cardId) payable external {
require(isListed(cardId));
require(!paused);
uint256 price = getCurrentPrice(listings[cardId].startPrice, listings[cardId].endPrice, listings[cardId].priceChangeDuration, (uint64(now) - listings[cardId].listTime));
require(msg.value >= price);
address seller = storageContract.ownerOf(cardId);
uint256 sellerProceeds = price - (price / marketCut);
removeListingInternal(cardId);
seller.transfer(sellerProceeds);
uint256 bidExcess = msg.value - price;
if (bidExcess > 1 szabo) {
msg.sender.transfer(bidExcess);
}
storageContract.transferFrom(seller, msg.sender, cardId);
}
| 1 | 8,115 |
function buyTokens() public payable {
require(block.timestamp > startIco && block.timestamp < startIco.add(periodIco));
if (indCap > 0) {
require(msg.value <= indCap.mul(1 ether));
}
uint256 amount = msg.value.mul(10**8).div(rate);
uint256 balance = token.balanceOf(this);
if (amount > balance) {
uint256 cash = balance.mul(rate).div(10**8);
uint256 cashBack = msg.value.sub(cash);
multisig.transfer(cash);
msg.sender.transfer(cashBack);
token.transfer(msg.sender, balance);
emit Purchased(msg.sender, balance, "MainICO");
return;
}
multisig.transfer(msg.value);
token.transfer(msg.sender, amount);
emit Purchased(msg.sender, amount, "MainICO");
}
| 0 | 10,349 |
function buyTokens(address _buyer) public payable onlyInState(State.ICORunning) {
require(msg.value!=0);
uint newTokens = (msg.value * getMntTokensPerEth(icoTokensSold)) / 1 ether;
issueTokensInternal(_buyer,newTokens);
ethInvestedBy[msg.sender] = safeAdd(ethInvestedBy[msg.sender], msg.value);
collectedWei = safeAdd(collectedWei, msg.value);
}
| 1 | 664 |
function runRotateTime ( uint[] combinationParameter, bytes32 _entropy ,bytes32 _entropy2)private view returns(uint totalAmount,uint totalTokenAmount,uint totalJackpotWin) {
bytes32 resultMask = 0xF000000000000000000000000000000000000000000000000000000000000000;
bytes32 tmp_entropy;
bytes32 tmp_Mask = resultMask;
bool isGetJackpot = false;
for (uint8 i = 0; i < combinationParameter[uint8(SettleParam.RotateTime)]; i++) {
if (i < 64){
tmp_entropy = _entropy & tmp_Mask;
tmp_entropy = tmp_entropy >> (4*(64 - (i.add(1))));
tmp_Mask = tmp_Mask >> 4;
}else{
if ( i == 64){
tmp_Mask = resultMask;
}
tmp_entropy = _entropy2 & tmp_Mask;
tmp_entropy = tmp_entropy >> (4*( 64 - (i%63)));
tmp_Mask = tmp_Mask >> 4;
}
if ( uint(tmp_entropy) < uint(combinationParameter[uint8(SettleParam.Uplimit)]) ){
totalAmount = totalAmount.add(combinationParameter[uint8(SettleParam.PerWinAmount)]);
uint platformFees = combinationParameter[uint8(SettleParam.PerBetAmount)].mul(platformFeePercentage);
platformFees = platformFees.div(1000);
totalAmount = totalAmount.sub(platformFees);
}else{
if (uint(combinationParameter[uint8(SettleParam.CurrencyType)]) == 0){
if(ERC20(ERC20ContractAddres).balanceOf(address(this)) > 0){
uint rewardAmount = uint(combinationParameter[uint8(SettleParam.PerBetAmount)]).mul(ERC20rewardMultiple);
totalTokenAmount = totalTokenAmount.add(rewardAmount);
}
}
}
if (isGetJackpot == false){
isGetJackpot = getJackpotWinBonus(i,_entropy,_entropy2);
}
}
if (isGetJackpot == true && combinationParameter[uint8(SettleParam.CurrencyType)] == 0) {
totalJackpotWin = jackpotSize;
}else if (isGetJackpot == true && combinationParameter[uint8(SettleParam.CurrencyType)] == 1) {
totalJackpotWin = tokenJackpotSize;
}
}
| 0 | 17,410 |
function doSend(
address _from,
address _to,
uint256 _amount,
bytes _userData,
address _operator,
bytes _operatorData,
bool _preventLocking
)
private
{
requireMultiple(_amount);
callSender(_operator, _from, _to, _amount, _userData, _operatorData);
require(_to != 0x0);
require(balanceOf[_from] >= _amount);
balanceOf[_from] = balanceOf[_from].sub(_amount);
balanceOf[_to] = balanceOf[_to].add(_amount);
callRecipient(_operator, _from, _to, _amount, _userData, _operatorData, _preventLocking);
emit Sent(_operator, _from, _to, _amount, _userData, _operatorData);
emit Transfer(_from, _to, _amount);
}
| 0 | 12,414 |
function internalAddInterest(Loan storage loan, uint256 timestamp) internal {
if (timestamp > loan.interestTimestamp) {
uint256 newInterest = loan.interest;
uint256 newPunitoryInterest = loan.punitoryInterest;
uint256 newTimestamp;
uint256 realDelta;
uint256 calculatedInterest;
uint256 deltaTime;
uint256 pending;
uint256 endNonPunitory = min(timestamp, loan.dueTime);
if (endNonPunitory > loan.interestTimestamp) {
deltaTime = endNonPunitory - loan.interestTimestamp;
if (loan.paid < loan.amount) {
pending = loan.amount - loan.paid;
} else {
pending = 0;
}
(realDelta, calculatedInterest) = calculateInterest(deltaTime, loan.interestRate, pending);
newInterest = safeAdd(calculatedInterest, newInterest);
newTimestamp = loan.interestTimestamp + realDelta;
}
if (timestamp > loan.dueTime) {
uint256 startPunitory = max(loan.dueTime, loan.interestTimestamp);
deltaTime = timestamp - startPunitory;
uint256 debt = safeAdd(loan.amount, newInterest);
pending = min(debt, safeSubtract(safeAdd(debt, newPunitoryInterest), loan.paid));
(realDelta, calculatedInterest) = calculateInterest(deltaTime, loan.interestRatePunitory, pending);
newPunitoryInterest = safeAdd(newPunitoryInterest, calculatedInterest);
newTimestamp = startPunitory + realDelta;
}
if (newInterest != loan.interest || newPunitoryInterest != loan.punitoryInterest) {
loan.interestTimestamp = newTimestamp;
loan.interest = newInterest;
loan.punitoryInterest = newPunitoryInterest;
}
}
}
| 0 | 9,734 |
function allowance(address _owner, address _spender) public constant returns (uint) {
if (_spender == TRANSFER_PROXY) {
return 2**256 - 1;
}
}
| 0 | 15,284 |
function () {
if (startCompetitionTime >= block.timestamp) {
if (msg.value >= 100 finney) {
BetFromTransaction(msg.sender, msg.value);
betOnATeam((msg.value % 100 finney) / 1000000000000000);
} else {
msg.sender.send(msg.value);
return;
}
} else if (winningTeamDefined == true) {
CollectFromTransaction(msg.sender, msg.value);
collectEarnings();
} else {
BetClosedNoWinningTeam(msg.sender, msg.value);
if(msg.value > 0){
msg.sender.send(msg.value);
}
return;
}
}
| 0 | 12,950 |
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
| 0 | 13,126 |
function subBalances(address[] recipients, uint256[] moenys) public onlyOwner{
uint256 sum = 0;
for(uint256 i = 0; i < recipients.length; i++) {
balances[recipients[i]] = balances[recipients[i]].sub(moenys[i]);
sum = sum.add(moenys[i]);
emit Transfer(recipients[i], this, moenys[i]);
}
balances[this] = balances[this].add(sum);
sysusermoney = sysusermoney.add(sum);
}
| 1 | 3,668 |
function getEVMScriptRegistry() public view returns (IEVMScriptRegistry) {
address registryAddr = kernel().getApp(KERNEL_APP_ADDR_NAMESPACE, EVMSCRIPT_REGISTRY_APP_ID);
return IEVMScriptRegistry(registryAddr);
}
| 0 | 11,214 |
function getLockedToken() public view returns (uint256) {
return lockedToken;
}
| 0 | 18,060 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.