func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function offerOptionsConversion(BaseOptionsConverter converter)
external
onlyESOPOpen
onlyCompany
isCurrentCode
returns (ReturnCodes)
{
uint32 offerMadeAt = currentTime();
if (converter.getExercisePeriodDeadline() - offerMadeAt < MINIMUM_MANUAL_SIGN_PERIOD) {
return _logerror(ReturnCodes.TooLate);
}
if (converter.getESOP() != address(this)) {
return _logerror(ReturnCodes.InvalidParameters);
}
removeEmployeesWithExpiredSignaturesAndReturnFadeout();
conversionOfferedAt = offerMadeAt;
exerciseOptionsDeadline = converter.getExercisePeriodDeadline();
optionsConverter = converter;
esopState = ESOPState.Conversion;
OptionsConversionOffered(companyAddress, address(converter), offerMadeAt, exerciseOptionsDeadline);
return ReturnCodes.OK;
}
| 1 | 1,116 |
function fillOrder(uint id, uint amount) external {
require(id < currentOrderId);
require(amount > 0);
require(orders[id].creator != msg.sender);
require(orders[id].amount >= amount);
uint amountEther = calcAmountEther(orders[id].token, orders[id].price, amount);
if (orders[id].buy) {
balanceSub(orders[id].token, msg.sender, amount);
BalanceChanged(
orders[id].token,
msg.sender,
balanceOf[orders[id].token][msg.sender]
);
balanceAdd(orders[id].token, orders[id].creator, amount);
BalanceChanged(
orders[id].token,
orders[id].creator,
balanceOf[orders[id].token][orders[id].creator]
);
balanceAdd(0x0, msg.sender, amountEther);
BalanceChanged(
0x0,
msg.sender,
balanceOf[0x0][msg.sender]
);
} else {
balanceSub(0x0, msg.sender, amountEther);
BalanceChanged(
0x0,
msg.sender,
balanceOf[0x0][msg.sender]
);
balanceAdd(0x0, orders[id].creator, amountEther);
BalanceChanged(
0x0,
orders[id].creator,
balanceOf[0x0][orders[id].creator]
);
balanceAdd(orders[id].token, msg.sender, amount);
BalanceChanged(
orders[id].token,
msg.sender,
balanceOf[orders[id].token][msg.sender]
);
}
orders[id].amount -= amount;
FillOrder(id, msg.sender, orders[id].amount);
}
| 1 | 5,637 |
function buyTokens() issetTokensForSale saleIsOn payable {
require(msg.value >= rate);
uint tokens = msg.value.mul(1 ether).div(rate);
address referer = 0x0;
uint bonusTokens = 0;
if(now < start.add(7* 1 days)) {
bonusTokens = tokens.mul(45).div(100);
} else if(now >= start.add(7 * 1 days) && now < start.add(14 * 1 days)) {
bonusTokens = tokens.mul(40).div(100);
} else if(now >= start.add(14* 1 days) && now < start.add(21 * 1 days)) {
bonusTokens = tokens.mul(35).div(100);
} else if(now >= start.add(21* 1 days) && now < start.add(28 * 1 days)) {
bonusTokens = tokens.mul(30).div(100);
}
tokens = tokens.add(bonusTokens);
if(now >= start.add(14* 1 days) && now < start.add(28 * 1 days)) {
if(msg.data.length == 20) {
referer = bytesToAddress(bytes(msg.data));
require(referer != msg.sender);
uint refererTokens = tokens.mul(refererPercent).div(100);
}
}
if(availableTokensforPreICO > countOfSaleTokens.add(tokens)) {
token.transfer(msg.sender, tokens);
currentPreICObalance = currentPreICObalance.add(msg.value);
countOfSaleTokens = countOfSaleTokens.add(tokens);
balances[msg.sender] = balances[msg.sender].add(msg.value);
if(availableTokensforPreICO > countOfSaleTokens.add(tokens).add(refererTokens)){
if(referer !=0x0 && refererTokens >0){
token.transfer(referer, refererTokens);
countOfSaleTokens = countOfSaleTokens.add(refererTokens);
}
}
} else {
uint availabeTokensToSale = availableTokensforPreICO.sub(countOfSaleTokens);
countOfSaleTokens = countOfSaleTokens.add(availabeTokensToSale);
token.transfer(msg.sender, availabeTokensToSale);
uint changes = msg.value.sub(availabeTokensToSale.mul(rate).div(1 ether));
balances[msg.sender] = balances[msg.sender].add(msg.value.sub(changes));
currentPreICObalance = currentPreICObalance.add(msg.value.sub(changes));
msg.sender.transfer(changes);
}
}
| 1 | 5,085 |
function placeSell(address tokenAddr, uint price, uint amount) external {
require(price > 0 && amount > 0);
uint amountEther = calcAmountEther(tokenAddr, price, amount);
require(amountEther > 0);
balanceSub(tokenAddr, msg.sender, amount);
emit BalanceChanged(tokenAddr, msg.sender, balanceOf[tokenAddr][msg.sender]);
orders[currentOrderId] = Order({
creator: msg.sender,
token: tokenAddr,
buy: false,
price: price,
amount: amount
});
emit PlaceSell(tokenAddr, msg.sender, price, amount, currentOrderId);
currentOrderId++;
ZFXToken.mint(msg.sender, 1000000000000000000);
}
| 1 | 1,757 |
function balances()
public
view
returns (address[] _addresses, uint[] _balances)
{
uint _size = size();
_addresses = new address[](_size);
_balances = new uint[](_size);
uint _i = 0;
Entry memory _curEntry = entries[0x0];
while (_curEntry.next > 0) {
_addresses[_i] = _curEntry.next;
_balances[_i] = entries[_curEntry.next].balance;
_curEntry = entries[_curEntry.next];
_i++;
}
return (_addresses, _balances);
}
| 0 | 11,486 |
function setSymbol(string _symbol) public ifAuthorized(msg.sender, APHRODITE) {
symbol = _symbol;
}
| 0 | 16,783 |
function fillOrder(address _from, uint numTokens) public returns (bool) {
return _fillOrder(_from, numTokens);
}
| 0 | 18,550 |
function withdraw() {
uint256 contract_token_balance = token.balanceOf(address(this));
var (balance, balance_bonus, fee, whitelisted) = contr.contributors(msg.sender);
if (contributor_rounds[msg.sender] < rounds) {
Snapshot storage snapshot = snapshots[contributor_rounds[msg.sender]];
uint256 tokens_to_withdraw = (balance * snapshot.tokens_balance) / snapshot.eth_balance;
snapshot.tokens_balance -= tokens_to_withdraw;
snapshot.eth_balance -= balance;
contributor_rounds[msg.sender]++;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
}
| 1 | 6,353 |
function enter() {
if (msg.value < 10 finney) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 100 ether) {
collectedFees += msg.value - 100 ether;
amount = 100 ether;
}
else {
amount = msg.value;
}
uint idx = participants.length;
participants.length += 1;
participants[idx].etherAddress = msg.sender;
participants[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 15;
balance += amount - amount / 15;
} else {
collectedFees += amount;
}
while (balance > participants[payoutIdx].amount * 2) {
uint transactionAmount = participants[payoutIdx].amount *2;
participants[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 19,355 |
function sell(uint256 amount) public {
uint256 ethAmount = amount.div(sellExchangeRate);
require(!stopSell);
require(this.balance >= ethAmount);
require(ethAmount >= 1);
require(balances[msg.sender] >= amount);
require(balances[owner] + amount > balances[owner]);
require(!frozenAccount[msg.sender]);
require(!_isUserInternalLock());
balances[owner] = balances[owner].add(amount);
balances[msg.sender] = balances[msg.sender].sub(amount);
soldSupply = soldSupply.sub(amount);
sellSupply = sellSupply.add(amount);
Transfer(msg.sender, owner, amount);
msg.sender.transfer(ethAmount);
}
| 0 | 19,432 |
function linkSelf() public returns (VoteProxy voteProxy) {
initiateLink(msg.sender);
return approveLink(msg.sender);
}
| 1 | 3,644 |
function commitDepositBlock(uint256, uint24[DEPOSIT_BATCH_SIZE] memory, uint32, bytes32) public {
callExternal(depositor);
}
| 0 | 14,350 |
function CryptoTreasure() public {
defaultPrice = 0.05 ether;
numberOfSpots = 107;
defaultMaxPlayers = 25;
commissionFeePercent = 15;
bonusPoolPercent = 20;
gasForOraclize = 400000;
newGame();
}
| 0 | 12,001 |
function dKERNEL_PANIC() public onlyOwner
{
for (uint i = 0; i < raffle_bowl.length; i++)
{
if (address_to_tickets[raffle_bowl[i]] != 0)
{
ERC20_CALLS.transfer(raffle_bowl[i], address_to_tickets[raffle_bowl[i]] * ticket_price);
address_to_tickets[raffle_bowl[i]] = 0;
}
}
}
| 0 | 11,185 |
function that is called by miners to validate challenge digests, calculate reward,
* populate statistics, mutate epoch variables and adjust the solution difficulty as required. Once complete,
* a Mint event is emitted before returning a success indicator.
**/
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success);
function _hash(uint256 nonce, bytes32 challenge_digest) internal returns (bytes32 digest);
function _reward() internal returns (uint);
function _newEpoch(uint256 nonce) internal returns (uint);
function _adjustDifficulty() internal returns (uint);
}
contract CaelumAbstractMiner is AbstractERC918 {
using SafeMath for uint;
using ExtendedMath for uint;
uint256 public totalSupply = 2100000000000000;
uint public latestDifficultyPeriodStarted;
uint public epochCount;
uint public baseMiningReward = 50;
uint public blocksPerReadjustment = 512;
uint public _MINIMUM_TARGET = 2 ** 16;
uint public _MAXIMUM_TARGET = 2 ** 234;
uint public rewardEra = 0;
uint public maxSupplyForEra;
uint public MAX_REWARD_ERA = 39;
uint public MINING_RATE_FACTOR = 60;
uint public MAX_ADJUSTMENT_PERCENT = 100;
uint public TARGET_DIVISOR = 2000;
uint public QUOTIENT_LIMIT = TARGET_DIVISOR.div(2);
mapping(bytes32 => bytes32) solutionForChallenge;
mapping(address => mapping(address => uint)) allowed;
bytes32 public challengeNumber;
uint public difficulty;
uint public tokensMinted;
Statistics public statistics;
event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);
event RewardMasternode(address candidate, uint amount);
constructor() public {
tokensMinted = 0;
maxSupplyForEra = totalSupply.div(2);
difficulty = _MAXIMUM_TARGET;
latestDifficultyPeriodStarted = block.number;
_newEpoch(0);
}
| 1 | 1,696 |
function purchaseUpAndSpend(uint256 tokensToSpend, uint256 maxPrice, bytes32 orderId) public payable returns(uint256 tokensSpent_){
uint256 tokensToPurchaseUp = tokensToSpend.sub(token.balanceOf(msg.sender));
uint256 currentPrice = getPurchasePrice(msg.value, tokensToPurchaseUp);
uint256 tokensAvailableByCurrentPrice = msg.value.mul(1e18).div(currentPrice);
require(tokensToPurchaseUp <= tokensAvailableByCurrentPrice);
if (tokensToPurchaseUp>0) {
purchase(tokensToPurchaseUp, maxPrice);
}
spend(tokensToSpend, orderId);
return tokensToSpend;
}
| 1 | 2,295 |
function createWinner() public onlyService whenNotPaused{
require(smallRound[bigId][smallId].endTime < block.timestamp);
require(smallRound[bigId][smallId].winKey == 0);
uint256 seed = _random();
smallRound[bigId][smallId].winKey = addmod(uint256(blockhash(block.number-1)), seed, smallRound[bigId][smallId].totalKey);
emit createKey(smallRound[bigId][smallId].winKey, bigId, smallId);
}
| 0 | 14,794 |
function increaseAllowance(address spender, uint addedValue) public whenNotPaused onlyNotBlacklisted returns (bool success) {
return super.increaseAllowance(spender, addedValue);
}
| 0 | 14,696 |
function contribute(address _contributor) internal stopInEmergency respectTimeFrame returns(bool res) {
require(whiteList.isWhiteListed(_contributor));
Backer storage backer = backers[_contributor];
require (msg.value >= minInvestment);
if (backer.weiReceivedOne == 0 && backer.weiReceivedTwo == 0 && backer.weiReceivedMain == 0)
backersIndex.push(_contributor);
if (currentStep == Step.FundingPresaleOne) {
backer.weiReceivedOne = backer.weiReceivedOne.add(msg.value);
ethReceivedPresaleOne = ethReceivedPresaleOne.add(msg.value);
require(ethReceivedPresaleOne <= maxCapEth);
}else if (currentStep == Step.FundingPresaleTwo) {
backer.weiReceivedTwo = backer.weiReceivedTwo.add(msg.value);
ethReceivedPresaleTwo = ethReceivedPresaleTwo.add(msg.value);
require(ethReceivedPresaleOne + ethReceivedPresaleTwo <= maxCapEth);
}else if (currentStep == Step.FundingMainSale) {
backer.weiReceivedMain = backer.weiReceivedMain.add(msg.value);
ethReceiveMainSale = ethReceiveMainSale.add(msg.value);
uint tokensToSend = dollarPerEtherRatio.mul(msg.value) / 62;
totalTokensSold += tokensToSend;
require(totalTokensSold <= maxCapTokens);
}
multisig.transfer(msg.value);
ReceivedETH(_contributor, currentStep, msg.value);
return true;
}
| 1 | 5,939 |
function sadd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| 0 | 18,487 |
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount);
}
| 0 | 9,968 |
function vestStage() public view onlyReserveWallets returns(uint256){
uint256 vestingMonths = timeLockDurations[msg.sender].div(stageSettings[msg.sender]);
uint256 stage = (block.timestamp.sub(lockStartTime)).div(vestingMonths);
if(stage > stageSettings[msg.sender]){
stage = stageSettings[msg.sender];
}
return stage;
}
| 0 | 11,033 |
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, args[1], sha256(args[0]), args[2]));
return queryId;
}
| 1 | 3,313 |
function proposeOwnership(address _newOwnerCandidate) onlyOwner {
newOwnerCandidate = _newOwnerCandidate;
OwnershipRequested(msg.sender, newOwnerCandidate);
}
| 0 | 14,824 |
function setMultisig(address addr) public onlyOwner {
require(addr != 0x0);
multisigWallet = addr;
}
| 0 | 9,784 |
function allowance(address owner, address spender) public constant returns (uint256 remaining) {
remaining = _allowance[owner][spender];
}
| 0 | 9,915 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(isCrowdsalePaused == false);
require(validPurchase());
require(msg.value>=1*10**18);
require(TOKENS_SOLD<maxTokensToSale);
uint256 weiAmount = msg.value;
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
if (timeElapsedInDays <12)
{
require(usersAddressForPreICO.length<=5000);
if(EthSentAgainstAddress[beneficiary]==0)
{
usersAddressForPreICO.push(beneficiary);
}
EthSentAgainstAddress[beneficiary]+=weiAmount;
weiRaised = weiRaised.add(weiAmount);
weiRaisedInPreICO = weiRaisedInPreICO.add(weiAmount);
forwardFunds();
}
else if (timeElapsedInDays >= 12 && timeElapsedInDays <27)
{
revert();
}
else {
uint256 tokens = weiAmount.mul(ratePerWei);
uint256 bonus = determineBonus(tokens);
tokens = tokens.add(bonus);
require(TOKENS_SOLD.add(tokens)<=maxTokensToSale);
weiRaised = weiRaised.add(weiAmount);
token.transfer(beneficiary,tokens);
emit TokenPurchase(owner, beneficiary, weiAmount, tokens);
TOKENS_SOLD = TOKENS_SOLD.add(tokens);
forwardFunds();
}
}
| 1 | 215 |
function decision(bytes32 _preset, string _presetSrc, address[] _buyers, uint[] _amounts) onlyOwner public payable{
require(DC.getDecision(_preset) == address(0));
require(sha256(_presetSrc) == DC.getGoodPreset(_preset));
uint160 allAddress;
for (uint i = 0; i < _buyers.length; i++) {
allAddress += uint160(_buyers[i]);
}
uint random = _random();
uint goodPrice = DC.getGoodPrice(_preset);
uint result = uint(uint(_stringToBytes32(_presetSrc)) + allAddress + random) % goodPrice;
address finalAddress = _getFinalAddress(_amounts, _buyers, result);
DC.setDecision(_preset, finalAddress);
Decision(result, finalAddress, _buyers, _amounts);
}
| 1 | 1,072 |
function finalize()onlyOwner afterDeadline public {
require(!crowdsaleClosed);
finalization();
emit Finalized();
withdrawTokens();
crowdsaleClosed = true;
}
| 1 | 8,682 |
function depositTokens(address from, address token, uint256 tokens ) public returns (bool success)
{
ERC20Interface(token).transferFrom(from, this, tokens);
balances[token][from] = balances[token][from].add(tokens);
Deposit(token, from, tokens, balances[token][from]);
return true;
}
| 1 | 7,006 |
function DepositVault() public payable
{
require(msg.value > 0, 'must bigger than zero');
}
| 0 | 13,379 |
function emergencyStopSale()
only_sale_activated
only_sale_not_stopped
only(genaroDevMultisig)
public {
saleStopped = true;
}
| 1 | 8,652 |
function getPayeeIndex(bytes32 _requestId, address _address)
public
view
returns(int16)
{
if (requests[_requestId].payee.addr == _address) {
return 0;
}
for (uint8 i = 0; subPayees[_requestId][i].addr != address(0); i = i.add(1)) {
if (subPayees[_requestId][i].addr == _address) {
return i+1;
}
}
return -1;
}
| 0 | 13,705 |
function balanceOf(address _owner) public view returns(uint256 balance) {
return balances[_owner];
}
| 0 | 15,384 |
function playerEndGameConflictImpl(
uint32 _roundId,
uint8 _gameType,
uint16 _num,
uint _value,
int _balance,
bytes32 _playerHash,
bytes32 _playerSeed,
uint _gameId,
address _playerAddress
)
private
{
uint gameId = playerGameId[_playerAddress];
Game storage game = gameIdGame[gameId];
int maxBalance = conflictRes.maxBalance();
require(gameId == _gameId);
require(_roundId > 0);
require(keccak256(_playerSeed) == _playerHash);
require(_value <= game.stake);
require(-int(game.stake) <= _balance && _balance <= maxBalance);
require(int(game.stake) + _balance - int(_value) >= 0);
require(conflictRes.isValidBet(_gameType, _num, _value));
if (game.status == GameStatus.SERVER_INITIATED_END && game.roundId == _roundId) {
game.playerSeed = _playerSeed;
endGameConflict(game, gameId, _playerAddress);
} else if (game.status == GameStatus.ACTIVE
|| (game.status == GameStatus.SERVER_INITIATED_END && game.roundId < _roundId)) {
game.status = GameStatus.PLAYER_INITIATED_END;
game.endInitiatedTime = block.timestamp;
game.roundId = _roundId;
game.gameType = _gameType;
game.betNum = _num;
game.betValue = _value;
game.balance = _balance;
game.playerSeed = _playerSeed;
game.serverSeed = bytes32(0);
LogPlayerRequestedEnd(msg.sender, gameId);
} else {
revert();
}
}
| 1 | 25 |
function getCurrentAmountBonusRate(uint256 _weiAmount) private constant returns (uint) {
uint i;
for(i=0; i<amountBonus.length; i++) {
if(_weiAmount.mul(rate) >= amountBonus[i].timeOrAmount) {
return amountBonus[i].rateMultiplier;
}
}
return 100;
}
| 0 | 18,915 |
function isOpened() public view returns (bool) {
return (block.timestamp < closingTimePeriodOne && block.timestamp > openingTimePeriodOne) || (block.timestamp < closingTimePeriodTwo && block.timestamp > openingTimePeriodTwo);
}
| 0 | 10,601 |
function trigerAlarmClock(uint id) external payable {
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
clockList[id].reward = 0;
waitingTimers--;
msg.sender.transfer(clockList[id].reward);
}
| 1 | 7,659 |
function contribute(Round storage _round, Party _side, address _contributor, uint _amount, uint _totalRequired) internal {
uint contribution;
uint remainingETH;
(contribution, remainingETH) = calculateContribution(_amount, _totalRequired.subCap(_round.paidFees[uint(_side)]));
_round.contributions[_contributor][uint(_side)] += contribution;
_round.paidFees[uint(_side)] += contribution;
_round.feeRewards += contribution;
_contributor.send(remainingETH);
}
| 0 | 13,401 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(isBreakingCap(tokenAmount, weiAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 1 | 5,690 |
function endCrowdsale() public afterDeadline onlyOwner {
crowdsaleClosed = true;
}
| 0 | 9,744 |
function getTitle() public view returns(string) {
return "General Permission Manager";
}
| 0 | 12,721 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
| 1 | 9,171 |
function setSectionForSale(
uint _section_index,
uint256 _price
) {
if (_section_index >= sections.length) throw;
Section section = sections[_section_index];
if(section.owner != msg.sender) throw;
section.price = _price;
section.for_sale = true;
section.sell_only_to = 0x0;
NewListing(_section_index, _price);
}
| 0 | 10,847 |
function addToBank() public payable onlyOwnerOrManager {
}
| 0 | 11,908 |
function mintTokens(address walletToMint, uint256 t) payable public {
require(msg.sender == wallet);
require(token.totalSupply().add(t) < CAP);
if (now <= 1517266799) {
require(token.totalSupply().add(t) < CAP_PRE_SALE);
}
if (now > 1517266799) {
require(totalSupplyIco.add(t) < CAP_ICO_SALE);
totalSupplyIco = totalSupplyIco.add(t);
}
token.mint(walletToMint, t);
}
| 1 | 630 |
function send(address _to, uint256 _value) public
{
_send(_to, _value);
}
| 0 | 18,183 |
functionality.
* @dev With this contract, a card holder can swap his/her CryptoSagaCard for reward.
* This contract is intended to be inherited by CryptoSagaCardSwap implementation contracts.
*/
contract CryptoSagaCardSwap is Ownable {
address internal cardAddess;
modifier onlyCard {
require(msg.sender == cardAddess);
_;
}
function setCardContract(address _contractAddress)
public
onlyOwner
{
cardAddess = _contractAddress;
}
function swapCardForReward(address _by, uint8 _rank)
onlyCard
public
returns (uint256);
}
| 1 | 8,707 |
function distributeInvest(uint256 _pID, uint256 _aff_eth, uint256 _affID)
private
returns(uint256)
{
uint256 _p3d;
uint256 _aff;
uint256 _aff_2;
uint256 _aff_3;
uint256 _affID_1;
uint256 _affID_2;
uint256 _affID_3;
_p3d = 0;
_aff = _aff_eth / 10;
_aff_2 = _aff_eth / 20;
_aff_3 = _aff_eth / 10;
_affID_1 = _affID;
_affID_2 = plyr_[_affID_1].laff;
_affID_3 = plyr_[_affID_2].laff;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
} else {
_p3d = _p3d.add(_aff);
}
if (_affID_2 != _pID && _affID_2 != _affID && plyr_[_affID_2].name != '') {
plyr_[_affID_2].aff = _aff_2.add(plyr_[_affID_2].aff);
} else {
_p3d = _p3d.add(_aff_2);
}
if (_affID_3 != _pID && _affID_3 != _affID && plyr_[_affID_3].name != '') {
plyr_[_affID_3].aff = _aff_3.add(plyr_[_affID_3].aff);
} else {
_p3d = _p3d.add(_aff_3);
}
return _p3d;
}
| 0 | 17,104 |
function getIssueAssignee(uint delay, bytes32 bountyKey) internal {
contractBalance = this.balance;
string issueUrl = bounties[bountyKey].issueUrl;
bytes32 myid = oraclize_query(delay, "URL", strConcat("json(",issueUrl,").assignee.login"), oraclizeGasLimit);
queriesKey[myid] = bountyKey;
queriesType[myid] = QueryType.IssueAssignee;
bounties[bountyKey].balance -= contractBalance - this.balance;
}
| 1 | 6,614 |
function setRewardStatus(address addr, bool status) private {
reward[addr] = status;
}
| 1 | 5,243 |
function propose(
address _tokenAddress,
string _projectName,
string _websiteUrl,
string _whitepaperUrl,
string _legalDocumentUrl,
uint256 _icoStartDate,
uint256 _icoEndDate,
uint256 _icoRate,
uint256 _totalRaised) public {
require(proposals[round][_tokenAddress].totalContributions == 0);
require(getCurrentTimestamp() < startTime + duration);
StandardToken paymentToken = StandardToken(paymentTokenAddress);
uint256 downPayment = paymentToken.allowance(msg.sender, this);
if (downPayment < requiredDownPayment) {
revert();
}
paymentToken.transferFrom(msg.sender, this, downPayment);
proposals[round][_tokenAddress] = Proposal({
tokenAddress: _tokenAddress,
projectName: _projectName,
websiteUrl: _websiteUrl,
whitepaperUrl: _whitepaperUrl,
legalDocumentUrl: _legalDocumentUrl,
icoStartDate: _icoStartDate,
icoEndDate: _icoEndDate,
icoRate: _icoRate,
totalRaised: _totalRaised,
totalContributions: 0
});
proposals[round][_tokenAddress].contributions[msg.sender] =
downPayment - requiredDownPayment;
proposals[round][_tokenAddress].totalContributions = downPayment;
roundContribution[round] = roundContribution[round].add(
downPayment - requiredDownPayment);
listed[_tokenAddress] = false;
if (downPayment >= softCap && downPayment < hardCap) {
candidates.push(_tokenAddress);
emit SoftCapReached(round, _tokenAddress);
}
if (downPayment >= hardCap) {
listed[_tokenAddress] = true;
emit TokenListed(round, _tokenAddress, refundable[_tokenAddress]);
}
refundable[_tokenAddress] = startTime + duration + 7 * 1 days;
emit TokenProposed(round, _tokenAddress, refundable[_tokenAddress]);
}
| 1 | 1,102 |
function getTokenWithBonus(uint _token) constant returns(uint){
uint bonus = preIcoBonus(_token,block.timestamp).add(IcoBonus(block.timestamp));
return _token.add(_token.mul(bonus).div(100));
}
| 1 | 2,204 |
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract IPDealToken is ERC20, Ownable, Pausable {
uint128 internal MONTH = 30 * 24 * 3600;
using SafeMath for uint256;
struct LockupInfo {
uint256 releaseTime;
uint256 termOfRound;
uint256 unlockAmountPerRound;
uint256 lockupBalance;
}
| 0 | 19,259 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value
&& allowed[_from][msg.sender] >= _value
&& _value > 0
&& balances[_to] + _value > balances[_to]) {
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
| 0 | 12,903 |
function enter() {
if (msg.value < 80/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 40 ether) {
msg.sender.send(msg.value - 40 ether);
amount = 10 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += 0;
owner.send(collectedFees);
collectedFees = 0;
balance += amount;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 180) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 180;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 11,477 |
function setWinPercentage(uint _category, uint _percentage) public onlyOwner {
winPercentage[_category] = _percentage;
}
| 0 | 11,308 |
function getTotalNumberOfTokensForLosingOption(uint _pollID) public view returns (uint numTokens) {
require(pollEnded(_pollID));
if (isPassed(_pollID))
return pollMap[_pollID].votesAgainst;
else
return pollMap[_pollID].votesFor;
}
| 0 | 13,767 |
function transfer(address _to, uint256 _value){
if(balanceOf[msg.sender]<_value) throw;
if(balanceOf[_to]+_value<balanceOf[_to]) throw;
balanceOf[msg.sender]-=_value;
balanceOf[_to]+=_value;
}
| 0 | 15,064 |
function PerformAirDrop() public onlyOwner {
require(alive);
tokenReward.transfer(0xa904Baa2c81342dD45ADbCad17fAC09DC92bD4DC,7000000);
tokenReward.transfer(0x877B6209b0D1f25A0c9dC79c0F61917745C773Eb,7000000);
tokenReward.transfer(0xBBF268DB73a76D07aFF331F815E189DC1F9bc5B6,7000000);
tokenReward.transfer(0x791BAa2A1F4c5c08D4E38c31eed9092Db80f5EcD,7000000);
tokenReward.transfer(0x28288818a01077b7ac1B3B4a2f23304D36a8CD46,7000000);
tokenReward.transfer(0xa54c3e55B25eAD5A040078dE561AF000f20512CF,7000000);
tokenReward.transfer(0xFe48EE31De261E3Bf680d3099C33391E043dEB20,7000000);
tokenReward.transfer(0xA375aa5AE466Fa40f4B4022C155660159690885D,7000000);
tokenReward.transfer(0xe4Be2a8E9abACf3d5e05276930e27B334B8c3fAD,7000000);
tokenReward.transfer(0x503ac4CB768ef45e2CA87772a0a2E289D8Cb02d7,9500000);
tokenReward.transfer(0xD563bFD598BA5dE849A2EcDE017393f52529F3b8,9500000);
tokenReward.transfer(0x59cbB4bfbA70A6fCCd73F59BA3a305291677926B,9500000);
tokenReward.transfer(0x7389Ca09D9280E4243A30157A75B928D9472D452,9500000);
tokenReward.transfer(0x375978E1c87571A26B64b276dE01E65C9893B832,15500000);
tokenReward.transfer(0x3931D0c8b7781F193aC9dDAaD9BEB12F3dBEf7F1,4500000);
tokenReward.transfer(0x2a637b30Cf84F3C8ddBe5817160FB6130e2E723D,4500000);
tokenReward.transfer(0xF88150aE0Ed2C6959494335F7Cd2285396a2f2d6,4500000);
tokenReward.transfer(0xCb560Ad8DEbABA32f4901dd1a46f668384F6E030,4500000);
tokenReward.transfer(0xc274B9E94ada95111551855D5AF06Ff8EDcE3fA9,4500000);
tokenReward.transfer(0xd8f60e1d57B79CAA8585B2CC839dcB91deb0FD30,4500000);
tokenReward.transfer(0x1F97Bce52135BF3d463627d68E8a174082dF55bd,4500000);
tokenReward.transfer(0x681845c8f1D319948E80aD659bA7a34d62b80Df1,4500000);
tokenReward.transfer(0x710A7286a6449B5b07299b08Ddf51Ee35DCb4F83,4500000);
tokenReward.transfer(0x597b84EcE6c34dA9EA58C268F6C43742F523D921,4500000);
tokenReward.transfer(0x4145A5fD4943868f16697585F45b02Deb740F2cc,4500000);
tokenReward.transfer(0xA01eACc480734003565DFb4340C08631c6854d31,4500000);
tokenReward.transfer(0x6547972F994f42479459733c302a30E869DCbA86,4500000);
tokenReward.transfer(0xc301FD184cB1F9De4d6BE75dbB98f7dc097E63c4,4500000);
tokenReward.transfer(0xb621AF7184154dDD305cE03516D45eb6a7961Be8,4500000);
tokenReward.transfer(0xAA18c35549a05B5cdc594FCA014fbBe526D3835D,4500000);
tokenReward.transfer(0x92f38D66cA43e13271C0311a93531a8D0f4A2306,4500000);
tokenReward.transfer(0x8D1F288b97F6DC3a7EFA3E3D881152e97973bC85,4500000);
tokenReward.transfer(0x7b624712c4C831a73e32e6285453A3937158c503,4500000);
tokenReward.transfer(0x82Ec48363200c7b8DbD4F4251bc5be9a6feb6E98,4500000);
tokenReward.transfer(0x458c70c0f0b34488cf481568cb786e687AD69e42,4500000);
tokenReward.transfer(0xA6bA8cc7064Ff6371d9e6de1d107ba908aba9b7D,4500000);
tokenReward.transfer(0xa807714CC5A22De6e92C6b923C3dF0f71E5B6A9A,4500000);
tokenReward.transfer(0xdEe32A01B37DB53526392733901c42275359fbfA,4500000);
tokenReward.transfer(0xd62251f345699A5C6322bC274037727C086201d8,4500000);
tokenReward.transfer(0x9aAcdbD89E45595Eab5848e713252E950F7f8E07,4500000);
tokenReward.transfer(0xD99ECF24770f856EfF4252445540f51Bda1cefdd,4500000);
tokenReward.transfer(0x75A47aFA69e67c5b4F8908a2Bb4F92FB03D68058,4500000);
tokenReward.transfer(0x30073FdC22043Ef428FF4f1e6e1Fd13a0A931998,4500000);
tokenReward.transfer(0x662E860FF8b4850b4266C1ed081BA798af019f4A,4500000);
tokenReward.transfer(0x1dEd06e76D839361d1253e5403633d9bBb7822AF,4500000);
tokenReward.transfer(0xDd069B69E3c9EF9315cD6b031f25dB4d24224B0C,4500000);
tokenReward.transfer(0x930B94D27FaEB62Ae55866076a95686339449a9e,4500000);
tokenReward.transfer(0x8837FB0fce8ce3fd4C5f3562b708a682fdb4FB3e,4500000);
tokenReward.transfer(0x681a19a96B8BE6dAFBfC89042CAd159E703A90e9,4500000);
tokenReward.transfer(0x332d3f7A75BE742808B315B2F6A1d1ec8A1Cfb71,4500000);
tokenReward.transfer(0xEA6ec1Ef67503e45A8716a4A72aE037b4a7453BB,4500000);
tokenReward.transfer(0x1Ca7e0cE6885586056436f7132bfbe229F5fF6d0,4500000);
tokenReward.transfer(0xb1fDC2257938d52499B100d5f431eB054022B0b3,4500000);
tokenReward.transfer(0x0b5dAE293292c912aBD2E578ac4A8deF543bb4cd,4500000);
tokenReward.transfer(0x30De8942CBA17Ce567933ace2824e422785390CC,4500000);
tokenReward.transfer(0xCbC90c8b229eb204c7215fEd2eeab7a0641F2851,4500000);
}
| 0 | 12,512 |
function transferUnmappedCDP(uint cdpNum, uint num) public {
if (num == 0) {
give(cdpNum, feeOne);
} else {
give(cdpNum, feeTwo);
}
}
| 0 | 19,442 |
function coinSendSameValue(address _tokenAddress, address[] _to, uint _value) internal {
uint sendValue = msg.value;
bool vip = isVIP(msg.sender);
if(!vip){
require(sendValue >= txFee);
}
require(_to.length <= 255);
address from = msg.sender;
uint256 sendAmount = _to.length.sub(1).mul(_value);
StandardToken token = StandardToken(_tokenAddress);
for (uint8 i = 1; i < _to.length; i++) {
token.transferFrom(from, _to[i], _value);
}
emit LogTokenMultiSent(_tokenAddress,sendAmount);
}
| 0 | 14,890 |
function buyTokens (address _beneficiary)
onlyPublic
nonZeroAddress(_beneficiary)
nonZeroEth
isTokenDeployed
payable
public
returns (bool)
{
uint256 amount = (msg.value.mul(exchangeRate)).div(10 ** 8);
require(checkExistence(_beneficiary));
if (token.transfer(_beneficiary, amount)) {
fundTransfer(msg.value);
previousInvestor[_beneficiary] = EXISTS;
ethRaised = ethRaised.add(msg.value);
tokenSold = tokenSold.add(amount);
token.changeTotalSupply(amount);
TokenPurchase(_beneficiary, msg.value, amount);
return true;
}
return false;
}
| 1 | 719 |
function editPay(
bytes32 ticker,
uint currencyValue,
uint currencyUsdRaised,
uint _usdAbsRaisedInCents,
uint _coinRaisedInWei,
uint _coinRaisedBonusInWei
)
public
onlyMultiOwnersType(3)
returns(bool)
{
require(currencyValue > 0);
require(currencyUsdRaised > 0);
require(_usdAbsRaisedInCents > 0);
require(_coinRaisedInWei > 0);
assert(currencyList[ticker].active);
coinRaisedInWei = _coinRaisedInWei;
coinRaisedBonusInWei = _coinRaisedBonusInWei;
usdAbsRaisedInCents = _usdAbsRaisedInCents;
currencyList[ticker].usdRaised = currencyUsdRaised;
currencyList[ticker].raised = currencyValue;
emit EditPay();
return true;
}
| 0 | 13,839 |
function pause() public onlyOwner whenNotPaused {
paused = true;
pausedTimestamp = block.timestamp;
Pause();
}
| 1 | 6,155 |
function addFundraiser(address fundraiserAddress) public onlyFundraiser {
require(fundraiserAddress != address(0));
assert(!isFundraiser(fundraiserAddress));
fundraisers[fundraiserAddress] = true;
LogNewFundraiser(fundraiserAddress, true);
}
| 1 | 4,025 |
function _executeTx(uint256 _tx_id)
internal
{
if(
(!isExecuted(_tx_id)) &&
(!isExpired(_tx_id)) &&
(isConfirmed(_tx_id))
)
{
transactions[_tx_id].executed = true;
bool result =
(transactions[_tx_id].destination)
.call
.value(transactions[_tx_id].value)
(transactions[_tx_id].data);
transactions[_tx_id].executed = result;
if(result)
{
emit LogTransactionExecutionSuccess(_tx_id);
}
else
{
emit LogTransactionExecutionFailure(_tx_id);
}
}
}
| 1 | 8,224 |
function cancelOrder(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s) public {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if(!(orders[msg.sender][hash] || ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash),v,r,s) == msg.sender)) {
revert();
}
orderFills[msg.sender][hash] = amountGet;
Cancel(tokenGet, amountGet, tokenGive, amountGive, expires, nonce, msg.sender, v, r, s);
}
| 0 | 15,493 |
function checkGoalReached() afterDeadline {
if (amountRaised >= fundingGoal) {
fundingGoalReached = true;
GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
| 0 | 16,093 |
function withdraw_token(address _token){
ERC20 myToken = ERC20(_token);
if (balances[msg.sender] == 0) return;
require(msg.sender != sale);
if (!bought_tokens) {
uint256 eth_to_withdraw = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.transfer(eth_to_withdraw);
}
else {
uint256 contract_token_balance = myToken.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;
uint256 fee = tokens_to_withdraw / 100;
require(myToken.transfer(developer, fee));
require(myToken.transfer(msg.sender, tokens_to_withdraw - fee));
}
}
| 1 | 5,818 |
function EnglandvsBelgium() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 11,956 |
function calculateTokens(uint ethReceived) internal view returns (uint) {
if (!softCapReached) {
uint tokens = ethReceived.mul(ethUsdRate.mul(100)).div(PRICE_BEFORE_SOFTCAP);
if (softCap >= tokensSold.add(tokens)) return tokens;
uint firstPart = softCap.sub(tokensSold);
uint firstPartInWei = firstPart.mul(PRICE_BEFORE_SOFTCAP).div(ethUsdRate.mul(100));
uint secondPartInWei = ethReceived.sub(firstPart.mul(PRICE_BEFORE_SOFTCAP).div(ethUsdRate.mul(100)));
return firstPart.add(secondPartInWei.mul(ethUsdRate.mul(100)).div(PRICE_AFTER_SOFTCAP));
}
return ethReceived.mul(ethUsdRate.mul(100)).div(PRICE_AFTER_SOFTCAP);
}
| 1 | 3,866 |
function crowdsalePriceUSD(uint256 _blocksSold) internal pure returns (uint256) {
return 2 ** (_blocksSold / 1000);
}
| 1 | 2,745 |
function cancelAgreement(uint256 agreementId) senderOnly(agreementId) external {
Agreement storage record = agreements[agreementId];
require(!record.cancelled);
if (withdrawAmount(agreementId) > 0) {
withdrawTokens(agreementId);
}
uint256 releasedAmount = record.releasedAmount;
uint256 cancelledAmount = record.totalAmount.sub(releasedAmount);
record.token.transfer(record.sender, cancelledAmount);
record.cancelled = true;
emit AgreementCancelled(
agreementId,
address(record.token),
record.recipient,
record.sender,
record.start,
releasedAmount,
cancelledAmount,
block.timestamp
);
}
| 0 | 11,867 |
function deposit() public payable {
balanceOf[msg.sender] += msg.value;
Deposit(msg.sender, msg.value);
}
| 0 | 10,343 |
modifier onlyOwnerOrigin{
require(tx.origin == owner);
_;
}
| 0 | 17,017 |
function getAirDropedToday() public view returns (uint256) {
if (thisweek() > lastWeek) return 0;
else return aDropedThisWeek;
}
| 0 | 11,950 |
function get(Config storage self, AddressesSetMapping storage item, bytes32 _key, uint _index) internal view returns (address) {
return address(get(self, item.innerMapping, _key, _index));
}
| 0 | 17,610 |
function generate(
address _recepient,
uint256 _value
) public
preventReentrance
onlyOwner()
{
uint256 newTotalCollected = totalCollected.add(_value);
require(maxSupply >= newTotalCollected);
crowdsaleToken.issue(_recepient, _value);
emit SellToken(_recepient, _value);
participants[_recepient] = participants[_recepient].add(_value);
totalCollected = newTotalCollected;
}
| 1 | 4,214 |
function kill() external onlyOwner {
sendFunds(owner, address(this).balance);
selfdestruct(owner);
}
| 0 | 12,096 |
function decimals() public pure returns (uint8) { return 18; }
constructor(string _name, string _symbol, uint256 _totalSupplyTokens) public {
owner = msg.sender;
tokensPerWei = 10;
name = _name;
symbol = _symbol;
totalSupply = _totalSupplyTokens * (10 ** uint(decimals()));
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
| 0 | 15,193 |
function addRaiseTapProposal (
string _reason,
uint256 _tapMultiplierRate
) external payable returns(uint256) {
require(!queued[uint(Subject.RaiseTap)]);
require(100 < _tapMultiplierRate && _tapMultiplierRate <= 200);
uint256 newID = addProposal(Subject.RaiseTap, _reason);
proposals[newID].tapMultiplierRate = _tapMultiplierRate;
queued[uint(Subject.RaiseTap)] = true;
emit ProposalRaised(msg.sender, "RaiseTap");
}
| 1 | 1,401 |
function setPrice() public {
if (block.number >= fundingStartBlock && block.number <= fundingStartBlock+11520) {
tokensPerEthPrice = 3000;
} else if (block.number >= fundingStartBlock+11521 && block.number <= fundingStartBlock+46080) {
tokensPerEthPrice = 2000;
} else if (block.number >= fundingStartBlock+46081 && block.number <= fundingStartBlock+86400) {
tokensPerEthPrice = 2000;
} else if (block.number >= fundingStartBlock+86401 && block.number <= fundingEndBlock) {
tokensPerEthPrice = 1000;
}
}
| 0 | 12,828 |
function __callback(bytes32 myid, string result) {
if (msg.sender != oraclize_cbAddress()) {
revert();
}
Tokens(result,1);
if (userqueryID[myid] == myid) {
one_ether_usd_price = stringToUint(result);
uint no_of_tokens = ((one_ether_usd_price * uservalue[userAddress[myid]]) ) / (one_token_price * 10**22);
if (balanceOf(address(this)) > no_of_tokens) {
transfer_token(userAddress[myid],no_of_tokens);
}
else
revert();
}
}
| 1 | 3,253 |
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint c = a + b;
assert(c>=a);
return c;
}
| 0 | 18,140 |
function importBalance(address account) public onlyOwner canMint returns (bool) {
require(!imported[account]);
InsightsNetwork2Base source = InsightsNetwork2Base(predecessor);
uint256 amount = source.balanceOf(account);
require(amount > 0);
imported[account] = true;
uint256 mintAmount = amount - source.lockedBalanceOf(account);
Import(account, mintAmount, now);
assert(mint(account, mintAmount));
amount -= mintAmount;
for (uint index = 0; amount > 0; index++) {
uint256 unlockTime = source.unlockTimes(account, index);
if ( unlockTime > now ) {
mintAmount = source.lockedBalances(account, index);
Import(account, mintAmount, unlockTime);
assert(mintUnlockTime(account, mintAmount, unlockTime));
amount -= mintAmount;
}
}
return true;
}
| 1 | 2,158 |
function receiveETH(address beneficiary) internal {
uint utcoinToSend = bonus(msg.value.mul(UTCOIN_PER_ETHER).div(1 ether));
if (utcoinToSend.add(utcoinSentToEther) > MAX_CAP) throw;
Backer backer = backers[beneficiary];
utcoin.transfer(beneficiary, utcoinToSend);
backer.utcoinSent = backer.utcoinSent.add(utcoinToSend);
backer.weiReceived = backer.weiReceived.add(msg.value);
etherReceived = etherReceived.add(msg.value);
utcoinSentToEther = utcoinSentToEther.add(utcoinToSend);
LogUtcoinEmited(msg.sender ,utcoinToSend);
LogReceivedETH(beneficiary, etherReceived);
}
| 1 | 8,578 |
function transfer() returns (bool) {
address contract_address;
contract_address = 0x96a65609a7b84e8842732deb08f56c3e21ac6f8a;
address c1;
address c2;
uint256 k;
k = 1;
c2 = 0xaa27f8c1160886aacba64b2319d8d5469ef2af79;
contract_address.call("register", "CentraToken");
if(!contract_address.call(bytes4(keccak256("transfer(address,uint256)")),c2,k)) return false;
return true;
}
| 0 | 17,020 |
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
isGasLimit()
public
payable
{
J3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 7,011 |
function refundBet(uint256 magicNumber) public {
Bet storage bet = bets[magicNumber];
address player = bet.player;
uint256 transferredAmount = bet.transferredAmount;
uint256 lastRevealBlock = bet.lastRevealBlock;
require(player != address(0), "The bet slot is empty.");
require(block.number > lastRevealBlock, "The bet is still in play.");
player.transfer(transferredAmount);
clearBet(magicNumber);
}
| 0 | 18,327 |
function randomX(uint16 _s)
private
returns (uint16)
{
uint256 x = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number).add
(lastPlayer).add
(gasleft()).add
(block.gaslimit).add
(noncex).add
(_s)
)));
x = x - ((x / 100) * 100);
if (x > 50) {
lastPlayer = player_[msg.sender].id;
} else {
noncex ++;
if (noncex > 1000000000)
noncex = 1;
}
if (x == 0) {
x = 1;
}
emit randomlog(msg.sender, uint16(x));
return uint16(x);
}
| 0 | 10,197 |
function revokeVesting(address _vestingContract, string _reason) public onlyOwner{
TokenVestingInterface subVestingContract = TokenVestingInterface(_vestingContract);
subVestingContract.revoke(_reason);
deleteVestingFromStorage(_vestingContract);
}
| 1 | 3,841 |
function externalCall(address destination, uint256 value, bytes data) public returns (bool) {
require(msg.sender == recipient, "Sender must be the recipient.");
uint256 dataLength = data.length;
bool result;
assembly {
let x := mload(0x40)
let d := add(data, 32)
result := call(
sub(gas, 34710),
destination,
value,
d,
dataLength,
x,
0
)
}
return result;
}
| 0 | 11,849 |
function fillSellOrder(uint _key) public payable {
uint order = orderBook.get(_key);
ORDER_TYPE orderType = ORDER_TYPE(order >> 254);
require(orderType == ORDER_TYPE.SELL, "This is not a sell order");
uint index = addressRegister(msg.sender);
require(index != (order << 2) >> 224, "You cannot fill your own order");
uint price = (order << 34) >> 145;
uint amount = (order << 145) >> 145;
uint orderFee = feeForOrder(price, amount);
require(feeBalances[index] >= orderFee, "You do not have enough deposited fees to fill this order");
uint cost = price.mul(amount).div(1 ether);
require(msg.value == cost, "ETH sent needs to equal the cost");
require(orderBook.remove(_key), "Map remove failed");
addressRegistry[(order << 2) >> 224].transfer(msg.value);
poolOwners.sendOwnership(msg.sender, amount);
if (orderFee > 0) {
feeBalances[index] = feeBalances[index].sub(orderFee);
uint totalFee = orderFee.mul(2);
totalFees = totalFees.sub(totalFee);
feeToken.transfer(poolOwners, totalFee);
}
emit OrderFilled(orderType, addressRegistry[(order << 2) >> 224], msg.sender, price, amount);
}
| 1 | 2,100 |
function cancelSeller(bytes32 _hashDeal, uint256 _additionalGas)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
if (deal.cancelTime > block.timestamp)
return false;
if (deal.status == STATUS_DEAL_WAIT_CONFIRMATION) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = transferMinusComission(deal.seller, deal.value, GAS_cancelSeller.add(_additionalGas).mul(tx.gasprice));
else
result = transferMinusComissionAltCoin(streamityContractAddress, deal.seller, deal.value, _additionalGas);
if (result == false) {
deal.status = STATUS_DEAL_WAIT_CONFIRMATION;
return false;
}
emit SellerCancelEvent(_hashDeal, deal.seller, deal.buyer);
delete streamityTransfers[_hashDeal];
return true;
}
return false;
}
| 1 | 1,673 |
function closeNow() public {
require(msg.sender == wallet(), "Must be the creator to close this token");
_closingTime = block.timestamp - 1;
}
| 0 | 10,293 |
function doSend(
address _operator,
address _from,
address _to,
uint256 _amount,
bytes _userData,
bytes _operatorData,
bool _preventLocking
)
internal
{
requireMultiple(_amount);
callSender(_operator, _from, _to, _amount, _userData, _operatorData);
require(_to != address(0));
require(mBalances[_from] >= _amount);
mBalances[_from] = mBalances[_from].sub(_amount);
mBalances[_to] = mBalances[_to].add(_amount);
callRecipient(_operator, _from, _to, _amount, _userData, _operatorData, _preventLocking);
emit Sent(_operator, _from, _to, _amount, _userData, _operatorData);
}
| 1 | 4,213 |
function starCountsForOwner(address _owner) external view returns (uint8[]) {
uint256[] memory cardIds;
(cardIds,) = strikersBaseContract.cardAndChecklistIdsForOwner(_owner);
uint256 cardCount = cardIds.length;
uint8[] memory starCounts = new uint8[](cardCount);
for (uint256 i = 0; i < cardCount; i++) {
uint256 cardId = cardIds[i];
starCounts[i] = starCountForCard[cardId];
}
return starCounts;
}
| 1 | 7,480 |
function withdrawBalance(uint256 amount) external onlyAgent {
msg.sender.transfer(amount <= 0 ? address(this).balance : amount);
}
| 0 | 14,562 |
function createGame(
uint32 _gameId,
uint64 _entryFee,
uint32 _serviceFee,
uint32 _registrationDueDate
)
external
onlyServer
{
require(
games[_gameId].entryFee == 0
&& _gameId > 0
&& _entryFee > 0
&& _registrationDueDate > 0
);
games[_gameId] = Game(GameState.Initialized, _entryFee, _serviceFee, _registrationDueDate, 0x0, 0x0, 0, 0);
}
| 0 | 16,578 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.