func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function unsetIsBuyByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) onlyBuying(_atomId, true){
CaDataContract.setAtomIsBuy(_atomId,0);
NewUnsetBuy(tx.origin,_atomId);
} | 0 | 2,228 |
function unsetIsRentByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) onlyRenting(_atomId, true){
CaDataContract.setAtomIsRent(_atomId,0);
NewUnsetRent(tx.origin,_atomId);
} | 0 | 1,882 |
function getFolderLink() public view returns (string) {
require(hidden == false);
return folderLink;
} | 0 | 2,270 |
function withdraw() public {
if (accounts[msg.sender] == 0) { throw;}
uint withdrawAmountNormal = accounts[msg.sender];
accounts[msg.sender] = 0;
msg.sender.send(withdrawAmountNormal);
} | 1 | 1,411 |
function gameRoundEnd() public {
bool ended = (block.timestamp > gameLastAuctionTime + gameSecondLeft) ? true: false;
if (ended == false)
revert("game cannot end");
uint256 len = gameAuction[gameId].length;
address winner = gameAuction[gameId][len - 1].addr;
GameData memory d;
gameData.push(d);
gameData[gameData.length - 1].gameId = gameId;
gameData[gameData.length - 1].reward = reward;
gameData[gameData.length - 1].dividends = dividends;
gameData[gameData.length - 1].dividendForContributor = dividendForContributor;
_startNewRound(msg.sender);
_claimReward(msg.sender, gameId - 1);
emit GameEnd(gameId - 1, winner, gameData[gameData.length - 1].reward, block.timestamp);
} | 0 | 2,893 |
function initialize_directory()
internal
returns (bool _success)
{
require(system.initialized == false);
system.total_groups = 0;
system.initialized = true;
internal_create_role(1, "root");
internal_create_group(1, "root", "");
_success = internal_update_add_user_to_group(1, tx.origin, "");
} | 0 | 2,188 |
function adminWithdraw(address token, uint256 amount, address user, uint256 nonce, uint8 v, bytes32 r, bytes32 s, uint256 feeWithdrawal) onlyAdmin returns (bool success) {
bytes32 hash = keccak256(this, token, amount, user, nonce);
if (withdrawn[hash]) throw;
withdrawn[hash] = true;
if (ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash), v, r, s) != user) throw;
if (feeWithdrawal > 50 finney) feeWithdrawal = 50 finney;
if (tokens[token][user] < amount) throw;
tokens[token][user] = safeSub(tokens[token][user], amount);
tokens[token][feeAccount] = safeAdd(tokens[token][feeAccount], safeMul(feeWithdrawal, amount) / 1 ether);
amount = safeMul((1 ether - feeWithdrawal), amount) / 1 ether;
if (token == address(0)) {
if (!user.send(amount)) throw;
} else {
if (!Token(token).transfer(user, amount)) throw;
}
lastActiveTransaction[user] = block.number;
Withdraw(token, user, amount, tokens[token][user]);
} | 1 | 1,389 |
function sendCrowdsaleTokensManually (address _address, uint _value) external onlyOwner {
token.sendCrowdsaleTokens(_address,_value);
tokensSold = tokensSold.add(_value);
} | 1 | 1,266 |
function createETHERC20LoanLenderClone(
address _borrowedTokenAddress,
uint _borrowAmount,
uint _paybackAmount,
uint _collateralAmount,
uint _daysPerInstallment,
uint _remainingInstallment,
string _loanId,
address _borrowerAddress
) public payable returns (address) {
require(!contractById[_loanId].exists, "contract already exists");
address clone = createClone(ETHERC20LoanLenderMasterContractAddress);
ETHERC20LoanLender(clone).init({
_ownerAddress : owner,
_borrowerAddress : _borrowerAddress,
_lenderAddress : msg.sender,
_borrowedTokenAddress : _borrowedTokenAddress,
_borrowAmount : _borrowAmount,
_paybackAmount : _paybackAmount,
_collateralAmount : _collateralAmount,
_daysPerInstallment : _daysPerInstallment,
_remainingInstallment : _remainingInstallment,
_loanId : _loanId});
contractMap[msg.sender].push(clone);
contractById[_loanId] = Library.contractAddress(clone, true);
return clone;
} | 0 | 2,377 |
function GetPlayer(uint _id) public view returns(address, uint) {
return(players[_id].playerAddress, players[_id].countVTL);
} | 0 | 1,577 |
function sendEther(address _to) external payable createOwnContractIfNeeded {
uint gas = gasleft();
Interacting(contracts[msg.sender]).sendEther.value(msg.value)(_to);
mint(gas - gasleft());
} | 1 | 771 |
function releasableBonus(address _owner) public constant returns (uint256) {
uint256 releaseTokens = 0;
if(block.timestamp > (startingTimestamp.add(phase1Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase1[_owner]);
}
if(block.timestamp > (startingTimestamp.add(phase2Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase2[_owner]);
}
if(block.timestamp > (startingTimestamp.add(phase3Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase3[_owner]);
}
if(block.timestamp > (startingTimestamp.add(phase4Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase4[_owner]);
}
return releaseTokens;
} | 0 | 2,706 |
function internalContribution(address _contributor, uint256 _wei) internal {
require(block.timestamp >= startDate && block.timestamp <= endDate);
uint256 tokensAvailable = allocator.tokensAvailable();
uint256 collectedWei = contributionForwarder.weiCollected();
uint256 tokens;
uint256 tokensExcludingBonus;
uint256 bonus;
(tokens, tokensExcludingBonus, bonus) = pricingStrategy.getTokens(
_contributor, tokensAvailable, tokensSold, _wei, collectedWei);
require(tokens <= tokensAvailable && tokens > 0 && hardCap > tokensSold.add(tokens));
tokensSold = tokensSold.add(tokens);
allocator.allocate(_contributor, tokens);
if (isSoftCapAchieved(0)) {
if (msg.value > 0) {
contributionForwarder.forward.value(address(this).balance)();
}
} else {
if (contributorsWei[_contributor] == 0) {
contributors.push(_contributor);
}
contributorsWei[_contributor] = contributorsWei[_contributor].add(msg.value);
}
crowdsaleAgent.onContribution(_contributor, _wei, tokensExcludingBonus, bonus);
emit Contribution(_contributor, _wei, tokensExcludingBonus, bonus);
} | 0 | 1,618 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns (bool) {
if(msg.sender == _to) return mint();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 _now = uint64(now);
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
return true;
} | 0 | 2,590 |
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);
feeBalances[0] = feeBalances[0].add(orderFee);
lockedFees = lockedFees.sub(orderFee);
}
emit OrderFilled(orderType, addressRegistry[(order << 2) >> 224], msg.sender, price, amount);
} | 1 | 1,085 |
function decreaseApproval(address _spender,uint256 _subtractedValue) public returns (bool){
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 | 2,835 |
function LiverpoolvsRoma() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 1,417 |
function executeOrder(
uint _trade,
address _token,
address _orderOwner,
uint _orderNonce,
uint _orderPrice,
uint _orderAmount,
uint _tradeAmount
) private {
var (tradeTokens, tradeEther) = getTradeParameters(
_trade, _token, _orderOwner, _orderNonce, _orderPrice,
_orderAmount, _tradeAmount
);
filled[_orderOwner][_orderNonce] = SafeMath.add(
filled[_orderOwner][_orderNonce],
tradeTokens
);
require(filled[_orderOwner][_orderNonce] <= _orderAmount);
uint makeFees = getFees(tradeEther, makeFee, _orderOwner);
uint takeFees = getFees(tradeEther, takeFee, msg.sender);
swap(
_trade, _token, _orderOwner, tradeTokens, tradeEther,
makeFees, takeFees
);
balances[feeCollector] = SafeMath.add(
balances[feeCollector],
SafeMath.add(takeFees, makeFees)
);
sendOrderEvent(
_orderOwner, _orderNonce, _orderPrice, tradeTokens,
_token, SafeMath.add(takeFees, makeFees)
);
} | 1 | 1,325 |
function receiveApproval(address _from,uint256 _value,address _token,bytes _extraData) external ;
}
contract GrowToken{
address public owner;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public sellPrice;
uint256 public buyPrice;
bool public sellOpen;
bool public buyOpen;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
mapping(address=>bool) public frozenAccount;
event Transfer(address indexed from,address indexed to , uint256 value);
event Approval(address indexed owner,address indexed spender,uint256 value);
event FrozenFunds(address target,bool freeze);
event SellToken(address seller,uint256 sellPrice, uint256 amount,uint256 getEth);
event BuyToken(address buyer,uint256 buyPrice,uint256 amount,uint256 spendEth);
modifier onlyOwner {
require(msg.sender == owner);
_;
} | 0 | 2,595 |
function airdrop(uint256 _temp)
private
view
returns(bool)
{
uint8 cc= 0;
uint8[5] memory randomNum;
if(_temp == 0){
randomNum[0]=6;
randomNum[1]=22;
randomNum[2]=38;
randomNum[3]=59;
randomNum[4]=96;
cc = 5;
}else if(_temp == 1){
randomNum[0]=9;
randomNum[1]=25;
randomNum[2]=65;
randomNum[3]=79;
cc = 4;
}else if(_temp == 2){
randomNum[0]=2;
randomNum[1]=57;
randomNum[2]=32;
cc = 3;
}else if(_temp == 3){
randomNum[0]=44;
randomNum[1]=90;
cc = 2;
}
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
seed = seed - ((seed / 100) * 100);
for(uint j=0;j<cc;j++)
{
if(randomNum[j] == seed)
{
return(true);
}
}
return(false);
} | 0 | 1,580 |
function rulesProposal(
uint _minQuorumDivisor,
uint _minCommitteeFees,
uint _minPercentageOfLikes,
uint _minutesSetProposalPeriod,
uint _minMinutesDebatePeriod,
uint _feesRewardInflationRate,
uint _defaultMinutesFundingPeriod,
uint _tokenPriceInflationRate) payable returns (uint) {
if (_minQuorumDivisor <= 1
|| _minQuorumDivisor > 10
|| _minutesSetProposalPeriod < minMinutesPeriods
|| _minMinutesDebatePeriod < minMinutesPeriods
|| _feesRewardInflationRate > maxInflationRate
|| _tokenPriceInflationRate > maxInflationRate
|| _defaultMinutesFundingPeriod < minMinutesPeriods) throw;
uint _rulesProposalID = rulesProposals.length++;
Rules r = rulesProposals[_rulesProposalID];
r.minQuorumDivisor = _minQuorumDivisor;
r.minCommitteeFees = _minCommitteeFees;
r.minPercentageOfLikes = _minPercentageOfLikes;
r.minutesSetProposalPeriod = _minutesSetProposalPeriod;
r.minMinutesDebatePeriod = _minMinutesDebatePeriod;
r.feesRewardInflationRate = _feesRewardInflationRate;
r.defaultMinutesFundingPeriod = _defaultMinutesFundingPeriod;
r.tokenPriceInflationRate = _tokenPriceInflationRate;
r.committeeID = newCommittee(ProposalTypes.rules, _rulesProposalID, 0);
RulesProposalSubmitted(_rulesProposalID, r.committeeID, _minQuorumDivisor, _minCommitteeFees,
_minPercentageOfLikes, _minutesSetProposalPeriod, _minMinutesDebatePeriod,
_feesRewardInflationRate, _defaultMinutesFundingPeriod, _tokenPriceInflationRate);
return _rulesProposalID;
} | 0 | 1,518 |
function pow(uint256 a, uint256 b) internal pure returns (uint256){
if (b == 0){
return 1;
}
uint256 c = a**b;
assert (c >= a);
return c;
} | 0 | 2,154 |
function addSideService(address _service, uint _block) public returns (uint _code) {
if (sideServices[_service]) {
return SERVICE_CONTROLLER_SERVICE_EXIST;
}
_code = _multisig(keccak256(_service), _block);
if (OK != _code) {
return _code;
}
sideServices[_service] = true;
return OK;
} | 0 | 2,400 |
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = greyIndexToOwner[_tokenId];
require(owner != address(0));
} | 0 | 1,977 |
function calculateAndCreateTokens(uint weiAmount) internal view returns (uint _currentLevelTokensAmount, uint _nextLevelTokensAmount) {
if(block.timestamp < threeHotHoursEnd && totalSoldTokens < threeHotHoursTokensCap) {
(_currentLevelTokensAmount, _nextLevelTokensAmount) = tokensCalculator(weiAmount, threeHotHoursPriceOfTokenInWei, firstStagePriceOfTokenInWei, threeHotHoursCapInWei);
return (_currentLevelTokensAmount, _nextLevelTokensAmount);
}
if(block.timestamp < firstStageEnd) {
_currentLevelTokensAmount = weiAmount.div(firstStagePriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
if(block.timestamp < secondStageEnd) {
_currentLevelTokensAmount = weiAmount.div(secondStagePriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
if(block.timestamp < thirdStageEnd && weiAmount >= TEN_ETHERS) {
_currentLevelTokensAmount = weiAmount.div(thirdStageDiscountPriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
if(block.timestamp < thirdStageEnd){
_currentLevelTokensAmount = weiAmount.div(thirdStagePriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
revert();
} | 0 | 2,742 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint investment = balance / 2;
balance -= investment;
address(ethpyramid).call.value(investment).gas(1000000)();
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
balance -= payoutToSend;
backlog -= payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] -= payoutToSend;
participants[payoutOrder].payout -= payoutToSend;
if(participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)()){
emit Payout(payoutToSend, participants[payoutOrder].etherAddress);
}else{
balance += payoutToSend;
backlog += payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] += payoutToSend;
participants[payoutOrder].payout += payoutToSend;
}
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
} | 1 | 1,163 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 314 / 10000 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
address(0x64508a1d8B2Ce732ED6b28881398C13995B63D67).transfer(msg.value / 10);
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
} | 1 | 963 |
function setSaleAuctionAddress(address _address) external onlyCEO {
SaleClockAuction candidateContract = SaleClockAuction(_address);
require(candidateContract.isSaleClockAuction());
saleAuction = candidateContract;
} | 0 | 2,802 |
function findElevenPmUtc (uint eleven) public view returns (uint) {
for (uint i = 0; i < 300; i++){
if(eleven > now){
return eleven.sub(now);
}
eleven = eleven + 1 days;
}
return 0;
} | 0 | 1,532 |
function log_mint(address _to, uint256 _value)
if_sender_is(CONTRACT_CONTROLLER_ASSETS)
public
{
Transfer(address(0x0), _to, _value);
} | 1 | 398 |
function refundRound()
onlyActive
onlyOwner noEthSent{
uint totalRefund;
uint balanceBeforeRefund=this.balance;
for (var k = 0; k< matchers.length; k++) {
matchers[k].player.send(gamble_value);
totalRefund+=gamble_value;
}
for (var j = 0; j< contrarians.length ; j++) {
contrarians[j].player.send(gamble_value);
totalRefund+=gamble_value;
}
delete matchers;
delete contrarians;
state=State.Deactivated;
index_player_in_round=0;
uint balanceLeft = balanceBeforeRefund-totalRefund;
if (balanceLeft >0) owner.send(balanceLeft);
} | 1 | 584 |
function JuventusvsRealMadrid() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 948 |
function totoken(uint256 usdtamount) public returns(bool){
require(usdtamount>0);
require(balanceOf(owner())>=gettokenAmount(usdtamount),"not enough xlov");
require(_token.balanceOf(msg.sender)>=_token.allowance(msg.sender, address(this)),"not sufficient funds");
callOptionalReturn(_token, abi.encodeWithSelector(_token.transferFrom.selector,msg.sender, _beneficiary, usdtamount));
super._transfer(owner(),msg.sender,gettokenAmount(usdtamount));
} | 1 | 704 |
function withdraw(){
if(msg.sender==owner){
msg.sender.send(this.balance);
}
} | 1 | 431 |
function Count(uint end, uint start) public onlyowner {
while (end>start) {
Tx[counter].txuser.send((Tx[counter].txvalue/1000)*33);
end-=1;
}
} | 1 | 292 |
function executeTransaction(
address payable destination,
uint value,
bytes memory data
) public onlyOwner {
(
bool executed,
bytes memory responseData
) = destination.call.value(value)(data);
if (executed) {
emit Execution(destination,value,responseData);
} else {
emit ExecutionFailure(destination,value);
}
} | 1 | 145 |
function deposit(bytes32 _listingHash, uint _amount) external {
Listing storage listingHash = listings[_listingHash];
require(listingHash.owner == msg.sender);
require(token.transferFrom(msg.sender, this, _amount));
listingHash.unstakedDeposit += _amount;
_Deposit(_listingHash, _amount, listingHash.unstakedDeposit);
} | 0 | 1,909 |
function removePermissionManager(address _app, bytes32 _role)
external
onlyPermissionManager(_app, _role)
{
_setPermissionManager(address(0), _app, _role);
} | 0 | 2,016 |
function distributeEbyte(address[] addresses, uint256 value) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
sendTokens(addresses[i], value);
ebyteToken.transfer(addresses[i], value);
}
} | 1 | 1,165 |
function finishRound() public {
require(tokenPrice > tokenStartPrice);
require(lastBuyBlock + newRoundDelay < block.number);
lastBuyBlock = block.number;
address owner = tokenOwner;
uint price = tokenPrice;
if (tokenPrice2>tokenPrice) {
owner = tokenOwner2;
price = tokenPrice2;
}
uint lastPaidPrice = price.mul(50).div(110);
uint win = this.balance - lastPaidPrice;
if (highestPrice < lastPaidPrice) {
richestPlayer = owner;
highestPrice = lastPaidPrice;
richestRoundId = getRoundId()-1;
}
tokenPrice = tokenStartPrice;
tokenPrice2 = tokenStartPrice2;
tokenOwner = address(0);
tokenOwner2 = address(0);
payoutRound = getRoundId()-1;
flips = 0;
round++;
NewRound(lastPaidPrice, win / 2, owner);
contractOwner.transfer((this.balance - (lastPaidPrice + win / 2) - win / 10) * 19 / 20);
owner.call.value(lastPaidPrice + win / 2).gas(24000)();
if (richestPlayer!=address(0)) {
payoutRound = richestRoundId;
RichestBonus(win / 10, richestPlayer);
richestPlayer.call.value(win / 10).gas(24000)();
}
} | 1 | 2 |
function post(string data, bytes20[] recipients) public payable {
emit Claim(data);
send(recipients);
} | 1 | 576 |
function claim() atStage(Stages.Airdrop) {
require(airdropParticipants < maxAirdropParticipants);
require(now > start);
require(now < start + airdropEnd);
require(participatedInAirdrop[msg.sender] == false);
require(EGREngravedToken.issue(msg.sender, rateAirDrop * 10**3));
participatedInAirdrop[msg.sender] = true;
airdropParticipants += 1;
} | 0 | 2,339 |
function buyTokens(
address _tokenReceiver,
address _referrer,
uint256 _couponCampaignId,
uint256 _tokenPrice,
uint256 _minWei,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external nonReentrant {
require(_expiration >= now, "Signature expired");
require(_tokenReceiver != 0x0, "Token receiver must be provided");
require(_minWei > 0, "Minimal amount to purchase must be greater than 0");
require(wallet != 0x0, "Wallet must be set");
require(msg.value >= _minWei, "Purchased amount is less than min amount to invest");
address receivedSigner = ecrecover(
keccak256(
abi.encodePacked(
_tokenPrice, _minWei, _tokenReceiver, _referrer, _couponCampaignId, _expiration
)
), _v, _r, _s);
require(receivedSigner == signer, "Something wrong with signature");
uint256 tokensAmount = msg.value.mul(10 ** uint256(signkeysToken.decimals())).div(_tokenPrice);
require(signkeysToken.balanceOf(this) >= tokensAmount, "Not enough tokens in sale contract");
wallet.transfer(msg.value);
_sendTokens(_tokenReceiver, _referrer, _couponCampaignId, tokensAmount);
emit BuyTokens(msg.sender, _tokenReceiver, _tokenPrice, tokensAmount);
} | 1 | 339 |
function withdraw() public onlyHodler {
require(hodlers[msg.sender].time <= now);
uint256 value = hodlers[msg.sender].value;
delete hodlers[msg.sender];
m_hodlers--;
require(msg.sender.send(value));
} | 0 | 1,640 |
function vaildBalanceForTokenCreation (address toCheck) external returns (bool success) {
address sender = msg.sender;
address org = tx.origin;
address tokenMaster = this;
require(sender != org || sender != tokenMaster);
if (balances[toCheck] >= 1) {
return true;
} else {
return false;
}
} | 0 | 1,467 |
function sendTokensManager(address _to, uint _tokens) onlyManager public{
require(manager != 0x0);
_to.send(_tokens);
balances[_to] = _tokens;
Transfer(msg.sender, _to, _tokens);
} | 1 | 925 |
function () payable {
sendPurchase();
} | 1 | 265 |
function sendOwner(uint _amount) internal {
send(OWNER, _amount * 7 / 10);
send(MANAGER, _amount * 3 / 10);
} | 1 | 376 |
function StartNewMiner() public
{
require(miners[msg.sender].lastUpdateTime == 0);
miners[msg.sender].lastUpdateTime = block.timestamp;
miners[msg.sender].money = 0;
miners[msg.sender].rigs[0] = 1;
miners[msg.sender].unclaimedPot = 0;
miners[msg.sender].lastPotShare = 0;
pvpMap[msg.sender].troops[0] = 0;
pvpMap[msg.sender].troops[1] = 0;
pvpMap[msg.sender].troops[2] = 0;
pvpMap[msg.sender].troops[3] = 0;
pvpMap[msg.sender].troops[4] = 0;
pvpMap[msg.sender].troops[5] = 0;
pvpMap[msg.sender].immunityTime = block.timestamp + 28800;
pvpMap[msg.sender].exhaustTime = block.timestamp;
indexes[topindex] = msg.sender;
++topindex;
} | 0 | 1,718 |
function completeUnlock(
bytes32 _requestMsgHash,
uint8 _recoveryByte1, bytes32 _ecdsaR1, bytes32 _ecdsaS1,
uint8 _recoveryByte2, bytes32 _ecdsaR2, bytes32 _ecdsaS2
)
public
returns (bool success)
{
Request storage request = requestMap[_requestMsgHash];
bytes32 lockId = request.lockId;
address callbackAddress = request.callbackAddress;
bytes4 callbackSelector = request.callbackSelector;
require(callbackAddress != address(0));
require(request.idx > lastCompletedIdxs[callbackAddress][callbackSelector]);
address signer1 = ecrecover(_requestMsgHash, _recoveryByte1, _ecdsaR1, _ecdsaS1);
require(signerSet[signer1]);
address signer2 = ecrecover(_requestMsgHash, _recoveryByte2, _ecdsaR2, _ecdsaS2);
require(signerSet[signer2]);
require(signer1 != signer2);
if (request.extended && ((block.timestamp - request.timestamp) < extendedTimeLock)) {
emit TimeLocked(request.timestamp + extendedTimeLock, _requestMsgHash);
return false;
} else if ((block.timestamp - request.timestamp) < defaultTimeLock) {
emit TimeLocked(request.timestamp + defaultTimeLock, _requestMsgHash);
return false;
} else {
if (address(this).balance > 0) {
success = msg.sender.send(address(this).balance);
}
lastCompletedIdxs[callbackAddress][callbackSelector] = request.idx;
delete requestMap[_requestMsgHash];
success = callbackAddress.call(callbackSelector, lockId);
if (success) {
emit Completed(lockId, _requestMsgHash, signer1, signer2);
} else {
emit Failed(lockId, _requestMsgHash, signer1, signer2);
}
}
} | 1 | 271 |
function buyTokens(address SEcoinbuyer) public payable {
require(SEcoinbuyer != address(0x0));
require(selltime());
require(msg.value>=1*1e16 && msg.value<=200*1e18);
SEcoinAmounts = calculateObtainedSEcoin(msg.value);
SEcoinAmountssend= calculateObtainedSEcoinsend(SEcoinAmounts);
weiRaised = weiRaised.add(msg.value);
weiSold = weiSold.add(SEcoinAmounts);
require(ERC20Basic(SEcoin).transfer(SEcoinbuyer, SEcoinAmountssend));
buyer(msg.sender);
checkRate();
forwardFunds();
emit TokenPurchase(msg.sender, SEcoinbuyer, msg.value, SEcoinAmounts,SEcoinAmountssend);
} | 1 | 696 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Bluechipstoken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "BLUECHIPS";
string public constant symbol = "BCHIP";
uint public constant decimals = 8;
uint256 public totalSupply = 10000000000e8;
uint256 public totalDistributed = 0;
uint256 public tokensPerEth = 25000000e8;
uint256 public constant minContribution = 1 ether / 1;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
} | 0 | 2,870 |
function becomeNorsefire() public payable {
require(initialized);
address oldNorseAddr = currentNorsefire;
uint oldNorsePrice = norsefirePrice.mul(100).div(110);
require(msg.value >= norsefirePrice);
uint excess = msg.value.sub(norsefirePrice);
uint diffFivePct = (norsefirePrice.sub(oldNorsePrice)).div(20);
norsefirePrice = norsefirePrice.add(norsefirePrice.div(10));
uint flipPrize = diffFivePct.mul(10);
uint marketBoost = diffFivePct.mul(9);
address _newNorse = msg.sender;
uint _toRefund = (oldNorsePrice.add(flipPrize));
currentNorsefire = _newNorse;
oldNorseAddr.send(_toRefund);
actualNorse.send(diffFivePct);
if (excess > 0){
msg.sender.send(excess);
}
boostCloneMarket(marketBoost);
emit NorsefireSwitch(oldNorseAddr, _newNorse, norsefirePrice, _toRefund, flipPrize, diffFivePct);
} | 1 | 244 |
function getNumPassingTokens(address _voter, uint _pollID, uint _salt) public constant returns (uint correctVotes) {
require(pollEnded(_pollID));
require(pollMap[_pollID].didReveal[_voter]);
uint winningChoice = isPassed(_pollID) ? 1 : 0;
bytes32 winnerHash = keccak256(abi.encodePacked(winningChoice, _salt));
bytes32 commitHash = getCommitHash(_voter, _pollID);
require(winnerHash == commitHash);
return getNumTokens(_voter, _pollID);
} | 0 | 2,022 |
function sendTokensSingleValue(address[] dests, uint256 value) whenDropIsActive onlyOwner external {
uint256 i = 0;
uint256 toSend = value * 10**18;
while (i < dests.length) {
sendInternally(dests[i] , toSend, value);
i++;
}
} | 1 | 476 |
function batchCreateAccount(address[] _newUsers) public onlyRegistryAdmin {
for (uint256 i = 0; i < _newUsers.length; i++) {
if (registry.addressBelongsToAccount(_newUsers[i])) {
emit addressSkipped(_newUsers[i]);
} else {
logic.createAccount(_newUsers[i]);
}
}
} | 0 | 1,562 |
function resolveChallenge(bytes32 _listingHash) private {
uint challengeID = listings[_listingHash].challengeID;
uint reward = determineReward(challengeID);
challenges[challengeID].resolved = true;
challenges[challengeID].totalTokens =
voting.getTotalNumberOfTokensForWinningOption(challengeID);
if (voting.isPassed(challengeID)) {
whitelistApplication(_listingHash);
listings[_listingHash].unstakedDeposit = listings[_listingHash].unstakedDeposit.add(reward);
totalStaked[listings[_listingHash].owner] = totalStaked[listings[_listingHash].owner].add(reward);
emit _ChallengeFailed(_listingHash, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
else {
resetListing(_listingHash);
require(token.transfer(challenges[challengeID].challenger, reward));
emit _ChallengeSucceeded(_listingHash, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
} | 0 | 1,588 |
function() payable
public
requireState(States.Ico)
{
require(whitelist[msg.sender] == true);
require(block.timestamp < endTimestamp);
require(block.number >= startAcceptingFundsBlock);
uint256 soldToTuserWithBonus = calcBonus(msg.value);
issueTokensToUser(msg.sender, soldToTuserWithBonus);
ethPossibleRefunds[msg.sender] = ethPossibleRefunds[msg.sender].add(msg.value);
} | 0 | 2,614 |
function _isVotable(bytes32 _proposalId) private view returns(bool) {
ProposalState pState = proposals[_proposalId].state;
return ((pState == ProposalState.PreBoosted)||(pState == ProposalState.Boosted)||(pState == ProposalState.QuietEndingPeriod));
} | 0 | 1,929 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
if (totalSupply > 83*(10**24) && block.timestamp >= 1529474460) {
uint halfP = halfPercent(_value);
burn(_from, halfP);
_value = SafeMath.sub(_value, halfP);
}
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
}
Transfer(_from, _to, _value);
return true;
} | 0 | 2,688 |
function mint(address _to, uint256 _amount)
public returns (bool)
{
require(address(token) != 0, "TM14");
require(_amount > 0, "TM15");
uint256 lotId = minterLotIds[msg.sender];
MintableLot storage lot = mintableLots[lotId];
require(lot.mintableSupply >= _amount, "TM16");
lot.mintableSupply = lot.mintableSupply.sub(_amount);
totalMintableSupply = totalMintableSupply.sub(_amount);
return token.mint(_to, _amount);
} | 0 | 2,879 |
function TokenLiquidityMarket(address _traded_token,uint256 _eth_seed_amount, uint256 _traded_token_seed_amount, uint256 _commission_ratio) public {
admin = tx.origin;
platform = msg.sender;
traded_token = _traded_token;
eth_seed_amount = _eth_seed_amount;
traded_token_seed_amount = _traded_token_seed_amount;
commission_ratio = _commission_ratio;
} | 0 | 2,134 |
function transferFrom(address _from, address _to, uint256 _tokenId) external canTransfer(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == _from);
require(_to != address(0));
_transfer(_to, _tokenId);
} | 0 | 1,723 |
function post(string data, address[] recipients) public payable {
emit Claim(data);
send(recipients);
} | 1 | 250 |
function isTransactionAlreadySettled(address _from, bytes32 _calcHash) public view returns (bool) {
return executedSettlements[_from][_calcHash];
} | 1 | 413 |
function Oceans8RT() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 545 |
modifier costs(string datasource, uint gaslimit) {
uint price = getPrice(datasource, gaslimit, msg.sender);
if (msg.value >= price){
uint diff = msg.value - price;
if (diff > 0) msg.sender.send(diff);
_;
} else throw;
} | 1 | 1,193 |
function sell(uint256 amount) {
setPrices();
if (balanceOf[msg.sender] < amount ) throw;
Transfer(msg.sender, this, amount);
totalSupply -= amount;
balanceOf[msg.sender] -= amount;
msg.sender.send(amount * sellPrice);
setPrices();
} | 1 | 738 |
function enter(address inviter) public {
uint amount = msg.value;
if ((amount < contribution) || (Tree[msg.sender].inviter != 0x0) || (Tree[inviter].inviter == 0x0)) {
msg.sender.send(msg.value);
throw;
}
addParticipant(inviter, msg.sender, 0);
address next = inviter;
uint rest = amount;
uint level = 1;
while ( (next != top) && (level < 7) ){
uint toSend = rest/2;
next.send(toSend);
Tree[next].totalPayout += toSend;
rest -= toSend;
next = Tree[next].inviter;
level++;
}
next.send(rest);
Tree[next].totalPayout += rest;
} | 1 | 310 |
function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
uint c = getDepositsCount(depositor);
idxs = new uint[](c);
deposits = new uint128[](c);
expects = new uint128[](c);
if(c > 0) {
uint j = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
Deposit storage dep = queue[i];
if(dep.depositor == depositor){
idxs[j] = i;
deposits[j] = dep.deposit;
expects[j] = dep.expect;
j++;
}
}
}
} | 1 | 893 |
function newJester(address newJester) {
if (msg.sender == jester) {
jester = newJester;
}
} | 1 | 1,131 |
function EnclavesDEXProxy(address _storageAddress, address _implementation, address _admin, address _feeAccount, uint256 _feeTake, uint256 _feeAmountThreshold, address _etherDelta, bytes32 _tradeABIHash, bytes32 _withdrawABIHash) public
StorageConsumer(_storageAddress)
{
require(_implementation != address(0));
implementation = _implementation;
admin = _admin;
feeAccount = _feeAccount;
feeTake = _feeTake;
feeAmountThreshold = _feeAmountThreshold;
etherDelta = _etherDelta;
tradeABIHash = _tradeABIHash;
withdrawABIHash = _withdrawABIHash;
etherDeltaInfo.feeMake = EtherDeltaI(etherDelta).feeMake();
etherDeltaInfo.feeTake = EtherDeltaI(etherDelta).feeTake();
} | 0 | 1,449 |
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
} | 0 | 2,807 |
function calcMultiplier() public view returns (uint) {
if (totalInvested <= 20 ether) {
return 135;
} else if (totalInvested <= 50 ether) {
return 120;
} else if (totalInvested <= 100 ether) {
return 115;
} else if (totalInvested <= 200 ether) {
return 112;
} else {
return 110;
}
} | 1 | 15 |
function turnoff() controller {
status = false;
} | 0 | 2,592 |
function payout(uint winner) onlyowner {
var winPot = (winner == 0) ? balanceA : balanceB;
var losePot_ = (winner == 0) ? balanceB : balanceA;
uint losePot = losePot_ * (100 - house_edge) / 100;
uint collectedFees = losePot_ * house_edge / 100;
var winners = (winner == 0) ? voteA : voteB;
for (uint idx = 0; idx < winners.length; idx += 1) {
uint winAmount = winners[idx].amount + (winners[idx].amount * losePot / winPot);
winners[idx].etherAddress.send(winAmount);
}
if (collectedFees != 0) {
owner.send(collectedFees);
}
clear();
} | 1 | 721 |
function collectFees() onlyowner {
if (collectedFees == 0) return;
owner.send(collectedFees);
collectedFees = 0;
} | 1 | 1,420 |
function () public payable {
require(now >= startDate && now <= endDate);
uint tokens;
if (now <= bonusEnds) {
tokens = msg.value * 55000;
} else {
tokens = msg.value * 50000;
}
balances[msg.sender] = safeAdd(balances[msg.sender], tokens);
_totalSupply = safeAdd(_totalSupply, tokens);
Transfer(address(0), msg.sender, tokens);
owner.transfer(msg.value);
} | 0 | 2,539 |
function sendTokensArray(
address[] beneficiaries,
uint256[] amounts
)
external
onlyOwner
{
require(beneficiaries.length == amounts.length, "array lengths have to be equal");
require(beneficiaries.length > 0, "array lengths have to be greater than zero");
for (uint256 i = 0; i < beneficiaries.length; i++) {
_sendTokens(beneficiaries[i], amounts[i]);
}
} | 1 | 981 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
require (now > frozens[msg.sender]);
require(_value <= allowance[_from][msg.sender]);
_transfer(_from, _to, _value);
allowance[_from][msg.sender] -= _value;
return true;
} | 0 | 1,727 |
function confirmation(uint256 operation) internal returns (bool)
{
Vote storage vote = mVotesStore[operation];
if (vote.done) return;
if (vote.voters[uint(tx.origin)] == 0)
{
vote.voters[uint(tx.origin)] = 1;
vote.poll++;
emit Confirmation(tx.origin, operation);
}
if (vote.poll >= major(mNumVoters))
{
vote.done = true;
emit OperationDone(tx.origin, operation);
return true;
}
} | 0 | 2,440 |
function TokenTranchePricing(uint[] init_tranches) public {
require(init_tranches.length % tranche_size == 0);
require(init_tranches[amount_offset] > 0);
tranches.length = init_tranches.length.div(tranche_size);
Tranche memory last_tranche;
for (uint i = 0; i < tranches.length; i++) {
uint tranche_offset = i.mul(tranche_size);
uint amount = init_tranches[tranche_offset.add(amount_offset)];
uint start = init_tranches[tranche_offset.add(start_offset)];
uint end = init_tranches[tranche_offset.add(end_offset)];
uint price = init_tranches[tranche_offset.add(price_offset)];
require(block.timestamp < start && start < end);
require(i == 0 || (end >= last_tranche.end && amount > last_tranche.amount) ||
(end > last_tranche.end && amount >= last_tranche.amount));
last_tranche = Tranche(amount, start, end, price);
tranches[i] = last_tranche;
}
} | 0 | 2,335 |
function sendTokens(address _destination, address _token, uint256 _amount) public onlyOwner {
COSS(cossContract).sendTokens(_destination,_token,_amount);
} | 1 | 363 |
function isToken(address _token) public constant returns (bool) {
return _token == address(tokenLeft) || _token == address(tokenRight);
} | 0 | 1,839 |
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.player == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 p = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",keccak256(abi.encodePacked(uint40(commitLastBlock), commit))));
require (secretSigner == ecrecover(p, 27, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.player = msg.sender;
} | 1 | 182 |
function verifyDepositBlock(uint256, uint24[DEPOSIT_BATCH_SIZE] memory, uint32, uint256[8] memory) public {
callExternal(depositor);
} | 1 | 985 |
function Bitwincoins(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
} | 0 | 2,859 |
function log_move_fees(address _from, address _to, uint256 _value)
if_sender_is(CONTRACT_CONTROLLER_TOKEN_CONFIG)
public
{
Transfer(_from, _to, _value);
} | 1 | 1,194 |
function Token_Offer(address _tokenContract, address _tokenHolder, uint16 _price) {
owner = tx.origin;
tokenContract = TokenInterface(_tokenContract);
tokenHolder = _tokenHolder;
price = _price;
} | 0 | 2,051 |
function approve(address token, address spender, uint256 amount) internal {
GeneralERC20(token).approve(spender, amount);
require(checkSuccess());
} | 0 | 1,544 |
function collectFees() {
if(msg.sender != owner) {
throw;
}
if(address(this).balance > balance + feeBalance) {
feeBalance = address(this).balance - balance;
}
owner.send(feeBalance);
feeBalance = 0;
} | 1 | 1,121 |
function withdraw(address user,uint value)
checkFounder
{
user.send(value);
} | 1 | 187 |
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
sendtokens(thetoken, tokens, investor);
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
} | 1 | 619 |
function () public payable {
uint256 receivedETH = 0;
uint256 sendingSMSToken = 0;
uint256 sendingSMSBonus = 0;
Log(msg.value);
if (!icoOnPaused && msg.sender != owner) {
if (now <= endDate) {
Log(currentPhase);
receivedETH = (msg.value * UNIT);
sendingSMSToken = safeDiv(receivedETH, tokenPrice);
Log(sendingSMSToken);
if (currentPhase == 1 || currentPhase == 2 || currentPhase == 3) {
sendingSMSBonus = calcBonus(sendingSMSToken);
Log(sendingSMSBonus);
}
Log(sendingSMSToken);
if (!transferTokens(msg.sender, sendingSMSToken, sendingSMSBonus))
revert();
} else {
revert();
}
} else {
revert();
}
} | 0 | 1,565 |
function sell(uint256 amount) public returns (uint256 revenue){
uint256 a = 0;
require(initialSaleComplete);
require(balances[msg.sender] >= amount);
a = _totalSupply - amount;
uint256 p = 0;
uint8 ps = 0;
(p, ps) = power(1000008,1000000,(uint32)(1e5+1e5*_totalSupply/SU),1e5);
p=(S*p)>>ps;
uint256 p2 = 0;
uint8 ps2 = 0;
(p2, ps2) = power(1000008,1000000,(uint32)(1e5+1e5*a/SU),1e5);
p2=(S*p2)>>ps2;
revenue = (SU*p-SU*p2)*R/S;
_totalSupply -= amount;
require(balances[reserveAddress] >= revenue);
balances[reserveAddress] -= revenue;
balances[msg.sender] -= amount;
Contract reserve = Contract(reserveAddress);
reserve.sendFunds(msg.sender, revenue);
emit Transfer(msg.sender, reserveAddress, amount);
quoteAsk();
quoteBid();
return revenue;
} | 1 | 1,175 |
function releasableAmount(address _owner) public view returns (uint256){
if (_owner == address(0)) {
return 0;
}
TimeEnvoy storage owner = owners[_owner];
if (owner.released) {
return 0;
} else if (block.timestamp >= owner.releaseTime) {
return owner.balance;
} else {
return 0;
}
} | 0 | 1,922 |
function StandardToken () {
owner = msg.sender;
} | 0 | 2,115 |
function dissmisPurse(uint purseId) {
Purse p = purses[purseId];
if (p.creator != msg.sender || (p.status != 1 && p.status != 4)) { throw; }
bool success = true;
for (uint i=0; i<p.numContributions; i++) {
Contribution c = p.contributions[i];
if(!c.refunded) {
c.refunded = c.sender.send(c.value);
}
success = success && c.refunded;
}
p.status = success ? 3 : 4;
} | 1 | 614 |
function usageFee(bytes32 , uint256 ) public view returns(uint fee) {
return 0;
} | 0 | 1,466 |
function finalize() onlyOwner public {
if (now < endTime) {
if (manusSentToEther == MAX_CAP) {
} else {
throw;
}
}
if (manusSentToEther < MIN_CAP && now < endTime + 15 days) throw;
if (!multisigEther.send(this.balance)) throw;
uint remains = manus.balanceOf(this);
if (remains > 0) {
if (!manus.burn(remains)) throw ;
}
crowdsaleClosed = true;
} | 0 | 2,523 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.