func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function setRegistrar(address _newRegistrar) external onlyOwner {
registrar_ = Registrar(_newRegistrar);
}
| 1
| 3,601
|
function getLatestManifestByName(address _registrant, bytes32 _name) public view
returns (address, bytes32, uint256, uint256, bytes32, string, uint256) {
bytes32 registrantNameIndex = keccak256(abi.encodePacked(_registrant, _name));
require(registrantNameManifests[registrantNameIndex].length > 0);
bytes32 manifestId = registrantNameManifests[registrantNameIndex][registrantNameManifests[registrantNameIndex].length - 1];
Manifest memory _manifest = manifests[manifestId];
return (
_manifest.registrant,
_manifest.name,
_manifest.version,
_manifest.index,
_manifest.hashTypeName,
_manifest.checksum,
_manifest.createdOn
);
}
| 0
| 12,826
|
function createLighthouse(
uint256 _minimalFreeze,
uint256 _timeoutBlocks,
string _name
)
external
returns (address lighthouse)
{
bytes32 subnode = keccak256(abi.encodePacked(lighthouseNode, keccak256(_name)));
require(ens.resolver(subnode) == 0);
lighthouse = new Lighthouse(lighthouseLib, _minimalFreeze, _timeoutBlocks);
emit NewLighthouse(lighthouse, _name);
isLighthouse[lighthouse] = true;
ens.setSubnodeOwner(lighthouseNode, keccak256(_name), this);
ens.setResolver(subnode, resolver);
resolver.setAddr(subnode, lighthouse);
}
| 1
| 8,233
|
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
| 15,494
|
function burn(address guy, uint wad) public auth stoppable {
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Burn(guy, wad);
emit Transfer(guy, address(0), wad);
}
| 0
| 11,067
|
function withdrawAllTokens() public onlyOwner{
CrypteloERC20 _tadamerc20;
_tadamerc20 = CrypteloERC20(ERC20Address);
uint totalAmount = _tadamerc20.balanceOf(this);
require(totalAmount > reservedTokens);
uint toWithdraw = totalAmount.sub(reservedTokens);
sendTokens(msg.sender, toWithdraw);
}
| 0
| 14,982
|
function finish() internal {
if (m_finished)
return;
if (getWeiCollected() >= getMinimumFunds()) {
m_funds.changeState(LightFundsRegistry.State.SUCCEEDED);
m_token.ICOSuccess();
}
else {
m_funds.changeState(LightFundsRegistry.State.REFUNDING);
}
m_finished = true;
}
| 1
| 2,923
|
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if(msg.data.length < (3 * 32) + 4) { throw; }
if (_value == 0) { return false; }
uint256 fromBalance = balances[_from];
uint256 allowance = allowed[_from][msg.sender];
bool sufficientFunds = fromBalance <= _value;
bool sufficientAllowance = allowance <= _value;
bool overflowed = balances[_to] + _value > balances[_to];
if (sufficientFunds && sufficientAllowance && !overflowed) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
| 0
| 16,202
|
constructor(address _token) public {
setInterfaceImplementation("ERC777TokensRecipient", this);
address tokenAddress = interfaceAddr(_token, "ERC777Token");
require(tokenAddress != address(0));
token = ERC777Token(tokenAddress);
}
| 1
| 1,064
|
function buyTicket(uint in_amount) public payable {
uint amount = in_amount;
if(in_amount > ticketPool.sub(ticketsBought)){
amount = ticketPool.sub(ticketsBought);
queueAmount[queueLength] = in_amount.sub(amount);
queueAddress[queueLength] = msg.sender;
queueFunds = queueFunds.add((in_amount.sub(amount)).mul(ticketPrice));
queueLength = queueLength.add(1);
}
require(msg.value == (ticketPrice.mul(in_amount)));
require(amount <= ticketPool.sub(ticketsBought));
require(in_amount > 0);
if(amount > 0){
ticketsBought = ticketsBought.add(amount);
buyers[buyerNumber] = msg.sender;
amounts[buyerNumber] = amount;
buyerNumber++;
BuyTickets(address(this), msg.sender, amount);
if(ticketsBought >= ticketPool){
jackpot = jackpot.add(jackpotCut);
token.awardToken(msg.sender, 1);
ledgerCount = 0;
getRandom();
}
token.awardToken(msg.sender, amount);
}
}
| 1
| 5,453
|
constructor(address _base_token, address _traded_token,uint _base_token_seed_amount, uint _traded_token_seed_amount, uint _commission_ratio) public {
admin = tx.origin;
base_token = _base_token;
traded_token = _traded_token;
base_token_seed_amount = _base_token_seed_amount;
traded_token_seed_amount = _traded_token_seed_amount;
commission_ratio = _commission_ratio;
}
| 0
| 12,590
|
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (_to == 0x0) revert();
if (balanceOf[_from] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
if (_value > allowance[_from][msg.sender]) revert();
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
| 0
| 9,877
|
function initialize(address _address) internal returns (bool success) {
if (!initialized[_address]) {
EOSToken token = EOSToken(EOSContract);
uint256 has_eos = token.balanceOf(_address);
if (has_eos > 0) {
initialized[_address] = true;
balances[_address] = _airdropAmount;
}
}
return true;
}
| 1
| 1,771
|
function platformUnfreeze() external{
uint month = 12;
assert(DRC.freezeOf(msg.sender) > 0 );
assert(finishTime > 0);
assert(msg.sender == platform);
uint step = safeSub(block.timestamp, finishTime) / (3600*24*30);
uint256 freeze = DRC.freezeOf(msg.sender);
uint256 unfreezeAmount = 0;
uint256 per = tokensForPlatform / month;
for(uint i = 0 ;i <= step && i < month;i++){
if(unfroze[i][msg.sender] == false){
unfreezeAmount += per;
}
}
require(unfreezeAmount > 0 );
require(unfreezeAmount <= freeze);
DRC.unfreeze(msg.sender,unfreezeAmount);
for(uint j = 0; j <= step && i < month; j++){
unfroze[j][msg.sender] = true;
}
}
| 1
| 7,779
|
function placeTokenBet(uint8 _rotateTime , uint8 _machineMode , uint _commitLastBlock, uint _commit, bytes32 r, bytes32 s, uint _amount, address _playerAddress) external onlySigner {
Bet storage bet = bets[_commit];
require (bet.gambler == address(0));
bytes32 signatureHash = keccak256(abi.encodePacked(_commitLastBlock, _commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s));
require (_rotateTime > 0 && _rotateTime <= 20);
require (_machineMode > 0 && _machineMode <= MAX_MODULO);
require (block.number < _commitLastBlock );
lockedInBets = lockedInBets.add(getPossibleWinPrize(withdrawalMode[_machineMode],_amount));
require (getPossibleWinPrize(withdrawalMode[_machineMode],_amount) <= maxProfit && getPossibleWinPrize(withdrawalMode[_machineMode],_amount) > 0);
require (lockedInBets.add(jackpotSize) <= ERC20(ERC20ContractAddres).balanceOf(address(this)));
require (_amount >= MIN_BET && _amount <= MAX_BET);
emit PlaceBetLog(_playerAddress, _amount, _rotateTime,_commit);
bet.amount = _amount;
bet.placeBlockNumber = uint40(block.number);
bet.gambler = _playerAddress;
bet.machineMode = _machineMode;
bet.rotateTime = _rotateTime;
}
| 1
| 3,989
|
function buyTokens(address contributor) payable stopInEmergency validPurchase public {
uint256 amount;
uint256 odd_ethers;
uint256 ethers;
(amount, odd_ethers) = calcAmountAt(msg.value, block.timestamp, token.totalSupply());
require(contributor != 0x0) ;
require(amount + token.totalSupply() <= mintCapInTokens);
ethers = (msg.value - odd_ethers);
token.mint(contributor, amount);
TokenPurchase(contributor, ethers, amount);
totalETH += ethers;
if(odd_ethers > 0) {
require(odd_ethers < msg.value);
TransferOddEther(contributor, odd_ethers);
contributor.transfer(odd_ethers);
}
wallet.transfer(ethers);
}
| 1
| 8,612
|
function snatch(bytes32 hash) public isHuman() whenNotPaused() {
Info storage info = infos[hash];
require(info.created > 0);
require(info.amount >= info.fill);
require(info.expires >= now);
if (info.limitAddress.length > 0) {
bool find = false;
for (uint i = 0; i < info.limitAddress.length; i++) {
if (info.limitAddress[i] == msg.sender) {
find = true;
break;
}
}
require(find);
}
SnatchInfo[] storage curSnatchInfos = snatchInfos[hash];
require(info.count > curSnatchInfos.length);
for (i = 0; i < curSnatchInfos.length; i++) {
require (curSnatchInfos[i].user != msg.sender);
}
uint per = 0;
if (info.isRandom) {
if (curSnatchInfos.length + 1 == info.count) {
per = info.amount.sub(info.fill);
} else {
require(random != address(0));
per = random.getRandom(hash);
}
} else {
per = info.amount.div(info.count);
}
snatchInfos[hash].push(SnatchInfo(msg.sender, per, now));
if (info.token == address(0)) {
msg.sender.transfer(per);
} else {
if (info.isSpecialERC20) {
SpecialERC20(info.token).transfer(msg.sender, per);
} else {
ERC20(info.token).transfer(msg.sender, per);
}
}
info.fill = info.fill.add(per);
emit Snatch(hash, msg.sender, per, now);
}
| 1
| 6,252
|
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
}
| 1
| 3,865
|
function claim(bytes32 channelId, uint256 payment, bytes signature) public {
require(canClaim(channelId, payment, msg.sender, signature), "canClaim returned false");
PaymentChannel storage channel = channels[channelId];
StandardToken token = StandardToken(channel.tokenContract);
if (payment >= channel.value) {
require(token.transfer(channel.receiver, channel.value), "Unable to transfer token to channel receiver");
} else {
require(token.transfer(channel.receiver, payment), "Unable to transfer token to channel receiver");
uint256 change = channel.value.sub(payment);
require(token.transfer(channel.sender, change), "Unable to transfer token to channel sender");
}
delete channels[channelId];
emit DidClaim(channelId);
}
| 1
| 5,564
|
function sign(string vow1, string name1, string vow2, string name2) public {
require(msg.sender == sealer);
Signage memory signage = Signage(
vow1,
name1,
vow2,
name2
);
signages.push(signage);
numMarriages +=1 ;
}
| 0
| 13,933
|
function updateSellerCanCancelAfter(
bytes32 _tradeHash,
uint32 _paymentWindowInSeconds
) public onlyDexc2c returns(bool){
require(escrows[_tradeHash].exists, "Escrow not exists");
uint32 _sellerCanCancelAfter = uint32(block.timestamp) + _paymentWindowInSeconds;
escrows[_tradeHash].sellerCanCancelAfter = _sellerCanCancelAfter;
emit Updated(_tradeHash, _sellerCanCancelAfter);
return true;
}
| 0
| 11,532
|
function setTokenMinter(address _tokenMinter) public onlyOwner onlyInitialized {
require(_tokenMinter != address(0));
tokenMinter = _tokenMinter;
}
| 1
| 6,173
|
function upgradeTo(string version, address implementation) public onlyProxyOwner {
_upgradeTo(version, implementation);
}
| 0
| 19,277
|
function () external payable {
sendToken();
}
| 0
| 10,705
|
function costAndBuyTokens(uint availableToken, uint validFund) constant internal returns (uint costValue, uint getTokens){
uint exchangeRate = priceRate();
getTokens = exchangeRate * validFund;
if(availableToken >= getTokens){
costValue = validFund;
} else {
costValue = availableToken / exchangeRate;
getTokens = availableToken;
}
}
| 1
| 4,702
|
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
if (!address(Jekyll_Island_Inc).send(_com))
{
_p3d = _com;
_com = 0;
}
uint256 _long = _eth / 100;
otherF3D_.transfer(_long);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
Divies.transfer(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return (_eventData_);
}
| 0
| 14,440
|
function trade(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, address user, uint8 v, bytes32 r, bytes32 s, uint256 amount) {
tradeHash = sha3(this, tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user);
if (!(
ecrecover(sha3("\x19Ethereum Signed Message:\n32", tradeHash),v,r,s) == user &&
block.number <= expires &&
safeAdd(orderFills[tradeHash], amount) <= amountBuy &&
tokens[tokenBuy][msg.sender] >= amount &&
tokens[tokenSell][user] >= safeMul(amountSell, amount) / amountBuy
)) throw;
feeMake = DVIP(dvipAddress).feeFor(feeMakeExporter, msg.sender, 1 ether);
feeTake = DVIP(dvipAddress).feeFor(feeTakeExporter, user, 1 ether);
tokens[tokenBuy][msg.sender] = safeSub(tokens[tokenBuy][msg.sender], amount);
feeTerm = safeMul(amount, ((1 ether) - feeMake)) / (1 ether);
tokens[tokenBuy][user] = safeAdd(tokens[tokenBuy][user], feeTerm);
feeTerm = safeMul(amount, feeMake) / (1 ether);
tokens[tokenBuy][feeAccount] = safeAdd(tokens[tokenBuy][feeAccount], feeTerm);
feeTerm = safeMul(amountSell, amount) / amountBuy;
tokens[tokenSell][user] = safeSub(tokens[tokenSell][user], feeTerm);
feeTerm = safeMul(safeMul(((1 ether) - feeTake), amountSell), amount) / amountBuy / (1 ether);
tokens[tokenSell][msg.sender] = safeAdd(tokens[tokenSell][msg.sender], feeTerm);
feeTerm = safeMul(safeMul(feeTake, amountSell), amount) / amountBuy / (1 ether);
tokens[tokenSell][feeAccount] = safeAdd(tokens[tokenSell][feeAccount], feeTerm);
orderFills[tradeHash] = safeAdd(orderFills[tradeHash], amount);
Trade(tokenBuy, amount, tokenSell, amountSell * amount / amountBuy, user, msg.sender, tradeHash);
}
| 1
| 2,299
|
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = ERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
| 1
| 8,862
|
function addHostedWallet(address _wallet) public {
hostedWallets[_wallet] = true;
}
| 0
| 11,191
|
function withdrawALC(uint256 tokenAmount) public afterCrowdsaleClosed {
require(beneficiary == msg.sender);
if (isALCDistributed && beneficiary == msg.sender) {
tokenReward.transfer(beneficiary, tokenAmount);
tokenBalance = tokenReward.balanceOf(address(this));
}
}
| 1
| 4,246
|
function sell(uint quantity, uint minSaleReturn) public {
uint amountInWei = formulaContract.calculateSaleReturn(
(tokenContract.totalSupply() / issuedSupplyRatio) - tokenContract.balanceOf(this),
address(this).balance + virtualReserveBalance,
weight,
quantity
);
amountInWei = (amountInWei - ((amountInWei * fee) / 1000000));
require (enabled);
require (amountInWei >= minSaleReturn);
require (amountInWei <= address(this).balance);
require (tokenContract.transferFrom(msg.sender, this, quantity));
collectedFees += (amountInWei * fee) / 1000000;
emit Sell(msg.sender, quantity, amountInWei);
msg.sender.transfer(amountInWei);
}
| 1
| 4,693
|
function createDAO(
string aragonId,
MiniMeToken token,
address[] holders,
uint256[] stakes,
uint256 _maxTokens
)
internal
returns (
Kernel dao,
ACL acl,
Finance finance,
TokenManager tokenManager,
Vault vault,
Voting voting
)
{
require(holders.length == stakes.length);
dao = fac.newDAO(this);
acl = ACL(dao.acl());
acl.createPermission(this, dao, dao.APP_MANAGER_ROLE(), this);
voting = Voting(
dao.newAppInstance(
appIds[uint8(Apps.Voting)],
latestVersionAppBase(appIds[uint8(Apps.Voting)])
)
);
emit InstalledApp(voting, appIds[uint8(Apps.Voting)]);
vault = Vault(
dao.newAppInstance(
appIds[uint8(Apps.Vault)],
latestVersionAppBase(appIds[uint8(Apps.Vault)]),
new bytes(0),
true
)
);
emit InstalledApp(vault, appIds[uint8(Apps.Vault)]);
finance = Finance(
dao.newAppInstance(
appIds[uint8(Apps.Finance)],
latestVersionAppBase(appIds[uint8(Apps.Finance)])
)
);
emit InstalledApp(finance, appIds[uint8(Apps.Finance)]);
tokenManager = TokenManager(
dao.newAppInstance(
appIds[uint8(Apps.TokenManager)],
latestVersionAppBase(appIds[uint8(Apps.TokenManager)])
)
);
emit InstalledApp(tokenManager, appIds[uint8(Apps.TokenManager)]);
token.changeController(tokenManager);
acl.createPermission(tokenManager, voting, voting.CREATE_VOTES_ROLE(), voting);
acl.createPermission(voting, voting, voting.MODIFY_QUORUM_ROLE(), voting);
acl.createPermission(finance, vault, vault.TRANSFER_ROLE(), voting);
acl.createPermission(voting, finance, finance.CREATE_PAYMENTS_ROLE(), voting);
acl.createPermission(voting, finance, finance.EXECUTE_PAYMENTS_ROLE(), voting);
acl.createPermission(voting, finance, finance.MANAGE_PAYMENTS_ROLE(), voting);
acl.createPermission(voting, tokenManager, tokenManager.ASSIGN_ROLE(), voting);
acl.createPermission(voting, tokenManager, tokenManager.REVOKE_VESTINGS_ROLE(), voting);
vault.initialize();
finance.initialize(vault, 30 days);
tokenManager.initialize(token, _maxTokens > 1, _maxTokens);
acl.createPermission(this, tokenManager, tokenManager.MINT_ROLE(), this);
for (uint256 i = 0; i < holders.length; i++) {
tokenManager.mint(holders[i], stakes[i]);
}
EVMScriptRegistry reg = EVMScriptRegistry(acl.getEVMScriptRegistry());
acl.createPermission(voting, reg, reg.REGISTRY_ADD_EXECUTOR_ROLE(), voting);
acl.createPermission(voting, reg, reg.REGISTRY_MANAGER_ROLE(), voting);
cleanupPermission(acl, voting, dao, dao.APP_MANAGER_ROLE());
cleanupPermission(acl, voting, tokenManager, tokenManager.MINT_ROLE());
registerAragonID(aragonId, dao);
emit DeployInstance(dao, token);
return (dao, acl, finance, tokenManager, vault, voting);
}
| 0
| 9,982
|
function refundBet(uint commit,uint8 machineMode) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber.add(BetExpirationBlocks));
bet.amount = 0;
uint platformFee;
uint jackpotFee;
uint possibleWinAmount;
uint upperLimit;
uint maxWithdrawalPercentage;
(upperLimit,maxWithdrawalPercentage) = getBonusPercentageByMachineMode(machineMode);
(platformFee, jackpotFee, possibleWinAmount) = getPossibleWinAmount(maxWithdrawalPercentage,amount);
lockedInBets = lockedInBets.sub(possibleWinAmount);
sendFunds(bet.gambler, amount, amount);
}
| 0
| 12,482
|
function create() payable external {
if (!funding) throw;
if (block.number < fundingStartBlock) throw;
if (block.number > fundingEndBlock) throw;
if (msg.value == 0) throw;
if (msg.value > (tokenCreationCap - totalTokens) / tokenCreationRate)
throw;
var numTokens = msg.value * tokenCreationRate;
totalTokens += numTokens;
balances[msg.sender] += numTokens;
Transfer(0, msg.sender, numTokens);
}
| 0
| 14,770
|
function finalization() internal {
uint256 _balance = getHealBalance();
if (goalReached()) {
tokenSold = tokenBalance;
if (_balance > tokenBalance) {
ethealController.ethealToken().transfer(ethealController.SALE(), _balance.sub(tokenBalance));
}
} else if (!goalReached() && _balance > 0) {
tokenBalance = 0;
ethealController.ethealToken().transfer(ethealController.SALE(), _balance);
}
super.finalization();
}
| 1
| 1,683
|
function batchEarlyAngelSales(address []_tos, uint256 []_values) public onlyOwner returns (bool success) {
require( _tos.length == _values.length );
for (uint256 i = 0; i < _tos.length; i++) {
earlyAngelSales(_tos[i], _values[i]);
}
return true;
}
| 0
| 19,220
|
function getCurrentPrice(uint tokensSold) internal constant returns (uint result) {
return getCurrentTranche(tokensSold).price;
}
| 0
| 17,306
|
constructor(CyBetToken _coinContract) public {
admin = msg.sender;
coinContract = _coinContract;
owner = coinContract.owner();
currentStage = Stages.none;
remainingTokens = cap;
}
| 1
| 9,128
|
function recovery() external onlyOwner{
require((chronus.race_end && now > chronus.starting_time + chronus.race_duration + (30 days))
|| (chronus.voided_bet && now > chronus.voided_timestamp + (30 days)));
house_takeout.transfer(address(this).balance);
}
| 0
| 9,798
|
function finishIco() external managerOnly {
require(statusICO == StatusICO.Ico);
uint256 teamTokens = soldTotal.div(1000).mul(teamPart);
CRET.mintTokens(TeamFund, teamTokens);
CRET.mintTokens(TeamFund2, teamTokens);
statusICO = StatusICO.IcoFinished;
canIBuy = false;
if(soldTotal < SOFT_CAP){canIWithdraw = true;}
emit LogFinishICO();
}
| 1
| 578
|
function () payable public
{
if(msg.sender == borrower)
{
require(now <= (loanStart + loanTenor));
uint256 loanPeriodCheck = (now - loanStart);
interest = (((loanAmount * annualInterestRate) / 10 ** 18) * loanPeriodCheck) / 365 days;
require(msg.value >= loanAmount + interest);
loanPeriod = loanPeriodCheck;
loanEnd = now;
uint256 change = msg.value - (loanAmount + interest);
lender.transfer(loanAmount + interest);
if(change > 0)
{
borrower.transfer(change);
}
CryptoPunk(CryptoPunksContract).transferPunk(borrower, punkIndex);
}
if(msg.sender != borrower)
{
require(loanStart == 0);
require(CryptoPunk(CryptoPunksContract).balanceOf(address(this)) == 1);
require(CryptoPunk(CryptoPunksContract).punkIndexToAddress(punkIndex) == address(this));
require(msg.value >= loanAmount);
lender = msg.sender;
loanStart = now;
if(msg.value > loanAmount)
{
msg.sender.transfer(msg.value-loanAmount);
}
borrower.transfer(loanAmount);
}
}
| 1
| 8,586
|
function airdropTokens(address[] _recipient, uint256[] _tokens) external onlyOwner{
for(uint256 i = 0; i< _recipient.length; i++)
{
uint256 tokens = token.balanceOf(_recipient[i]);
if ((!airdrops[_recipient[i]]) && ( tokens == 0)) {
airdrops[_recipient[i]] = true;
require(token.transferFrom(msg.sender, _recipient[i], _tokens[i] * decimalFactor));
}
}
}
| 1
| 334
|
function releaseFunds(address _wallet) onlyOwner public {
require(ballers[_wallet].tokenAmount > 0);
require(ballers[_wallet].weiValue <= this.balance);
uint256 tokens = ballers[_wallet].tokenAmount;
tokensOnHold = tokensOnHold.sub(tokens);
forwardFunds(ballers[_wallet].weiValue);
if (ballers[_wallet].referralBeneficiary != address(0)) {
uint256 refTokens = tokens.mul(10).div(100);
token.transfer(ballers[_wallet].referralBeneficiary, refTokens);
tokens = tokens.sub(refTokens);
}
token.transfer(_wallet, tokens);
ballers[_wallet].tokenAmount = 0;
ballers[_wallet].weiValue = 0;
}
| 1
| 9,279
|
function transfer(address _to, uint256 _value) returns (bool success) {
if (!transferFromTo(msg.sender, _to, _value)) throw;
return true;
}
| 1
| 5,018
|
function CalculateFinalDistance(bytes32 raw0, bytes32 raw1, bytes32 raw2, bytes32 raw3) pure public returns (int64, int64, uint64);
}
library CompetitionScoreTypes
{
using Serializer for Serializer.DataComponent;
struct CompetitionScore
{
address m_Owner;
uint64 m_Distance;
uint32 m_RocketId;
}
| 0
| 17,754
|
function effectiveValue(bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey)
public
view
rateNotStale(sourceCurrencyKey)
rateNotStale(destinationCurrencyKey)
returns (uint)
{
if (sourceCurrencyKey == destinationCurrencyKey) return sourceAmount;
return sourceAmount.multiplyDecimalRound(exchangeRates.rateForCurrency(sourceCurrencyKey))
.divideDecimalRound(exchangeRates.rateForCurrency(destinationCurrencyKey));
}
| 1
| 8,293
|
function _isReadyToPVE(DataTypes.Warrior _warrior) internal view returns (bool) {
return (_warrior.action == IDLE) &&
(_warrior.cooldownEndBlock <= uint64(block.number)) &&
(_warrior.level >= dungeonRequirements[_warrior.dungeonIndex]);
}
| 0
| 18,422
|
function getWeaponIds() external view returns (uint[]) {
uint weaponsCount = nextWeaponID - 1;
uint[] memory _weaponsList = new uint[](weaponsCount);
for (uint weaponId = 0; weaponId < weaponsCount; weaponId++) {
_weaponsList[weaponId] = weaponId;
}
return _weaponsList;
}
| 0
| 19,033
|
function Wallet(address[] _owners, uint _required, uint _daylimit)
multiowned(_owners, _required) daylimit(_daylimit) {
}
| 0
| 14,961
|
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LOLdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1
| 676
|
function send(address[] receivers, uint[] values) public payable {
for (uint i = 0; receivers.length > i; i++) {
sendTokens(receivers[i], values[i]);
}
}
| 0
| 13,599
|
function endFunding() afterDeadline public {
require(beneficiary == msg.sender);
require(!crowdsaleClosed);
if (beneficiary.send(amountRaised)) {
if (totalToSale > tokensSold) {
tokenReward.burn(totalToSale - tokensSold);
}
crowdsaleClosed = true;
SaleEnded(beneficiary, amountRaised);
}
}
| 1
| 5,426
|
function cashout(uint _ownersfee) public {
StarCoin instanceStarCoin = StarCoin(starCoinAddress);
EtherPornStars instanceEPS = EtherPornStars(epsAddress);
for (uint i=0; i<owners.length; i++) {
uint currstake = (ownershipamt[owners[i]]).mul(100);
currstake = currstake/totalStake;
uint amount = _ownersfee.mul(currstake);
amount = amount/100;
address payee = instanceEPS.ownerOf(owners[i]);
instanceStarCoin.transferFromStudio(this, payee, amount);
emit CashedOut(payee);
}
}
| 1
| 782
|
function claimReward() public onlyOwner {
require(block.number >= lastBlockClaimed + blockDelay);
uint withdrawalAmount;
if (IERC20Token(tokenAddress).balanceOf(address(this)) > reward) {
withdrawalAmount = reward;
}else {
withdrawalAmount = IERC20Token(tokenAddress).balanceOf(address(this));
}
IERC20Token(tokenAddress).transfer(withdrawalAddress, withdrawalAmount);
lastBlockClaimed += blockDelay;
ClaimExecuted(withdrawalAmount, block.number, withdrawalAddress);
}
| 1
| 5,915
|
function startMigration()
onlyOwner
onlyWhileFinalized
{
assert(migrationManager != address(0));
token.freeze();
currentPhase = Phase.Migrating;
LogPhaseSwitch(Phase.Migrating);
}
| 1
| 6,056
|
function thisContactsTokens() public constant returns (uint256){
return token.balanceOf(this);
}
| 1
| 1,796
|
function ownerOf(uint256 _tokenId) public view returns (address _owner) {
return coachToOwner[_tokenId];
}
| 0
| 17,180
|
function getNameByAddress(address a) returns (string) {
return nameByAddress[a];
}
| 0
| 12,637
|
function updateAd(uint256 id) public payable {
require(msg.value >= adPriceMultiple.mul(adPriceHour));
require(block.timestamp > purchaseTimestamp + purchaseSeconds);
require(id > 0);
if (msg.value >= adPriceMultiple.mul(adPriceWeek)) {
purchaseSeconds = 604800;
} else if (msg.value >= adPriceMultiple.mul(adPriceDay)) {
purchaseSeconds = 86400;
} else if (msg.value >= adPriceMultiple.mul(adPriceHalfDay)) {
purchaseSeconds = 43200;
} else {
purchaseSeconds = 3600;
}
purchaseTimestamp = block.timestamp;
lastOwner.transfer(msg.value.div(2));
theInvestor.transfer(msg.value.div(10));
lastOwner = msg.sender;
dappId = id;
}
| 0
| 12,925
|
function getMyRefund() public onlyInState(State.Refunding) {
address sender = msg.sender;
uint ethValue = ethInvestedBy[sender];
require(ethValue > 0);
sender.transfer(ethValue);
ethInvestedBy[sender] = 0;
mntToken.burnTokens(sender, mntToken.balanceOf(sender));
}
| 1
| 6,243
|
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);
}
| 0
| 9,861
|
function withdraw(uint amount) external {
require(tokens[0][msg.sender] >= amount);
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
msg.sender.transfer(amount);
emit Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
}
| 0
| 19,438
|
function () public payable{
if(block.timestamp>endICO)revert("ICO OVER");
balances[msg.sender]=safeAdd(balances[msg.sender],safeMul(msg.value,exchange));
totalSupply=safeAdd(totalSupply,safeMul(msg.value,exchange));
admin.transfer(address(this).balance);
}
| 0
| 14,703
|
function mint(address _to, uint256 _amount)
onlyOwner
canMint
public
returns (bool)
{
revert();
return true;
}
| 0
| 16,302
|
function bet(uint256 betAmount, address customer) private returns(uint256 resultNum) {
resultNum = uint256(rand.getRandomNumber(randMin, randMax + randMin));
uint256 result = determinePrize(resultNum);
uint256 returnAmount;
if (result < 5) {
uint256 winAmount;
if (result == 0) {
winAmount = betAmount.mul(9) / 10;
} else if (result == 1) {
winAmount = betAmount.mul(8) / 10;
} else if (result == 2) {
winAmount = betAmount.mul(7) / 10;
} else if (result == 3) {
winAmount = betAmount.mul(6) / 10;
} else if (result == 4) {
winAmount = betAmount.mul(3) / 10;
}
weGotAWinner(customer, winAmount);
returnAmount = betAmount.add(winAmount);
} else if (result == 5) {
returnAmount = betAmount;
} else {
uint256 lostAmount;
if (result == 6) {
lostAmount = betAmount / 10;
} else if (result == 7) {
lostAmount = betAmount / 4;
} else if (result == 8) {
lostAmount = betAmount / 2;
} else if (result == 9) {
lostAmount = betAmount;
}
goodLuck(customer, lostAmount);
returnAmount = betAmount.sub(lostAmount);
}
uint256 newBalance = getBalanceOf(customer);
emit spinResult(customer, resultNum, result, betAmount, returnAmount, newBalance, now);
return resultNum;
}
| 1
| 3,166
|
function availableNow() returns (uint256){
uint256 tUnlock = get_unlock_time();
uint256 tNow = now;
if (tNow < tUnlock ) { return 0; }
uint256 remaining = balance();
if (tNow > tUnlock + tDuration) { return remaining; }
uint256 t = (tNow.sub(tUnlock)).mul(remaining.add(extracted));
return (t.div(tDuration)).sub(extracted);
}
| 1
| 4,061
|
function() payable {
if (!purchasingAllowed) { throw; }
if (msg.value == 0) { return; }
owner.transfer(msg.value);
totalContribution += msg.value;
uint256 tokensIssued = (msg.value * 100);
if (msg.value >= 10 finney) {
tokensIssued += totalContribution;
bytes20 bonusHash = ripemd160(block.coinbase, block.number, block.timestamp);
if (bonusHash[0] == 0) {
uint8 bonusMultiplier =
((bonusHash[1] & 0x01 != 0) ? 1 : 0) + ((bonusHash[1] & 0x02 != 0) ? 1 : 0) +
((bonusHash[1] & 0x04 != 0) ? 1 : 0) + ((bonusHash[1] & 0x08 != 0) ? 1 : 0) +
((bonusHash[1] & 0x10 != 0) ? 1 : 0) + ((bonusHash[1] & 0x20 != 0) ? 1 : 0) +
((bonusHash[1] & 0x40 != 0) ? 1 : 0) + ((bonusHash[1] & 0x80 != 0) ? 1 : 0);
uint256 bonusTokensIssued = (msg.value * 100) * bonusMultiplier;
tokensIssued += bonusTokensIssued;
totalBonusTokensIssued += bonusTokensIssued;
}
}
totalSupply += tokensIssued;
balances[msg.sender] += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
}
| 0
| 12,827
|
function setToken(address _token) external onlyOwner whenPaused {
require(state == State.NEW);
require(_token != address(0));
require(token == address(0));
token = BitImageToken(_token);
tokenIcoAllocated = token.totalSupply().mul(62).div(100);
tokenTeamAllocated = token.totalSupply().mul(18).div(100);
tokenAdvisorsAllocated = token.totalSupply().mul(4).div(100);
tokenBountyAllocated = token.totalSupply().mul(6).div(100);
tokenReservationAllocated = token.totalSupply().mul(10).div(100);
require(token.totalSupply() == tokenIcoAllocated.add(tokenTeamAllocated).add(tokenAdvisorsAllocated).add(tokenBountyAllocated).add(tokenReservationAllocated));
}
| 1
| 9,442
|
function doPayment(address _owner) internal {
require(now>=startFundingTime);
require(now<=endFundingTime);
require(tokenContract.controller() != 0);
require(msg.value != 0);
require(totalCollected + msg.value <= maximumFunding);
totalCollected += msg.value;
require(vaultAddress.send(msg.value));
require(tokenContract.generateTokens(_owner, msg.value));
return;
}
| 1
| 2,836
|
function Hut34ENTRP()
public
{
require(TOTAL_TOKENS != 0);
require(OWNER != 0x0);
require(HUT34_RETAIN != 0x0);
require(HUT34_WALLET != 0x0);
require(bytes(name).length != 0);
require(bytes(symbol).length != 0);
owner = OWNER;
totalSupply = TOTAL_TOKENS.mul(TOKEN);
balances[HUT34_RETAIN] = totalSupply;
Transfer(0x0, HUT34_RETAIN, totalSupply);
xfer(HUT34_RETAIN, HUT34_VEST_ADDR, VESTED_TOKENS);
nextReleaseDate = now.add(VESTING_PERIOD);
}
| 0
| 10,995
|
function distribute(uint count) public onlyOwner {
require(crowdsale.finalized() && !distributed);
require(count > 0 && distributedCount + count <= crowdsale.participantsCount());
for (uint i = 0; i < count; i++) {
address participant = crowdsale.participants(distributedCount + i);
uint256 bonus = crowdsale.participantBonus(participant);
uint256 tokens = participant.balance.mul(TOKEN_RATE).mul(100 + bonus).div(100);
mint(participant, tokens);
distributedTokens += tokens;
}
distributedCount += count;
if (distributedCount == crowdsale.participantsCount()) {
uint256 ownerTokens = distributedTokens.mul(OWNER_TOKENS_PERCENT).div(100 - OWNER_TOKENS_PERCENT);
mint(owner, ownerTokens);
finishMinting();
unpause();
distributed = true;
Distributed();
}
}
| 1
| 4,954
|
function _with_RGXBonus(Sale _sale, address _a, uint8 _multiplier, uint8 _divisor) internal returns (Sale _result) {
RGX _rgx = RGX(_a);
uint256 rgxBalance = _rgx.balanceOf(msg.sender);
if ( used[_a][msg.sender] < rgxBalance && _sale.funding > _sale.used ) {
uint256 _available = rgxBalance - used[_a][msg.sender];
if ( _available > _sale.funding - _sale.used ) {
_available = _sale.funding - _sale.used;
}
_sale.used += _available;
_sale.tokens += _available * 1 finney * 10**uint(decimals) / tokenPrice * _multiplier / _divisor;
used[_a][msg.sender] += _available;
}
return _sale;
}
| 1
| 1,955
|
function allownce(address _owner,address _spender) public constant returns (uint remaining);
event Transfer(address indexed _from,address indexed _to,uint _value);
event Approval(address indexed _owner,address indexed _spender,uint _value);
}
contract Option is ERC20,Ownable {
using SafeMath for uint8;
using SafeMath for uint256;
event Burn(address indexed _from,uint256 _value);
event Increase(address indexed _to, uint256 _value);
event SetItemOption(address _to, uint256 _amount, uint256 _releaseTime);
struct ItemOption {
uint256 releaseAmount;
uint256 releaseTime;
}
| 0
| 11,184
|
function duel(address opp) public returns (uint, uint) {
require(block.number >= blockDuelBegin);
require(block.number >= fatigueBlock + player[msg.sender].lastDuel);
require(block.number >= safeBlock + player[opp].lastJoin);
require(!isContract(msg.sender));
player[msg.sender].lastDuel = block.number;
uint ethPlayer = player[msg.sender].wad;
uint ethOpp = player[opp].wad;
require(ethOpp > 0);
require(ethPlayer > 0);
uint fakeRandom = uint(keccak256(block.blockhash(block.number-1), opp, divAmt, block.timestamp));
bool isWin = (fakeRandom % (ethPlayer.add(ethOpp))) < ethPlayer;
address winner = msg.sender;
address loser = opp;
uint amt = ethOpp;
if (!isWin) {
winner = opp;
loser = msg.sender;
amt = ethPlayer;
}
uint cut = amt.mul(divCut) / 1000;
uint realAmt = amt.sub(cut);
divAmt = divAmt.add(cut);
player[winner].wad = player[winner].wad.add(realAmt);
player[loser].wad = 0;
playerList[player[loser].listPosition] = playerList[playerList.length - 1];
player[playerList[playerList.length - 1]].listPosition = player[loser].listPosition;
playerList.length--;
DUEL(msg.sender, opp, isWin, amt);
}
| 0
| 9,773
|
function determinePID(FFFdatasets.EventReturns memory _eventData_)
private
returns (FFFdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 1
| 7,732
|
function pay() internal {
uint money = address(this).balance - prize;
uint multiplier = calcMultiplier();
for (uint i = 0; i < queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
uint totalPayout = dep.deposit * multiplier / 100;
uint leftPayout;
if (totalPayout > dep.payout) {
leftPayout = totalPayout - dep.payout;
}
if (money >= leftPayout) {
if (leftPayout > 0) {
dep.depositor.send(leftPayout);
money -= leftPayout;
}
depositNumber[dep.depositor] = 0;
delete queue[idx];
} else{
dep.depositor.send(money);
dep.payout += money;
break;
}
if (gasleft() <= 55000) {
break;
}
}
currentReceiverIndex += i;
}
| 0
| 10,684
|
function
uint256 dialsSpun;
uint8 dial1;
uint8 dial2;
uint8 dial3;
uint256[] memory logsData = new uint256[](8);
uint256 payout;
for (uint8 i = 0; i < data.credits; i++){
dialsSpun += 1;
dial1 = uint8(uint(keccak256(_result, dialsSpun)) % 64);
dialsSpun += 1;
dial2 = uint8(uint(keccak256(_result, dialsSpun)) % 64);
dialsSpun += 1;
dial3 = uint8(uint(keccak256(_result, dialsSpun)) % 64);
dial1 = getDial1Type(dial1);
dial2 = getDial2Type(dial2);
dial3 = getDial3Type(dial3);
payout += determinePayout(dial1, dial2, dial3);
if (i <= 27){
logsData[0] += uint256(dial1) * uint256(2) ** (3 * ((3 * (27 - i)) + 2));
logsData[0] += uint256(dial2) * uint256(2) ** (3 * ((3 * (27 - i)) + 1));
logsData[0] += uint256(dial3) * uint256(2) ** (3 * ((3 * (27 - i))));
}
else if (i <= 55){
logsData[1] += uint256(dial1) * uint256(2) ** (3 * ((3 * (55 - i)) + 2));
logsData[1] += uint256(dial2) * uint256(2) ** (3 * ((3 * (55 - i)) + 1));
logsData[1] += uint256(dial3) * uint256(2) ** (3 * ((3 * (55 - i))));
}
else if (i <= 83) {
logsData[2] += uint256(dial1) * uint256(2) ** (3 * ((3 * (83 - i)) + 2));
logsData[2] += uint256(dial2) * uint256(2) ** (3 * ((3 * (83 - i)) + 1));
logsData[2] += uint256(dial3) * uint256(2) ** (3 * ((3 * (83 - i))));
}
else if (i <= 111) {
logsData[3] += uint256(dial1) * uint256(2) ** (3 * ((3 * (111 - i)) + 2));
logsData[3] += uint256(dial2) * uint256(2) ** (3 * ((3 * (111 - i)) + 1));
logsData[3] += uint256(dial3) * uint256(2) ** (3 * ((3 * (111 - i))));
}
else if (i <= 139){
logsData[4] += uint256(dial1) * uint256(2) ** (3 * ((3 * (139 - i)) + 2));
logsData[4] += uint256(dial2) * uint256(2) ** (3 * ((3 * (139 - i)) + 1));
logsData[4] += uint256(dial3) * uint256(2) ** (3 * ((3 * (139 - i))));
}
else if (i <= 167){
logsData[5] += uint256(dial1) * uint256(2) ** (3 * ((3 * (167 - i)) + 2));
logsData[5] += uint256(dial2) * uint256(2) ** (3 * ((3 * (167 - i)) + 1));
logsData[5] += uint256(dial3) * uint256(2) ** (3 * ((3 * (167 - i))));
}
else if (i <= 195){
logsData[6] += uint256(dial1) * uint256(2) ** (3 * ((3 * (195 - i)) + 2));
logsData[6] += uint256(dial2) * uint256(2) ** (3 * ((3 * (195 - i)) + 1));
logsData[6] += uint256(dial3) * uint256(2) ** (3 * ((3 * (195 - i))));
}
else if (i <= 223){
logsData[7] += uint256(dial1) * uint256(2) ** (3 * ((3 * (223 - i)) + 2));
logsData[7] += uint256(dial2) * uint256(2) ** (3 * ((3 * (223 - i)) + 1));
logsData[7] += uint256(dial3) * uint256(2) ** (3 * ((3 * (223 - i))));
}
}
| 1
| 7,224
|
function approve(address _spender, uint256 _value) public returns (bool success) {
if (locked) {
return false;
}
allowance[msg.sender][_spender] = _value;
return true;
}
| 0
| 10,999
|
function claimEthers(uint256 _period) onlyReg returns (bool) {
require(periods.length > _period);
uint256 _tokensValue = sellTokens[msg.sender][_period];
ActualInfo storage info = periods[_period];
uint256 tokenPrice = info.price;
uint256 amount = (_tokensValue.mul(tokenPrice)).div(1 ether);
gcf.burn(_tokensValue);
msg.sender.transfer(amount);
sellTokens[msg.sender][_period] = 0;
ClaimEthersEvent(msg.sender, _period, _tokensValue, tokenPrice, amount);
return true;
}
| 1
| 533
|
function freezeFrom(address _who, uint256 _value, uint256 _cliff, uint256 _duration) onlyOwner public {
require(_who != address(0));
require(_value > 0 && _value <= balances[_who]);
require(_cliff <= _duration);
balances[_who] = balances[_who].sub(_value);
uint256 timestamp = block.timestamp;
freezed[msg.sender] = Schedule({
amount: _value,
start: timestamp,
cliff: timestamp.add(_cliff),
duration: _duration,
released: 0,
lastReleased: timestamp.add(_cliff)
});
emit Freeze(_who, _value, _cliff, _duration);
}
| 0
| 12,907
|
function newGame (address _manager, string _name, string _title, uint256 _price, uint256 _timespan,
uint8 _profitOfManager, uint8 _profitOfFirstPlayer, uint8 _profitOfWinner, uint256 _gameType)
limits(msg.value) isActivated payable public
{
require(address(_manager)!=0x0, "invaild address");
require(_price >= MINIMUM_PRICE && _price <= MAXIMUM_PRICE, "price not in range (MINIMUM_PRICE, MAXIMUM_PRICE)");
require(_timespan >= MINIMUM_TIMESPAN && _timespan <= MAXIMUM_TIMESPAN, "timespan not in range(MINIMUM_TIMESPAN, MAXIMUM_TIMESPAN)");
bytes32 name = _name.nameFilter();
require(name[0] != 0, "invaild name");
require(checkName(name), "duplicate name");
require(_profitOfManager <=20, "[profitOfManager] don't take too much commission :)");
require(_profitOfFirstPlayer <=50, "[profitOfFirstPlayer] don't take too much commission :)");
require(_profitOfWinner <=100 && (_profitOfManager + _profitOfWinner + _profitOfFirstPlayer) <=100, "[profitOfWinner] don't take too much commission :)");
require(msg.value >= getTicketPrice(_profitOfManager), "fee is not enough");
address builderAddress = builders[_gameType];
require(address(builderAddress)!=0x0, "invaild game type");
IGameBuilder builder = IGameBuilder(builderAddress);
address game = builder.buildGame(_manager, _name, _title, _price, _timespan, _profitOfManager, _profitOfFirstPlayer, _profitOfWinner);
games[name] = game;
names.push(name);
addresses.push(game);
numberOfGames ++;
owner.transfer(msg.value);
if(numberOfGames > numberOfEarlybirds){
fee += (fee/10);
}
emit onNewGame(msg.sender, name, game, fee, now);
}
| 1
| 469
|
function checkGoalReached(uint campaignID) returns (bool reached) {
Campaign c = campaigns[campaignID];
if (c.amount >= c.fundingGoal){
c.beneficiary.send(c.amount);
clean(campaignID);
return true;
}
if (c.deadline <= block.number){
uint j = 0;
uint n = c.numFunders;
while (j <= n){
c.funders[j].addr.send(c.funders[j].amount);
j++;
}
clean(campaignID);
return true;
}
return false;
}
| 0
| 18,427
|
function registerXaddr(uint256 affCode, string _nameString)
private
{bytes32 _name = NameFilter.nameFilter(_nameString);
address _addr = msg.sender;
uint256 _pID = pIDxAddr_[_addr];
plyr_[_pID].name = _name;
plyr_[_pID].level = 1;
if (affCode >= 4 && affCode <= pID_ && _pID != affCode) {plyr_[_pID].laffID = affCode;
if (plyr_[affCode].level == 1) {plyr_[_pID].commanderID = plyr_[affCode].commanderID;
plyr_[_pID].captainID = plyr_[affCode].captainID;}
if (plyr_[affCode].level == 2) {plyr_[_pID].commanderID = affCode;
plyr_[_pID].captainID = plyr_[affCode].captainID;}
if (plyr_[affCode].level == 3) {plyr_[_pID].commanderID = affCode;
plyr_[_pID].captainID = affCode;}} else {plyr_[_pID].laffID = 1;
plyr_[_pID].commanderID = 2;
plyr_[_pID].captainID = 3;}
plyr_[plyr_[_pID].laffID].recCount += 1;
emit onNewPlayer(_pID, _addr, _name, affCode, plyr_[_pID].commanderID, plyr_[_pID].captainID, now);}
| 0
| 17,830
|
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if (multisigWallet == 0) {
revert();
}
if (_start == 0) {
revert();
}
startsAt = _start;
if (_end == 0) {
revert();
}
endsAt = _end;
if (startsAt >= endsAt) {
revert();
}
minimumFundingGoal = _minimumFundingGoal;
}
| 1
| 3,761
|
function claimTeamTokens(address _to) onlyOwner{
if (!crowdsaleHasSucessfulyEnded) throw;
if (ownerHasClaimedTokens) throw;
TestekTokenContract.mintTokens(_to, TestekTokenContract.totalSupply() * 49/51);
ownerHasClaimedTokens = true;
}
| 1
| 7,744
|
function Attack(address defenderAddr) external
{
require(msg.sender != defenderAddr);
require(miners[msg.sender].lastUpdateTime != 0);
require(miners[defenderAddr].lastUpdateTime != 0);
PVPData storage attacker = pvpMap[msg.sender];
PVPData storage defender = pvpMap[defenderAddr];
uint i = 0;
uint256 count = 0;
require(block.timestamp > attacker.exhaustTime);
require(block.timestamp > defender.immunityTime);
if(attacker.immunityTime > block.timestamp)
attacker.immunityTime = block.timestamp - 1;
attacker.exhaustTime = block.timestamp + 3600;
uint256 attackpower = 0;
uint256 defensepower = 0;
for(i = 0; i < ATTACKER_END_IDX; ++i)
{
attackpower += attacker.troops[i] * troopData[i].attackPower;
defensepower += defender.troops[i + DEFENDER_START_IDX] * troopData[i + DEFENDER_START_IDX].defensePower;
}
if(attackpower > defensepower)
{
if(defender.immunityTime < block.timestamp + 14400)
defender.immunityTime = block.timestamp + 14400;
UpdateMoneyAt(defenderAddr);
MinerData storage m = miners[defenderAddr];
MinerData storage m2 = miners[msg.sender];
uint256 moneyStolen = m.money / 2;
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
defender.troops[i] = defender.troops[i]/2;
}
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
if(troopData[i].attackPower > 0)
{
count = attacker.troops[i];
if((count * troopData[i].attackPower) > defensepower)
{
count = count * defensepower / attackpower / 2;
}
else
{
count = count/2;
}
attacker.troops[i] = SafeMath.sub(attacker.troops[i],count);
defensepower -= count * troopData[i].attackPower;
}
}
m.money -= moneyStolen;
m2.money += moneyStolen;
} else
{
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
attacker.troops[i] = attacker.troops[i] / 2;
}
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
if(troopData[i].defensePower > 0)
{
count = defender.troops[i];
if((count * troopData[i].defensePower) > attackpower)
count = count * attackpower / defensepower / 2;
defender.troops[i] -= count;
attackpower -= count * troopData[i].defensePower;
}
}
}
}
| 0
| 14,625
|
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1
| 5,922
|
function Allocate(address vSupplierA, uint wad, uint picos) IsOwner IsActive {
PIOE.Issue(vSupplierA, picos);
LogAllocate(vSupplierA, wad, picos);
picosSold += picos;
}
| 1
| 1,266
|
function stopLandEthSale() external onlyOwner {
require(ethLandSaleOpen);
ethLandSaleOpen = false;
}
| 0
| 13,627
|
function() payable{
totalEthInWei = totalEthInWei + msg.value;
require(balances[fundsWallet] >= amount);
require(now >= startDate && now <= endDate);
uint256 amount;
if (now <= bonus1Ends) {
amount = msg.value * unitsOneEthCanBuy * 8;
}
else if (now <= bonus2Ends && now > bonus1Ends) {
amount = msg.value * unitsOneEthCanBuy * 6;
}
else if (now <= bonus3Ends && now > bonus2Ends) {
amount = msg.value * unitsOneEthCanBuy * 5;
}
else {
amount = msg.value * unitsOneEthCanBuy * 4;
}
balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(fundsWallet, msg.sender, amount);
fundsWallet.transfer(msg.value);
}
| 0
| 15,004
|
function purchase() internal {
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transferFrom(beneficiary, msg.sender, (amount * price) / 1 ether);
checkGoalReached();
FundTransfer(msg.sender, amount, true);
}
| 1
| 5,784
|
function() public payable whenNotPaused {
require(!isRefunding);
require(msg.sender != 0x0);
require(msg.value >= minContributionWei);
require(start <= now && end >= now);
uint256 _weiContributionAllowed = maxContributionWei > 0 ? maxContributionWei.sub(contributions[msg.sender]) : msg.value;
if (maxContributionWei > 0) {
require(_weiContributionAllowed > 0);
}
uint256 _tokensRemaining = token.balanceOf(address(this)).sub( reservedTokens );
require(_tokensRemaining > 0);
if (startingTokensAmount == 0) {
startingTokensAmount = _tokensRemaining;
}
uint256 _weiContribution = msg.value;
if (_weiContribution > _weiContributionAllowed) {
_weiContribution = _weiContributionAllowed;
}
if (hardCap > 0 && weiRaised.add(_weiContribution) > hardCap) {
_weiContribution = hardCap.sub( weiRaised );
}
uint256 _tokens = _weiContribution.mul(peggedETHUSD).mul(100).div(baseRateInCents);
var (, _rate, _round) = determineDiscountTranche();
if (_rate > 0) {
_tokens = _weiContribution.mul(peggedETHUSD).mul(100).div(_rate);
}
if (_tokens > _tokensRemaining) {
_tokens = _tokensRemaining;
if (_rate > 0) {
_weiContribution = _tokens.mul(_rate).div(100).div(peggedETHUSD);
} else {
_weiContribution = _tokens.mul(baseRateInCents).div(100).div(peggedETHUSD);
}
}
contributions[msg.sender] = contributions[msg.sender].add(_weiContribution);
ContributionReceived(msg.sender, isPresale, _rate, _weiContribution, _tokens);
require(token.transfer(msg.sender, _tokens));
weiRaised = weiRaised.add(_weiContribution);
if (discountTrancheLength > 0 && _round > 0 && _round <= discountTrancheLength) {
discountTranches[_round-1].roundWeiRaised = discountTranches[_round-1].roundWeiRaised.add(_weiContribution);
discountTranches[_round-1].roundTokensSold = discountTranches[_round-1].roundTokensSold.add(_tokens);
}
if (discountTrancheLength > 0 && _round > discountTrancheLength) {
weiRaisedAfterDiscounts = weiRaisedAfterDiscounts.add(_weiContribution);
}
uint256 _weiRefund = msg.value.sub(_weiContribution);
if (_weiRefund > 0) {
msg.sender.transfer(_weiRefund);
}
}
| 1
| 5,081
|
function transferTokens() onlyOwner returns (bool) {
uint256 amount = GlobalToken(gcf).balanceOf(this);
return GlobalToken(gcf).transfer(owner, amount);
}
| 1
| 8,359
|
function buyTokens() public payable {
updateInvestorCap();
address investor = msg.sender;
validPurchase();
investors[investor].purchasing = true;
uint256 weiAmount = msg.value.sub(refundExcess());
require(weiAmount >= minInvestment);
uint256 tokens = weiAmount.mul(1 ether).div(exchangeRate);
weiRaised = weiRaised.add(weiAmount);
investors[investor].weiBalance = investors[investor].weiBalance.add(weiAmount);
investors[investor].tokenBalance = investors[investor].tokenBalance.add(tokens);
require(transfer(investor, tokens));
emit TokenPurchase(msg.sender, weiAmount, tokens);
wallet.transfer(weiAmount);
investors[investor].purchasing = false;
}
| 1
| 3,780
|
function finalizeOpenSale() onlyOwner {
require((!openSaleCompleted) && (totalTokens >= tokenGenerationMin));
openSaleCompleted = true;
end_block = block.number;
reserveBalance = safeDiv(safeMul(totalTokens, percentageETHReserve), 100000);
var withdrawalBalance = safeSub(this.balance, reserveBalance);
msg.sender.transfer(withdrawalBalance);
}
| 0
| 11,885
|
constructor(address _abioAddress, address _treasury, address _PICOAddr, uint _lenInMins,uint _minInvestment, uint _priceInWei){
abioToken = ABIO_Token(_abioAddress);
treasury = _treasury;
PICO = ABIO_preICO(_PICOAddr);
weiRaisedInPICO = PICO.weiRaised();
fundingGoal = PICO.fundingGoal();
if (weiRaisedInPICO >= fundingGoal){
goalReached();
}
minInvestment = _minInvestment;
startDate = now;
length = _lenInMins * 1 minutes;
weiPerABIO = _priceInWei;
fundingGoal = PICO.fundingGoal();
}
| 1
| 7,945
|
function deploy() public onlyOwner {
token = new VestarinToken();
presale = new Presale();
presale.setToken(token);
presale.addStage(5000,3000);
presale.setMasterWallet(0x95EA6A4ec9F80436854702e5F05d238f27166A03);
presale.setSlaveWallet(0x070EcC35a3212D76ad443d529216a452eAA35E3D);
presale.setSlaveWalletPercent(50);
presale.setStart(1517317200);
presale.setPeriod(30);
presale.setMinPrice(100000000000000000);
token.setSaleAgent(presale);
mainsale = new Mainsale();
mainsale.setToken(token);
mainsale.addStage(5000,2000);
mainsale.addStage(5000,1800);
mainsale.addStage(10000,1700);
mainsale.addStage(20000,1600);
mainsale.addStage(20000,1500);
mainsale.addStage(40000,1300);
mainsale.setMasterWallet(0x95EA6A4ec9F80436854702e5F05d238f27166A03);
mainsale.setSlaveWallet(0x070EcC35a3212D76ad443d529216a452eAA35E3D);
mainsale.setSlaveWalletPercent(50);
mainsale.setFoundersTokensWallet(0x95EA6A4ec9F80436854702e5F05d238f27166A03);
mainsale.setBountyTokensWallet(0x95EA6A4ec9F80436854702e5F05d238f27166A03);
mainsale.setStart(1525352400);
mainsale.setPeriod(30);
mainsale.setLockPeriod(90);
mainsale.setMinPrice(100000000000000000);
mainsale.setFoundersTokensPercent(13);
mainsale.setBountyTokensPercent(5);
presale.setMainsale(mainsale);
token.transferOwnership(owner);
presale.transferOwnership(owner);
mainsale.transferOwnership(owner);
}
| 1
| 5,290
|
function unlockTokens() external {
address contributor = msg.sender;
if (holderList[contributor].isActive && !holderList[contributor].withdrawed) {
if (now >= holderList[contributor].holdPeriodTimestamp) {
if ( OppToken.transfer( msg.sender, holderList[contributor].tokens ) ) {
holderList[contributor].withdrawed = true;
TokensTransfered(contributor, holderList[contributor].tokens);
}
} else {
revert();
}
} else {
revert();
}
}
| 1
| 4,767
|
function list_frozen_accounts(uint _max_num_of_items_to_display) public view
returns (uint _num,address[] _frozen_holders,uint[] _whens){
uint len = holders_frozen.length;
uint num_of_frozen_holders = 0;
if(_max_num_of_items_to_display==0) _max_num_of_items_to_display=1;
for (uint i = len-1 ; i >= 0 ; i--) {
if( account_frozen_time[ holders_frozen[i] ] > 0x0) num_of_frozen_holders++;
if(_max_num_of_items_to_display == num_of_frozen_holders) break;
}
_frozen_holders = new address[](num_of_frozen_holders);
_whens = new uint[](num_of_frozen_holders);
_num=0;
for (uint j = len-1 ; j >= 0 && num_of_frozen_holders > _num ; j--) {
address addr= holders_frozen[j];
uint256 when= account_frozen_time[ addr ];
if( when == 0x0) continue;
_frozen_holders[_num]= addr;
_whens[_num]= when;
_num++;
}
}
| 0
| 13,339
|
function distributeVault(uint256 _pID, uint256 _rID, uint256 _affID, uint256 _eth, uint256 _tickets)
private
{
uint256 _gen = 0;
uint256 _genvault = 0;
uint256 ticketprice_ = getBuyPrice();
if (round_[_rID].tickets > _headtickets){
if (round_[_rID].tickets.sub(_tickets) > _headtickets){
_gen = _tickets;
}else{
_gen = round_[_rID].tickets.sub(_headtickets);
}
}
if (_gen > 0){
_genvault = ((ticketprice_ * _gen).mul(20)) / 100;
round_[_rID].mask = _genvault.add(round_[_rID].mask);
}
uint256 _aff = _eth / 10;
uint256 _com = _eth / 20;
uint256 _found = _eth.mul(32) / 100;
round_[_rID].found = _found.add(round_[_rID].found);
if (_affID != 0){
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
community_addr.transfer(_com);
}else{
_com = _com.add(_aff);
community_addr.transfer(_com);
}
uint256 _nextpot = _eth.sub(_genvault);
if (_affID != 0){
_nextpot = _nextpot.sub(_aff);
}
_nextpot = _nextpot.sub(_com);
_nextpot = _nextpot.sub(_found);
round_[_rID].nextpot = _nextpot.add(round_[_rID].nextpot);
}
| 0
| 15,606
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.