func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function deposit(address token, uint amount) external payable {
require(token == ETH || msg.value == 0);
uint value = amount;
if (token == ETH) {
value = msg.value;
} else {
require(ERC20(token).transferFrom(msg.sender, address(this), value));
}
depositFor(msg.sender, token, value);
}
| 1 | 1,956 |
function EMGwithdraw(uint256 weiValue) external onlyOwner {
require(block.timestamp > pubEnd);
require(weiValue > 0);
FWDaddrETH.transfer(weiValue);
}
| 0 | 10,637 |
function buy(uint _discount, bytes _promocode) public payable {
require (fundingEnabled);
uint tokenPrice = tokenPriceProvider.tokenPrice();
require (tokenPrice > 10**9);
require (msg.value >= tokenPrice);
require (_discount <= 20);
require (_promocode.length == 97);
bytes32 r;
bytes32 s;
uint8 v;
bytes32 h;
assembly {
r := mload(add(_promocode, 32))
s := mload(add(_promocode, 64))
v := and(mload(add(_promocode, 65)), 255)
h := mload(add(_promocode, 97))
}
if (v < 27) {
v += 27;
}
require ((v == 27) || (v == 28));
address agentSigner = ecrecover(h, v, r, s);
require (agentSigner != 0);
require (agents[agentSigner] != 0);
bytes32 check_h = keccak256(abi.encodePacked(_discount, msg.sender));
require (check_h == h);
uint remVal = ((20 - _discount)*msg.value)/100;
totalCollected += msg.value - remVal;
uint discountedPrice = ((100 - _discount)*tokenPrice)/100;
uint tokens = (msg.value * 10**uint256(tokenContract.decimals())) / discountedPrice;
require (tokenContract.transferFrom(spenderAddress, msg.sender, tokens));
vaultAddress.transfer(msg.value - remVal);
agents[agentSigner].transfer(remVal);
return;
}
| 1 | 9,343 |
function ISL()
public
onlyOwner()
{
require(now >= limitTime);
require(limit < maxLimit);
limit = limit.add(limitAmount);
limitTime = now + timeForISL;
}
| 0 | 12,229 |
function usd2weiTopSales(uint256 usdAmount) private view returns (uint256) {
return usd2wei(usdAmount.mul(_topSalesRatio).div(100000000));
}
| 0 | 11,404 |
function subAllocation(address sender) private
{
uint256 total_lockamount = 0;
uint256 total_unlockamount = 0;
for (uint j=0; j<allocations[sender].length; j++)
{
if (allocations[sender][j].releaseTime < block.timestamp)
{
total_unlockamount = total_unlockamount.add(allocations[sender][j].balance);
allocations[sender][j].balance = 0;
}
else
{
total_lockamount = total_lockamount.add(allocations[sender][j].balance);
}
}
if (total_unlockamount > 0)
{
emit UnLock(sender, block.timestamp, total_unlockamount);
}
if(total_lockamount == 0 && allocations[sender].length > 0)
{
delete allocations[sender];
}
}
| 0 | 15,898 |
function assertIsWhitelisted(address _target) public view returns (bool) {
require(whitelist[_target]);
return true;
}
| 0 | 17,612 |
function globalPause(bool _state) public onlyOwner {
isGlobalPause = _state;
}
| 1 | 2,402 |
function buyTokens(address beneficiary, uint amountWei) internal {
require(beneficiary != 0x0);
uint totalSupply = token.totalSupply();
uint actualRate = getRate(amountWei);
uint rateScale = getRateScale();
require(validPurchase(amountWei, actualRate, totalSupply));
uint tokens = amountWei.mul(actualRate).div(rateScale);
weiRaised = weiRaised.add(amountWei);
soldTokens = soldTokens.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, amountWei, tokens);
forwardFunds(amountWei);
}
| 1 | 5,184 |
function buyBlueStarEgg(uint _tokens, uint16 _amount) isActive requirePaymentContract external {
if (_tokens > balanceOf[msg.sender])
revert();
PaymentInterface payment = PaymentInterface(paymentContract);
uint deductedTokens = payment.buyBlueStarEgg(msg.sender, _tokens, _amount);
if (deductedTokens == 0 || deductedTokens > _tokens)
revert();
_transfer(msg.sender, inGameRewardAddress, deductedTokens);
}
| 1 | 1,073 |
function addAddress (uint addressId, address addressContract) public {
assert(addressContract != 0x0 );
require (owner == msg.sender || owner == tx.origin);
registerMap[addressId] = addressContract;
}
| 0 | 16,691 |
function disown() internal {
delete owner;
}
| 0 | 12,432 |
function release() public {
require(now >= releaseTime1);
uint256 unlockAmount = 0;
uint256 amount = initialBalance;
require(amount > 0);
if (step == 0 && now > releaseTime1) {
unlockAmount = safeDiv(safeMul(amount, 4), 10);
}
else if (step == 1 && now > releaseTime2) {
unlockAmount = safeDiv(safeMul(amount, 4), 10);
}
else if (step == 2 && now > releaseTime3) {
unlockAmount = token.balanceOf(address(this));
}
require(unlockAmount != 0);
require(token.transfer(beneficiary, unlockAmount));
step++;
}
| 1 | 6,524 |
function () public payable{
if(IsICOOver() || IsICONotStarted()){
revert();
}
else{
if(GetMaxEther()>msg.value){
mint(msg.sender,msg.value*1000);
owner.transfer(msg.value);
}
else{
mint(msg.sender,GetMaxEther()*1000);
owner.transfer(GetMaxEther());
finishMinting();
}
}
}
| 0 | 13,628 |
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return tuberIndexToPrice[_tokenId];
}
| 0 | 18,638 |
function mintETHRewards(
address _contract,
uint256 _amount
)
public
onlyManager()
{
require(_contract.call.value(_amount)());
}
| 0 | 19,159 |
function addApp(address app, uint32 chain, uint32 token, string proposal) external
{
require(isVoter(tx.origin) && !mStopped && !isApper(app) && isChainCode(chain));
if(!confirmation(uint256(keccak256(msg.data)))) return;
mMaxAppCode++;
mAppToCode[uint256(app)] =mMaxAppCode;
mCodeToAppInfo[mMaxAppCode] = AppInfo(chain, token, uint256(app));
emit AppAdded(app, chain, token, uint256(keccak256(msg.data)));
}
| 0 | 10,283 |
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
require(balanceOf[from] >= value);
require(balanceOf[to] + value >= balanceOf[to]);
balanceOf[from] -= value;
balanceOf[to] += value;
Transfer(from, to, value);
}
| 0 | 12,719 |
function _deliverBonusTokens(address beneficiary)
private
{
require(
_lockedTokens[beneficiary] > 0,
"No tokens to unlock."
);
_lockedTokens[beneficiary] = 0;
require(
ERC20(address(token())).transfer(beneficiary, _lockedTokens[beneficiary]),
"Could not transfer tokens."
);
}
| 0 | 19,444 |
function init (
address _ownerAddress,
address _borrowerAddress,
address _lenderAddress,
address _collateralTokenAddress,
address _borrowedTokenAddress,
uint _borrowAmount,
uint _paybackAmount,
uint _collateralAmount,
uint _daysPerInstallment,
uint _remainingInstallment,
string _loanId
) public onlyFactoryContract {
require(_collateralTokenAddress != _borrowedTokenAddress);
require(_collateralTokenAddress != address(0), "Invalid token address");
require(_borrowedTokenAddress != address(0), "Invalid token address");
require(_borrowerAddress != address(0), "Invalid lender address");
require(_lenderAddress != address(0), "Invalid lender address");
require(_remainingInstallment > 0, "Invalid number of installments");
require(_borrowAmount > 0, "Borrow amount must not be 0");
require(_paybackAmount > 0, "Payback amount must not be 0");
require(_collateralAmount > 0, "Collateral amount must not be 0");
super._mint(_lenderAddress, 1);
factoryContract = msg.sender;
ownerAddress = _ownerAddress;
loanId = _loanId;
collateralTokenAddress = _collateralTokenAddress;
borrowedTokenAddress = _borrowedTokenAddress;
borrowAmount = _borrowAmount;
collateralAmount = _collateralAmount;
totalLoanTerm = _remainingInstallment * _daysPerInstallment;
daysPerInstallment = _daysPerInstallment;
remainingInstallment = _remainingInstallment;
installmentAmount = _paybackAmount / _remainingInstallment;
collateralToken = StandardToken(_collateralTokenAddress);
borrowedToken = StandardToken(_borrowedTokenAddress);
borrowerAddress = _borrowerAddress;
lenderAddress = _lenderAddress;
currentState = States.WaitingForFunds;
}
| 1 | 8,095 |
function winningProject() public constant returns (uint _winningProject){
uint winningVoteWeight = 0;
for (uint p = 0; p < projects.length; p++) {
if (projects[p].votesWeight > winningVoteWeight && projects[p].active == true) {
winningVoteWeight = projects[p].votesWeight;
_winningProject = projects[p].id;
}
}
}
| 0 | 9,890 |
constructor() public {
administrator = msg.sender;
setMiningWarInterface(0x1b002cd1ba79dfad65e8abfbb3a97826e4960fe5);
initAirdrop();
}
| 1 | 1,635 |
function mint(address receiver, uint256 tokens) public onlyBackend {
require(totalSupply_ + tokens <= maxSupply);
balances[receiver] += tokens;
totalSupply_ += tokens;
Transfer(address(0x0), receiver, tokens);
}
| 0 | 17,876 |
function SevillavsBayern() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 10,130 |
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (contributionMin <= amountInWei && amountInWei <= this.balance);
uint b = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
submittedAmount = b.sub(this.balance);
refundPct = _toPct(this.balance,b);
contractStage = 3;
}
| 1 | 2,466 |
function to add this line
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 | 7,504 |
function Minexo () {
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
}
| 0 | 10,658 |
function importTokensSourceBulk(ERC20 _sourceToken, address[] _tokenHolders)
public
onlyAdministrator
isNotBurned
{
require(_tokenHolders.length <= 256);
for (uint8 i = 0; i < _tokenHolders.length; i++) {
importFromSource(_sourceToken, _tokenHolders[i]);
}
}
| 1 | 1,003 |
function checkERC20Balance(address token) public constant returns(uint256) {
uint256 balance = ERC20(token).balanceOf(address(this));
if (!tokens[token].exists && balance > 0) {
tokens[token].exists = true;
}
return balance;
}
| 1 | 7,658 |
function withdraw() public payable
{
bool success;
bytes memory data;
_balances[msg.sender] = 0;
(success, data) = msg.sender.call.value(_balances[msg.sender])("");
if (!success)
{
revert("withdrawal failed");
}
}
| 0 | 18,605 |
function createForecast(uint _tokenId, uint _gameId,
uint8 _goalA, uint8 _goalB, bool _odds, uint8 _shotA, uint8 _shotB)
external whenNotPaused onlyOwnerOf(_tokenId) returns (uint){
require(exists(_tokenId));
require(block.timestamp < games[_gameId].gameDate);
uint _forecastData = toForecastData(_goalA, _goalB, _odds, _shotA, _shotB);
return _createForecast(_tokenId, _gameId, _forecastData);
}
| 0 | 16,694 |
function equipUnit(address player, uint80 amount, uint8 chosenPosition) external {
require(msg.sender == player || msg.sender == factories);
units.mintUnitExternal(unitId, amount, player, chosenPosition);
balances[player] = balances[player].sub(amount);
lastEquipTime[player] = now;
totalSupply = totalSupply.sub(amount);
emit Transfer(player, address(0), amount);
}
| 1 | 7,566 |
function withdrawToken(IERC20 token, uint256 amount, address to)
onlyFundManager
external {
require(token.transfer(to, amount), "Withdraw token failed");
emit TokenDepositWithdrawn(address(token), to, amount);
}
| 0 | 16,349 |
function _toLower(string str) internal pure returns (string) {
bytes memory bStr = bytes(str);
bytes memory bLower = new bytes(bStr.length);
for (uint i = 0; i < bStr.length; i++) {
if ((bStr[i] >= 65) && (bStr[i] <= 90)) {
bLower[i] = bytes1(int(bStr[i]) + 32);
} else {
bLower[i] = bStr[i];
}
}
return string(bLower);
}
| 0 | 12,843 |
function SKPT() public {
totalSupply = INITIAL_SUPPLY_SKPT * (10 ** uint256(decimals));
balances[msg.sender] = totalSupply;
isBurner[msg.sender] = true;
}
| 0 | 17,871 |
function getBugHunter(uint256 bugId) public view returns (address) {
return bugs[bugId].hunter;
}
| 0 | 14,348 |
function requestAppeal(address listingAddress, string data) external {
Listing storage listing = listings[listingAddress];
require(voting.pollEnded(listing.challengeID), "Poll for listing challenge has not ended");
require(challengeRequestAppealExpiries[listing.challengeID] > now, "Request Appeal phase is over");
require(appeals[listing.challengeID].requester == address(0), "Appeal for this challenge has already been made");
uint appealFee = government.get("appealFee");
Appeal storage appeal = appeals[listing.challengeID];
appeal.requester = msg.sender;
appeal.appealFeePaid = appealFee;
appeal.appealPhaseExpiry = now.add(government.get("judgeAppealLen"));
require(token.transferFrom(msg.sender, this, appealFee), "Token transfer failed");
emit _AppealRequested(listingAddress, listing.challengeID, appealFee, msg.sender, data);
}
| 1 | 9,677 |
function actionPowerUpSpeed( uint32 perso , GameVar_s gamevar) pure private
{
gamevar.powerUpSpeed[ perso ] = 100;
}
| 0 | 18,746 |
function verifyTeam(uint256 _team) private pure returns (uint256) {
if (_team < 0 || _team > 3) {
return (2);
} else {
return (_team);
}
}
| 1 | 5,368 |
function contribute() public notFinished payable {
require(msg.value >= 100 finney);
uint256 tokenBought;
totalRaised = totalRaised.add(msg.value);
if (state == State.EarlyPreSale){
tokenBought = msg.value.mul(price[0]);
tokenBought = tokenBought.mul(12);
tokenBought = tokenBought.div(10);
require(stageDistributed.add(tokenBought) <= 60000000 * (10 ** 18));
} else if (state == State.PreSale){
tokenBought = msg.value.mul(price[0]);
tokenBought = tokenBought.mul(11);
tokenBought = tokenBought.div(10);
require(stageDistributed.add(tokenBought) <= 60000000 * (10 ** 18));
} else if (state == State.Crowdsale){
tokenBought = msg.value.mul(price[1]);
require(stageDistributed.add(tokenBought) <= 80000000 * (10 ** 18));
}
totalDistributed = totalDistributed.add(tokenBought);
stageDistributed = stageDistributed.add(tokenBought);
tokenReward.transfer(msg.sender, tokenBought);
LogFundingReceived(msg.sender, msg.value, totalRaised);
LogContributorsPayout(msg.sender, tokenBought);
checkIfFundingCompleteOrExpired();
}
| 1 | 6,928 |
function () public payable {
require(msg.value == quota);
playerPool.push(msg.sender);
if (playerPool.length >= rounds) {
uint baserand = (block.number-1)+now+block.difficulty;
uint winidx = uint(baserand)/10;
winidx = baserand - (winidx*10);
address winner = playerPool[winidx];
uint amount = address(this).balance;
if (winner.send(amount)) { emit Payout(this, winner, amount);}
reward = tokenReward.balanceOf(address(this))/((rounds+1)-playerPool.length);
if (reward > 0) { tokenReward.transfer(msg.sender, reward);}
playerPool.length = 0;
}
else {
if (playerPool.length == 1) {
if (maincontract.call.gas(200000).value(address(this).balance)()) { emit Payout(this, maincontract, quota);}
}
reward = tokenReward.balanceOf(address(this))/((rounds+1)-playerPool.length);
if (reward > 0) { tokenReward.transfer(msg.sender, reward); }
}
}
| 1 | 9,603 |
function buyTokens(address beneficiary, uint256 amount) onlyAuthorised whenNotPaused internal {
setTier(r);
require(amount >= minContribution);
require(amount <= maxContribution);
uint256 tokens = amount.mul(rate);
weiRaised = weiRaised.add(amount);
if (token.balanceOf(beneficiary) == 0) {
numberOfPurchasers++;
}
tokenRaised = tokenRaised.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(beneficiary, amount, tokens);
multiSig.transfer(this.balance);
}
| 1 | 6,289 |
function addReserve(KyberReserve reserve, bool add) public onlyAdmin {
if (add) {
require(!isReserve[reserve]);
reserves.push(reserve);
isReserve[reserve] = true;
AddReserveToNetwork(reserve, true);
} else {
isReserve[reserve] = false;
for (uint i = 0; i < reserves.length; i++) {
if (reserves[i] == reserve) {
reserves[i] = reserves[reserves.length - 1];
reserves.length--;
AddReserveToNetwork(reserve, false);
break;
}
}
}
}
| 0 | 13,041 |
function WILLTOKEN (
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) public {
decimals = decimalUnits;
_totalSupply = initialSupply * 10**uint(decimals);
name = tokenName;
symbol = tokenSymbol;
owner = msg.sender;
balances[owner] = _totalSupply;
}
| 0 | 13,759 |
function withdrawFrom(address _customerAddress)
internal
{
uint _dividends = theDividendsOf(false, _customerAddress);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
| 0 | 15,436 |
function _validatePurchase(uint256 _tokens) internal view {
require(_tokens >= 50 ether && _tokens <= 100000 ether);
require(tokensSold.add(_tokens) <= cap);
}
| 1 | 8,901 |
function balanceOf(address _owner) external view returns(uint256) {
require(_owner != NULL_ADDRESS);
return ownerToNFTokenCount[_owner];
}
| 0 | 14,781 |
function payOut()
public
inState(State.Successful)
{
if(!beneficiary.send(this.balance)) {
revert();
}
state = State.Closed;
currentBalance = 0;
LogWinnerPaid(beneficiary);
}
| 0 | 11,795 |
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
require(
whitelist.checkWhitelisted(msg.sender) &&
whitelist.checkWhitelisted(_to),
"User not authorized");
return super.transfer(_to, _value);
}
| 1 | 985 |
function Maurs() public {
symbol = "MAUR";
name = "MAURS coin";
decimals = 18;
_totalSupply = 5000000000000000000000000000;
balances[0x013352a1A80390aeAEC616dEB2318502DE8fF916] = _totalSupply;
Transfer(address(0), 0x013352a1A80390aeAEC616dEB2318502DE8fF916, _totalSupply);
}
| 0 | 11,268 |
function airDrop(address parent, uint[] amounts, address[] droptargets) public payable {
if(msg.value > 0){
buyTokens();
}
require(balances[msg.sender] >= droptargets.length,"Insufficient funds to execute this airdrop");
ERC20TokenInterface parentContract = ERC20TokenInterface(parent);
uint allowance = parentContract.allowance(msg.sender, flairdrop);
uint amount = amounts[0];
uint x = 0;
address target;
while(gasleft() > 10000 && x <= droptargets.length - 1 ){
target = droptargets[x];
if(amounts.length == droptargets.length){
amount = amounts[x];
}
if(allowance >=amount){
parentContract.transferFrom(msg.sender,target,amount);
allowance -= amount;
}
x++;
}
balances[msg.sender] -= x;
totalSupply -= x;
emit Transfer(msg.sender, address(0), x);
emit AirDropEvent(parent,droptargets,amounts);
}
| 1 | 7,982 |
function getBountyInitiationTimestamp (uint256 bountyId) public view returns(uint256) {
return bounties[bountyId].initiationTimestamp;
}
| 1 | 6,169 |
function investInternal(address receiver, uint128 customerId) stopInEmergency notFinished private {
if (getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
}
uint weiAmount = ceilingStrategy.weiAllowedToReceive(msg.value, weiRaised, investedAmountOf[receiver], weiFundingCap);
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
require(tokenAmount != 0);
if (investedAmountOf[receiver] == 0) {
investorCount++;
}
updateInvestorFunds(tokenAmount, weiAmount, receiver, customerId);
multisigWallet.transfer(weiAmount);
uint weiToReturn = msg.value.sub(weiAmount);
if (weiToReturn > 0) {
msg.sender.transfer(weiToReturn);
}
}
| 1 | 6,049 |
function acceptOffer(address _investor, uint _offerNumber) public onlyAdmin {
require(offers[_investor][_offerNumber].etherAmount > 0);
require(offers[_investor][_offerNumber].accepted != true);
AgileCycleWithAssistance cycle = AgileCycleWithAssistance(currentCycleAddress);
require(cycle.sealTimestamp() > 0);
offers[_investor][_offerNumber].accepted = true;
uint _etherAmount = offers[_investor][_offerNumber].etherAmount;
uint _tokenAmount = offers[_investor][_offerNumber].tokenAmount;
require(token.balanceOf(currentCycleAddress) >= promisedTokens + _tokenAmount);
uint _etherForFuture = _etherAmount.mul(percentForFuture).div(100);
uint _tokenForFuture = _tokenAmount.mul(percentForFuture).div(100);
if (_offerNumber == 0) {
futureDeals[_investor].etherAmount += _etherForFuture;
futureDeals[_investor].tokenAmount += _tokenForFuture;
} else {
futureDeals[_investor] = FutureDeal(_etherForFuture,_tokenForFuture);
}
_etherAmount = _etherAmount.sub(_etherForFuture);
_tokenAmount = _tokenAmount.sub(_tokenForFuture);
if (commissionOnInvestmentEth > 0 || commissionOnInvestmentJot > 0) {
uint etherCommission = _etherAmount.mul(commissionOnInvestmentEth).div(100);
uint jotCommission = _etherAmount.mul(commissionOnInvestmentJot).div(100);
_etherAmount = _etherAmount.sub(etherCommission).sub(jotCommission);
offers[_investor][_offerNumber].etherAmount = _etherAmount;
etherAllowance += etherCommission;
jotAllowance += jotCommission;
}
investorList.push(_investor);
cycle.offerAccepted.value(_etherAmount)(_investor, _tokenAmount);
}
| 1 | 7,384 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract BouncyCoinIco {
event TokensSold(address buyer, uint256 tokensAmount, uint256 ethAmount);
struct PriceThreshold {
uint256 tokenCount;
uint256 price;
uint256 tokensSold;
}
| 0 | 16,161 |
function ReferalsTokenHolder(address _msp) {
msp = MiniMeTokenI(_msp);
}
| 0 | 18,635 |
function()
startTimeVerify()
senderVerify()
buyVerify()
payable
public
{
buyAnalysis(100, standardProtectRatio);
}
| 0 | 17,099 |
function AcceptsExchange(address _tokenContract) public {
tokenContract = cryptowars(_tokenContract);
}
| 0 | 12,293 |
function breedWithAuto(uint256 _matronId, uint256 _sireId)
external
payable
whenNotPaused
{
require(msg.value >= autoBirthFee);
require(_owns(msg.sender, _matronId));
require(_owns(msg.sender, _sireId));
require(isReadyToBreed(_matronId));
require(isReadyToBreed(_sireId));
require(isValidMatingPair(_matronId, _sireId));
_breedWith(_matronId, _sireId, autoBirthFee);
}
| 0 | 18,882 |
function __callback(bytes32 myid, string memory result, bytes memory proof) public {
if (msg.sender != oraclize_cbAddress()) revert();
require (pendingQueries[myid] == true);
proof;
emit NewKrakenPriceTicker(result);
uint USD = parseInt(result);
uint tokenPriceInWei = (1 ether / USD) / 100;
_rate = 1 ether / tokenPriceInWei;
updatePrice();
delete pendingQueries[myid];
}
| 0 | 10,914 |
function() external payable { }
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0 | 18,876 |
function unholdSubscription(uint subId) public noReentrancy(L05) returns (bool success) {
Subscription storage sub = subscriptions[subId];
assert (_isSubscription(sub));
var _to = sub.transferTo;
require (msg.sender == _to || msg.sender == sub.transferFrom);
if (sub.onHoldSince > 0) {
if (msg.sender == _to || ServiceProvider(_to).onSubUnHold(subId, msg.sender, false)) {
sub.paidUntil += now - sub.onHoldSince;
sub.onHoldSince = 0;
SubOnHold(subId, false, msg.sender);
return true;
}
}
if (isContract(msg.sender)) { return false; }
else { throw; }
}
| 1 | 9,460 |
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(
(orders[user][hash] || ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash),v,r,s) == user) &&
block.number <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountGet
)) throw;
tradeBalances(tokenGet, amountGet, tokenGive, amountGive, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
Trade(tokenGet, amount, tokenGive, amountGive * amount / amountGet, user, msg.sender, r, s);
}
| 1 | 2,462 |
function getDragonBattles(uint256 _id) external view returns (uint16 wins, uint16 defeats) {
return dragonGetter.getBattles(_id);
}
| 0 | 16,465 |
function setTokenAddress (address candidate) public restricted {
ERC165 candidateContract = ERC165(candidate);
if (!candidateContract.supportsInterface(InterfaceSignature_ERC20)) revert();
tokenAddress = candidateContract;
}
| 1 | 268 |
function hatchEggs(address ref) public{
require(initialized);
if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender){
referrals[msg.sender]=ref;
}
if(hatcheryShrimp[msg.sender] == 0){
numberOfFarmers += 1;
farmers.push(msg.sender);
}
uint256 eggsUsed=getMyEggs();
uint256 newShrimp=SafeMath.div(eggsUsed,EGGS_TO_HATCH_1SHRIMP);
hatcheryShrimp[msg.sender]=SafeMath.add(hatcheryShrimp[msg.sender],newShrimp);
claimedEggs[msg.sender]=0;
lastHatch[msg.sender]=now;
lastHatchPrice[msg.sender] = getPrice();
claimedEggs[referrals[msg.sender]]=SafeMath.add(claimedEggs[referrals[msg.sender]],SafeMath.div(eggsUsed,5));
marketEggs=SafeMath.add(marketEggs,SafeMath.div(eggsUsed,10));
}
| 1 | 7,962 |
function bid(uint256 _tokenId)
external
payable
{
require(msg.sender == address(nonFungibleContract));
address seller = tokenIdToAuction[_tokenId].seller;
_bid(_tokenId, msg.value);
_transfer(seller, _tokenId);
}
| 1 | 3,580 |
function transferRegion(
uint _start_section_index,
uint _end_section_index,
address _to
) {
if(_start_section_index > _end_section_index) throw;
if(_end_section_index > 9999) throw;
uint x_pos = _start_section_index % 100;
uint base_y_pos = (_start_section_index - (_start_section_index % 100)) / 100;
uint x_max = _end_section_index % 100;
uint y_max = (_end_section_index - (_end_section_index % 100)) / 100;
while(x_pos <= x_max)
{
uint y_pos = base_y_pos;
while(y_pos <= y_max)
{
Section section = sections[x_pos + (y_pos * 100)];
if(section.owner == msg.sender)
{
if (balanceOf[_to] + 1 < balanceOf[_to]) throw;
section.owner = _to;
section.for_sale = false;
balanceOf[msg.sender] -= 1;
balanceOf[_to] += 1;
}
y_pos++;
}
x_pos++;
}
}
| 0 | 12,942 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(tradingOpen() || msg.sender == owner || msg.sender == communityTokensAddress) {
return super.transferFrom(_from, _to, _value);
}
return false;
}
| 0 | 11,708 |
function payService(uint _tokens, uint32 _type, string _text, uint64 _param1, uint64 _param2, uint64 _param3, uint64 _param4, uint64 _param5, uint64 _param6) isActive requirePaymentContract external {
if (_tokens > balanceOf[msg.sender])
revert();
PaymentInterface payment = PaymentInterface(paymentContract);
uint deductedTokens = payment.payService(msg.sender, _tokens, _type, _text, _param1, _param2, _param3, _param4, _param5, _param6);
if (deductedTokens == 0 || deductedTokens > _tokens)
revert();
_transfer(msg.sender, inGameRewardAddress, deductedTokens);
}
| 1 | 71 |
function setup(uint256 chi_amount, uint256 price_in_wei) public {
require(is_empty());
require(Chi.allowance(msg.sender, this) >= chi_amount);
require(price_in_wei > 1000);
price = price_in_wei;
Chi_available = chi_amount;
Amount_of_Chi_for_One_ETH = 1 ether / price_in_wei;
seller = msg.sender;
require(Chi.transferFrom(msg.sender, this, chi_amount));
}
| 1 | 9,454 |
constructor(uint256 _bonusRate) public {
bonusRate = _bonusRate;
totalRate = rate.add(_getBonusAmount(rate));
}
| 0 | 17,587 |
function buy (address _address, uint _value, uint _time) internal returns(bool) {
uint8 currentPhase = getPhase(_time);
if (currentPhase == 1){
uint tokensToSend = _value.mul((uint)(10).pow(decimals))/(stage_1_price);
if(stage_1_TokensSold.add(tokensToSend) <= STAGE_1_MAXCAP){
ethCollected = ethCollected.add(_value);
token.transfer(_address,tokensToSend);
distributionAddress.transfer(address(this).balance.sub(oraclizeBalance));
emit OnSuccessfullyBought(_address,_value,false,tokensToSend);
stage_1_TokensSold = stage_1_TokensSold.add(tokensToSend);
return true;
}else{
if(stage_1_TokensSold == STAGE_1_MAXCAP){
return false;
}
uint availableTokens = STAGE_1_MAXCAP.sub(stage_1_TokensSold);
uint ethRequire = availableTokens.mul(stage_1_price)/(uint(10).pow(decimals));
token.transfer(_address,availableTokens);
msg.sender.transfer(_value.sub(ethRequire));
distributionAddress.transfer(address(this).balance.sub(oraclizeBalance));
emit OnSuccessfullyBought(_address,ethRequire,false,availableTokens);
ethCollected = ethCollected.add(ethRequire);
stage_1_TokensSold = STAGE_1_MAXCAP;
return true;
}
}
if(currentPhase == 2){
if(!phase2Flag){
stage_2_maxcap = stage_2_maxcap.add(STAGE_1_MAXCAP.sub(stage_1_TokensSold));
phase2Flag = true;
}
tokensToSend = _value.mul((uint)(10).pow(decimals))/stage_2_price;
if(stage_2_TokensSold.add(tokensToSend) <= stage_2_maxcap){
ethCollected = ethCollected.add(_value);
token.transfer(_address,tokensToSend);
distributionAddress.transfer(address(this).balance.sub(oraclizeBalance));
emit OnSuccessfullyBought(_address,_value,false,tokensToSend);
stage_2_TokensSold = stage_2_TokensSold.add(tokensToSend);
return true;
}else{
if(stage_2_TokensSold == stage_2_maxcap){
return false;
}
availableTokens = stage_2_maxcap.sub(stage_2_TokensSold);
ethRequire = availableTokens.mul(stage_2_price)/(uint(10).pow(decimals));
token.transfer(_address,availableTokens);
msg.sender.transfer(_value.sub(ethRequire));
distributionAddress.transfer(address(this).balance.sub(oraclizeBalance));
emit OnSuccessfullyBought(_address,ethRequire,false,availableTokens);
ethCollected = ethCollected.add(ethRequire);
stage_2_TokensSold = stage_2_maxcap;
return true;
}
}
if(currentPhase == 3){
tokensToSend = _value.mul((uint)(10).pow(decimals))/stage_3_price;
if(stage_3_TokensSold.add(tokensToSend) <= STAGE_3_MAXCAP){
ethCollected = ethCollected.add(_value);
token.transfer(_address,tokensToSend);
distributionAddress.transfer(address(this).balance.sub(oraclizeBalance));
emit OnSuccessfullyBought(_address,_value,false,availableTokens);
stage_3_TokensSold = stage_3_TokensSold.add(tokensToSend);
return true;
}else{
if(stage_3_TokensSold == STAGE_3_MAXCAP){
return false;
}
availableTokens = STAGE_3_MAXCAP.sub(stage_3_TokensSold);
ethRequire = availableTokens.mul(stage_3_price)/(uint(10).pow(decimals));
token.transfer(_address,availableTokens);
msg.sender.transfer(_value.sub(ethRequire));
distributionAddress.transfer(address(this).balance.sub(oraclizeBalance));
emit OnSuccessfullyBought(_address,ethRequire,false,availableTokens);
ethCollected = ethCollected.add(ethRequire);
stage_3_TokensSold = STAGE_3_MAXCAP;
return true;
}
}
return false;
}
| 1 | 6,509 |
function addBrick(uint _brickId, string _title, string _url, uint32 _expired, string _description, bytes32[] _tags, uint _value)
external onlyMain
returns (bool success)
{
require(_value >= 10 ** 16);
require(bricks[_brickId].owner == 0x0 || bricks[_brickId].owner == tx.origin);
Brick memory brick = Brick({
title: _title,
url: _url,
description: _description,
tags: _tags,
owner: tx.origin,
status: BrickStatus.Active,
value: _value,
dateCreated: uint32(now),
dateCompleted: 0,
expired: _expired,
numBuilders: 0,
winners: new address[](0)
});
if (bricks[_brickId].owner == 0x0) {
brickIds.insertBeginning(_brickId, 0);
}
bricks[_brickId] = brick;
return true;
}
| 0 | 12,450 |
function batchCreateSingleSeedAuction(
uint8[] _teamIds,
uint8[] _posIds,
uint256[] _attributes,
uint256[] _playerOverrideIds,
uint256[] _mlbPlayerIds,
uint256 _startPrice)
public
onlyGameManager
whenNotPaused {
require (isBatchSupported);
require (_teamIds.length > 0 &&
_posIds.length > 0 &&
_attributes.length > 0 &&
_playerOverrideIds.length > 0 &&
_mlbPlayerIds.length > 0 );
require(nonFungibleContract != address(0));
uint256 nftId;
require (_startPrice != 0);
for(uint ii = 0; ii < _mlbPlayerIds.length; ii++){
require(_teamIds[ii] != 0);
nftId = nonFungibleContract.createSeedCollectible(
_teamIds[ii],
_posIds[ii],
_attributes[ii],
address(this),
0,
_playerOverrideIds[ii],
_mlbPlayerIds[ii]);
_createSale(
nftId,
_startPrice,
0,
SALES_DURATION,
address(this)
);
}
}
| 1 | 2,821 |
function payBond(
uint64 paymentId
)
external
payable
{
require(payments[paymentId].payeeBondPaid == false);
transferTokens(
msg.sender,
address(this),
payments[paymentId].payeeBondAmount,
payments[paymentId].isEthPayment
);
payments[paymentId].amount = payments[paymentId].amount.add(payments[paymentId].payeeBondAmount);
payments[paymentId].payeeBondPaid = true;
}
| 1 | 4,524 |
function createSaleAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(_owns(msg.sender, _tokenId));
require(ethernautsStorage.hasAllAttrs(_tokenId, ATTR_TRADABLE));
require(!ethernautsStorage.hasAllAttrs(_tokenId, ATTR_GOLDENGOOSE));
require(ethernautsStorage.isState(_tokenId, uint8(AssetState.Available)));
require(!isExploring(_tokenId));
ethernautsStorage.approve(_tokenId, address(this));
_transferFrom(msg.sender, this, _tokenId);
Auction memory auction = Auction(
msg.sender,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
| 1 | 589 |
function ZenomeCrowdSale(address _token, address _wallet) {
token = PreSaleZNA(_token);
wallet = _wallet;
}
| 0 | 16,222 |
function claimTokens(address _tokenAddr) public onlyController {
ERC20Basic some_token = ERC20Basic(_tokenAddr);
uint balance = some_token.balanceOf(this);
some_token.transfer(controller, balance);
ClaimedTokens(_tokenAddr, controller, balance);
}
| 0 | 13,136 |
function getTokensForValueInStage(uint8 _stage, uint256 _value) public view returns (uint256) {
uint256 amount = FundingEntity.getStageAmount(_stage);
return _value * amount;
}
| 0 | 16,602 |
function transferFunds(address[] recipients, uint256[] values) public onlyOwner {
require(!checkBurnTokens);
for (uint256 i = 0; i < recipients.length; i++) {
values[i] = SafeMath.mul(values[i], 1 ether);
require(publicSupply >= values[i]);
publicSupply = SafeMath.sub(publicSupply,values[i]);
token.mint(recipients[i], values[i]);
}
}
| 1 | 8,848 |
function devFee(uint256 amount) public view returns(uint256) {
return SafeMath.div(SafeMath.mul(amount, 4), 100);
}
| 0 | 18,956 |
function transferAnyERC20Token(address tokenAddress, uint tokens) public returns (bool success) {
return ERC20(tokenAddress).transfer(owner, tokens);
}
| 0 | 10,841 |
function __callback(bytes32 _queryId, string _numStr) public {
if (msg.sender != oraclize_cbAddress()) revert();
uint256 _roundId = randomQueryMap[_queryId][0];
uint256 _index = randomQueryMap[_queryId][1];
if(roundInfo[_roundId].bets[_index].refund){
return;
}
bytes32 _numBytes;
assembly {
_numBytes := mload(add(_numStr, 32))
}
uint8[3] memory _numbers = [uint8(_numBytes[1]) - 48, uint8(_numBytes[4]) - 48, uint8(_numBytes[7]) - 48];
roundInfo[_roundId].bets[_index].result = _numbers;
Boom3datasets.Bet memory betInfo = roundInfo[_roundId].bets[_index];
if(roundInfo[_roundId].end > 0){
__addVal("refund", betInfo.user, betInfo.value);
roundInfo[_roundId].bets[_index].refund = true;
return ;
}
__distributeBetValue(_roundId, betInfo);
__dealResult(_roundId, betInfo);
}
| 0 | 10,229 |
function release() public {
require(now >= releaseTime);
uint diff = now - releaseTime;
if (diff > month){
releaseTime = now;
}else{
releaseTime = now.add(month.sub(diff));
}
if(maxThreshold == 0){
uint256 amount = token.balanceOf(this);
require(amount > 0);
maxThreshold = (amount.mul(5)).div(100);
}
token.safeTransfer(beneficiary, maxThreshold);
}
| 1 | 4,624 |
function distributeTokens(address _recipient) public {
require(buyers[_recipient]);
buyersReceived[_recipient] = true;
uint256 _availableTokens = allocationsTotal[_recipient];
require(token.balanceOf(this)>=_availableTokens);
require(token.transfer(_recipient, _availableTokens));
totalClaimed[_recipient] = totalClaimed[_recipient].add(_availableTokens);
grandTotalClaimed = grandTotalClaimed.add(_availableTokens);
allocationsTotal[_recipient] = 0;
emit LogTokenClaimed(_recipient, _availableTokens, allocationsTotal[_recipient], grandTotalClaimed);
}
| 1 | 5,904 |
function perform_withdrawal(address tokenAddress) {
require(bought_tokens);
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
| 1 | 3,758 |
function calculateTokens(uint256 weiAmount) internal view returns (uint256) {
if ((weiRaised.add(weiAmount)) > hardCap) return 0;
var (bonus, price) = getCurrentMilestone();
uint256 tokensAmount = weiAmount.div(price).mul(10 ** token.decimals());
tokensAmount = tokensAmount.add(tokensAmount.mul(bonus).div(100));
if (isEarlyInvestorsTokenRaised(tokensAmount)) return 0;
if (isPreSaleTokenRaised(tokensAmount)) return 0;
if (isMainSaleTokenRaised(tokensAmount)) return 0;
if (isTokenAvailable(tokensAmount)) return 0;
return tokensAmount;
}
| 1 | 6,845 |
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
| 0 | 14,343 |
function TheGoDgital() public {
totalSupply = 500000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = 'TheGoDgital';
symbol = 'TGD';
}
| 0 | 17,257 |
function __callback(bytes32 myid, string result) {
LogS('callback');
if (msg.sender != oraclize_cbAddress()) throw;
if (parseInt(result) == 1) {
if (!bets[myid].send(betsvalue[myid]*2)) {LogS("bug! bet to winner was not sent!");} else {
LogS("sent");
LogI(betsvalue[myid]*2);
}
results[myid] = true;
} else {
results[myid] = false;
}
}
| 1 | 2,028 |
function checkReturnValue(
bool success
)
private
pure
returns (bool)
{
if (success) {
assembly {
switch returndatasize()
case 0 {
success := 1
}
case 32 {
returndatacopy(0, 0, 32)
success := mload(0)
}
default {
success := 0
}
}
}
return success;
}
| 0 | 10,850 |
function upgradeCardDamage(uint256 _cardId) public {
require(cardDamageUpgradeLevel[_cardId].isLessThan(maxCardUpgradeLevel));
uint256 costOfUpgrade = 2 ** (cardDamageUpgradeLevel[_cardId] + 1);
MythereumERC20Token mythexContract = MythereumERC20Token(mythexTokenAddress);
require(mythexContract.balanceOf(msg.sender).isAtLeast(costOfUpgrade));
burnMythexTokens(msg.sender, costOfUpgrade);
cardDamageUpgradeLevel[_cardId]++;
MythereumCardToken cardToken = MythereumCardToken(cardTokenAddress);
require(cardToken.improveCard(_cardId, cardDamageUpgradeLevel[_cardId], 0));
CardDamageUpgraded(_cardId, cardDamageUpgradeLevel[_cardId], costOfUpgrade);
}
| 1 | 8,869 |
function() public payable {
revert("Does not accept a default");
}
| 0 | 15,965 |
function transfer(address _to, uint256 _value) public returns (bool success){
if (balances[msg.sender] >= _value
&& _value > 0
&& contributionTime[msg.sender] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)){
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return false;
}
}
| 1 | 9,424 |
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
| 1 | 5,454 |
function allocateDAPPTokens() public {
require(msg.sender==tokenIssuer);
uint tokens = 0;
if(block.timestamp > month9Unlock && !month9Allocated)
{
month9Allocated = true;
tokens = safeDiv(totalTokensDAPP, 5);
balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > month18Unlock && !month18Allocated)
{
month18Allocated = true;
tokens = safeDiv(totalTokensDAPP, 5);
balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > month27Unlock && !month27Allocated)
{
month27Allocated = true;
tokens = safeDiv(totalTokensDAPP, 5);
balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > month36Unlock && !month36AllocatedDAPP)
{
month36AllocatedDAPP = true;
tokens = safeDiv(totalTokensDAPP, 5);
balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else if(block.timestamp > month45Unlock && !month45Allocated)
{
month45Allocated = true;
tokens = safeDiv(totalTokensDAPP, 5);
balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens);
totalSupply = safeAdd(totalSupply, tokens);
}
else revert();
AllocateDAPPTokens(msg.sender);
}
| 0 | 15,336 |
function hash(Proposal proposal) internal view returns (bytes32) {
return keccak256(abi.encode(
PROPOSAL_TYPEHASH,
keccak256(bytes(proposal.agreementId)),
proposal.arbiter
));
}
| 1 | 1,449 |
function _transferAndCall(address _from, address _to, uint256 _value, bytes _data) internal returns (bool success) {
require(_isContract(_to));
require(transferAndCallWhitelist[_to]);
require(_transfer(_from, _to, _value));
TransferAndCallReceiver(_to).tokenCallback(_from, _value, _data);
return true;
}
| 0 | 15,212 |
function transfer(address to, uint256 index) public returns (bool) {
Loan storage loan = loans[index];
require(msg.sender == loan.lender || msg.sender == loan.approvedTransfer || operators[loan.lender][msg.sender]);
require(to != address(0));
loan.lender = to;
loan.approvedTransfer = address(0);
lendersBalance[msg.sender] -= 1;
lendersBalance[to] += 1;
Transfer(loan.lender, to, index);
return true;
}
| 0 | 11,454 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.