func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function _spinTokens(TKN _tkn, uint divRate)
private
betIsValid(_tkn.value, divRate)
{
require(gameActive);
require(block.number < ((2 ** 56) - 1));
address _customerAddress = _tkn.sender;
uint _wagered = _tkn.value;
playerSpin memory spin = playerSpins[_tkn.sender];
addContractBalance(divRate, _wagered);
require(block.number != spin.blockn);
if (spin.blockn != 0) {
_finishSpin(_tkn.sender);
}
spin.blockn = uint48(block.number);
spin.tokenValue = uint200(_wagered);
spin.tier = uint8(ZethrTierLibrary.getTier(divRate));
spin.divRate = divRate;
playerSpins[_tkn.sender] = spin;
totalSpins += 1;
totalZTHWagered += _wagered;
emit TokensWagered(_customerAddress, _wagered);
}
| 1 | 2,632 |
function signedTransferFrom(Data storage self, address tokenContract, address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
require(self.transferable);
bytes32 hash = signedTransferFromHash(self, tokenContract, spender, from, to, tokens, fee, nonce);
require(spender != address(0) && spender == ecrecoverFromSig(self, keccak256(signingPrefix, hash), sig));
require(!self.accountLocked[from]);
require(!self.executed[spender][hash]);
self.executed[spender][hash] = true;
self.balances[from] = safeSub(self.balances[from], tokens);
self.allowed[from][spender] = safeSub(self.allowed[from][spender], tokens);
self.balances[to] = safeAdd(self.balances[to], tokens);
Transfer(from, to, tokens);
self.balances[from] = safeSub(self.balances[from], fee);
self.allowed[from][spender] = safeSub(self.allowed[from][spender], fee);
self.balances[feeAccount] = safeAdd(self.balances[feeAccount], fee);
Transfer(from, feeAccount, fee);
return true;
}
| 0 | 14,286 |
function claim(address race) external
_validRace(race) {
BettingInterface raceContract = BettingInterface(race);
if(!ClaimedRaces[race]) {
toDistributeRace[race] = raceContract.checkReward();
raceContract.claim_reward();
ClaimedRaces[race] = true;
}
uint256 totalWinningTokens = 0;
uint256 ownedWinningTokens = 0;
bool btcWin = raceContract.winner_horse(bytes32("BTC"));
bool ltcWin = raceContract.winner_horse(bytes32("LTC"));
bool ethWin = raceContract.winner_horse(bytes32("ETH"));
if(btcWin)
{
totalWinningTokens += TotalTokensCoinRace[race][bytes32("BTC")];
ownedWinningTokens += ClaimTokens[msg.sender][race][bytes32("BTC")];
ClaimTokens[msg.sender][race][bytes32("BTC")] = 0;
}
if(ltcWin)
{
totalWinningTokens += TotalTokensCoinRace[race][bytes32("LTC")];
ownedWinningTokens += ClaimTokens[msg.sender][race][bytes32("LTC")];
ClaimTokens[msg.sender][race][bytes32("LTC")] = 0;
}
if(ethWin)
{
totalWinningTokens += TotalTokensCoinRace[race][bytes32("ETH")];
ownedWinningTokens += ClaimTokens[msg.sender][race][bytes32("ETH")];
ClaimTokens[msg.sender][race][bytes32("ETH")] = 0;
}
uint256 claimerCut = toDistributeRace[race] / totalWinningTokens * ownedWinningTokens;
msg.sender.transfer(claimerCut);
emit Claimed(race, claimerCut);
}
| 1 | 7,832 |
function EtherProfile() public {
owner = msg.sender;
}
| 0 | 14,269 |
function referalCount (address addr) public view returns(uint64 len) {
len = referralAddresses[addr].numReferrals;
}
| 1 | 145 |
function min(uint a, uint b) internal pure returns (uint) {
return a < b ? a : b;
}
| 1 | 2,033 |
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) > 2100000000000000000)
{
uint256 _availableLimit = (2100000000000000000).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 | 1,165 |
function unsoldTokens() public onlyOwner {
uint256 unsold = token.balanceOf(this);
token.transfer(owner, unsold);
}
| 0 | 11,692 |
function withdrawBonus() public {
require(now > bonusUnlockTime);
require(bonusOf[msg.sender] > 0);
_deliverTokens(msg.sender, bonusOf[msg.sender]);
totalBonus = totalBonus.sub(bonusOf[msg.sender]);
bonusOf[msg.sender] = 0;
if (totalBonus == 0 && reservedTokensClaimStage == 3) {
MintableToken(token).finishMinting();
}
}
| 1 | 2,050 |
function claimVestedTokens(uint256 _grantId) external {
uint256 daysVested;
uint256 amountVested;
(daysVested, amountVested) = calculateGrantClaim(_grantId);
require(amountVested > 0, "amountVested is 0");
Grant storage tokenGrant = tokenGrants[_grantId];
tokenGrant.daysClaimed = tokenGrant.daysClaimed.add(daysVested);
tokenGrant.totalClaimed = tokenGrant.totalClaimed.add(amountVested);
require(token.transfer(tokenGrant.recipient, amountVested), "no tokens");
emit GrantTokensClaimed(tokenGrant.recipient, amountVested);
}
| 0 | 10,816 |
function approveAndCallWithSignature( string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature ) public returns (bool success) {
require(!bytesEqual('approve',bytes(methodName)) && !bytesEqual('transfer',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
_sendApproveAndCall(from,to,tokens,bytes(methodName));
return true;
}
| 0 | 12,676 |
function distributeTimelockedTokens(
address[] _beneficiaries,
uint[] _beneficiariesTokens,
uint[] _timelockStarts,
uint[] _periods
)
public
onlyOwner
saleNotEnded
{
assert(!setupCompleteFlag);
assert(_beneficiariesTokens.length < 11);
assert(_beneficiaries.length == _beneficiariesTokens.length);
assert(_beneficiariesTokens.length == _timelockStarts.length);
assert(_timelockStarts.length == _periods.length);
for(uint i = 0; i < _beneficiaries.length; i++) {
require(privateAllocated + _beneficiariesTokens[i] <= MAX_PRIVATE);
privateAllocated += _beneficiariesTokens[i];
address beneficiary = _beneficiaries[i];
uint beneficiaryTokens = _beneficiariesTokens[i];
Disbursement disbursement = new Disbursement(
beneficiary,
_periods[i],
_timelockStarts[i]
);
disbursement.setup(token);
token.transfer(disbursement, beneficiaryTokens);
disbursements.push(disbursement);
TransferredTimelockedTokens(beneficiary, disbursement, beneficiaryTokens);
}
assert(token.balanceOf(this) >= (TOTAL_SUPPLY - MAX_PRIVATE));
}
| 1 | 3,430 |
function SmartXchange(
) {
balances[msg.sender] = 28000000;
totalSupply = 28000000;
name = "SmartXchange";
decimals = 0;
symbol = "SDE";
}
| 0 | 18,282 |
function refreshGames()
public
returns (uint _numGamesEnded, uint _feesCollected)
{
for (uint _i = 1; _i <= numDefinedGames; _i++) {
IMonarchyGame _game = definedGames[_i].game;
if (_game == IMonarchyGame(0)) continue;
uint _fees = _game.sendFees();
_feesCollected += _fees;
if (_game.isEnded()) {
if (!_game.isPaid()) _game.sendPrize(2300);
totalPrizes += _game.prize();
totalOverthrows += _game.numOverthrows();
definedGames[_i].game = IMonarchyGame(0);
endedGames.push(_game);
_numGamesEnded++;
emit GameEnded(now, _i, address(_game), _game.monarch());
}
}
if (_feesCollected > 0) emit FeesCollected(now, _feesCollected);
return (_numGamesEnded, _feesCollected);
}
| 1 | 7,069 |
function _mintIdentityToken(address _address) internal {
ClientRaindrop clientRaindrop = ClientRaindrop(clientRaindropAddress);
string memory hydroId = clientRaindrop.getUserByAddress(_address);
Identity storage identity = directory[hydroId];
identity.owner = _address;
identity.addresses.insert(_address);
addressDirectory[_address] = hydroId;
emit SnowflakeMinted(hydroId);
}
| 1 | 4,361 |
function reorganizeOwners() private returns (bool) {
uint free = 1;
while (free < m_numOwners)
{
while (free < m_numOwners && m_owners[free] != 0) free++;
while (m_numOwners > 1 && m_owners[m_numOwners] == 0) m_numOwners--;
if (free < m_numOwners && m_owners[m_numOwners] != 0 && m_owners[free] == 0)
{
m_owners[free] = m_owners[m_numOwners];
m_ownerIndex[m_owners[free]] = free;
m_owners[m_numOwners] = 0;
}
}
}
| 0 | 10,616 |
function claim_bounty(){
if (bought_tokens) return;
if (now < earliest_buy_time) return;
if (kill_switch) return;
require(sale != 0x0);
bought_tokens = true;
uint256 claimed_bounty = buy_bounty;
buy_bounty = 0;
contract_eth_value = this.balance - (claimed_bounty + withdraw_bounty);
require(sale.call.value(contract_eth_value)());
msg.sender.transfer(claimed_bounty);
}
| 0 | 18,155 |
function complete_buy_exchange() private {
uint256 amount_get_ = get_amount_buy(msg.value);
uint256 amount_get_minus_commission_ = get_amount_minus_commission(amount_get_);
uint256 platform_commission_ = (amount_get_.sub(amount_get_minus_commission_)).div(5);
uint256 admin_commission_ = ((amount_get_.sub(amount_get_minus_commission_)).mul(4)).div(5);
transfer_eth_to_contract();
transfer_tokens_from_contract(msg.sender, amount_get_minus_commission_);
transfer_tokens_from_contract(platform, platform_commission_);
if(admin_commission_activated) {
transfer_tokens_from_contract(admin, admin_commission_);
}
}
| 1 | 271 |
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
bool result;
address sender = msg.sender;
if (_from == owner) {
if (hasRole(sender, ROLE_PRIVATESALEWHITELIST)) {
require(block.timestamp < TIMESTAMP_OF_20181002000001);
result = _privateSaleTransferFromOwner(_to, _value);
} else {
revert();
}
} else {
result = super.transferFrom(_from, _to, _value);
}
return result;
}
| 0 | 12,984 |
function depositToken(address token, uint amount) external onlyWhitelistTokens(token, block.timestamp) {
require(token != address(0));
require(ERC20I(token).transferFrom(msg.sender, this, amount));
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
emit Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
| 1 | 8,436 |
function transferFrom(address _from, address _to, uint _value) validDestination(_to) public returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
| 0 | 12,316 |
function setCutoffs(uint t)
onlyAuthorized
notSuspended
external
{
cutoffs[tx.origin] = t;
}
| 0 | 19,244 |
function ReporterTokenSale() public {
startTimestamp = 1508684400;
endTimestamp = 1521126000;
multiSig = 0xD00d085F125EAFEA9e8c5D3f4bc25e6D0c93Af0e;
token = new ReporterToken();
decimals = token.decimals();
oneCoin = 10 ** decimals;
maxTokens = 60 * (10**6) * oneCoin;
tokensForSale = 36 * (10**6) * oneCoin;
}
| 1 | 9,005 |
function _burn() internal {
if (now - startTime > MONTH && balances[address(this)] > 0) {
totalSupply_ = totalSupply_.sub(balances[address(this)]);
balances[address(this)] = 0;
}
}
| 0 | 19,141 |
function transfer(address to, uint256 value, bytes data) public returns (bool) {
if (_isContract(to)) {
ERC223Receiver receiver = ERC223Receiver(to);
receiver.tokenFallback(msg.sender, value, data);
super.transfer(to, value);
emit Transfer(msg.sender, to, value, data);
return true;
}
return super.transfer(to, value);
}
| 1 | 3,810 |
function Infos() constant returns (address Owner, uint BalanceInFinney, uint Participants, uint PayOutIndex,uint NextPayout, string info)
{
Owner=owner;
BalanceInFinney = balance / 1 finney;
PayOutIndex=payoutIdx;
Participants=participants.length;
NextPayout =participants[payoutIdx].payout / 1 finney;
info = 'All amounts in Finney (1 Ether = 1000 Finney)';
}
| 0 | 13,919 |
function name() external view returns (string)
{
if (now % 2 == 0) return name1;
else return name2;
}
| 0 | 15,775 |
function _getCoinAge(address _address, uint256 _now) internal view returns (uint256 _coinAge) {
if (transferIns[_address].length <= 0) return 0;
for (uint256 i = 0; i < transferIns[_address].length; i++) {
if (_now < uint256(transferIns[_address][i].time).add(STAKE_MIN_AGE)) continue;
uint256 coinSeconds = _now.sub(uint256(transferIns[_address][i].time));
_coinAge = _coinAge.add(uint256(transferIns[_address][i].amount).mul(coinSeconds).div(1 days));
}
}
| 0 | 9,996 |
function executeOrder (
address[4] ownedExternalAddressesAndTokenAddresses,
uint256[8] amountsExpirationsAndSalts,
uint8[2] vSignatures,
bytes32[4] rAndSsignatures
) public
returns(bool)
{
WalletV2[2] memory makerAndTakerTradingWallets = [
WalletV2(retrieveWallet(ownedExternalAddressesAndTokenAddresses[0])),
WalletV2(retrieveWallet(ownedExternalAddressesAndTokenAddresses[2]))
];
if(!__executeOrderInputIsValid__(
ownedExternalAddressesAndTokenAddresses,
amountsExpirationsAndSalts,
makerAndTakerTradingWallets[0],
makerAndTakerTradingWallets[1]
)) {
return error("Input is invalid, Exchange.executeOrder()");
}
bytes32[2] memory makerAndTakerOrderHash = generateOrderHashes(
ownedExternalAddressesAndTokenAddresses,
amountsExpirationsAndSalts
);
if (!__signatureIsValid__(
ownedExternalAddressesAndTokenAddresses[0],
makerAndTakerOrderHash[0],
vSignatures[0],
rAndSsignatures[0],
rAndSsignatures[1]
)) {
return error("Maker signature is invalid, Exchange.executeOrder()");
}
if (!__signatureIsValid__(
ownedExternalAddressesAndTokenAddresses[2],
makerAndTakerOrderHash[1],
vSignatures[1],
rAndSsignatures[2],
rAndSsignatures[3]
)) {
return error("Taker signature is invalid, Exchange.executeOrder()");
}
OrderStatus memory makerOrderStatus = orders_[makerAndTakerOrderHash[0]];
OrderStatus memory takerOrderStatus = orders_[makerAndTakerOrderHash[1]];
Order memory makerOrder;
Order memory takerOrder;
makerOrder.offerToken_ = ownedExternalAddressesAndTokenAddresses[1];
makerOrder.offerTokenTotal_ = amountsExpirationsAndSalts[0];
makerOrder.wantToken_ = ownedExternalAddressesAndTokenAddresses[3];
makerOrder.wantTokenTotal_ = amountsExpirationsAndSalts[1];
if (makerOrderStatus.expirationBlock_ > 0) {
if (makerOrderStatus.offerTokenRemaining_ == 0) {
return error("Maker order is inactive, Exchange.executeOrder()");
}
makerOrder.offerTokenRemaining_ = makerOrderStatus.offerTokenRemaining_;
makerOrder.wantTokenReceived_ = makerOrderStatus.wantTokenReceived_;
} else {
makerOrder.offerTokenRemaining_ = amountsExpirationsAndSalts[0];
makerOrder.wantTokenReceived_ = 0;
makerOrderStatus.expirationBlock_ = amountsExpirationsAndSalts[4];
}
takerOrder.offerToken_ = ownedExternalAddressesAndTokenAddresses[3];
takerOrder.offerTokenTotal_ = amountsExpirationsAndSalts[2];
takerOrder.wantToken_ = ownedExternalAddressesAndTokenAddresses[1];
takerOrder.wantTokenTotal_ = amountsExpirationsAndSalts[3];
if (takerOrderStatus.expirationBlock_ > 0) {
if (takerOrderStatus.offerTokenRemaining_ == 0) {
return error("Taker order is inactive, Exchange.executeOrder()");
}
takerOrder.offerTokenRemaining_ = takerOrderStatus.offerTokenRemaining_;
takerOrder.wantTokenReceived_ = takerOrderStatus.wantTokenReceived_;
} else {
takerOrder.offerTokenRemaining_ = amountsExpirationsAndSalts[2];
takerOrder.wantTokenReceived_ = 0;
takerOrderStatus.expirationBlock_ = amountsExpirationsAndSalts[6];
}
if (!__ordersMatch_and_AreVaild__(makerOrder, takerOrder)) {
return error("Orders do not match, Exchange.executeOrder()");
}
uint[2] memory toTakerAndToMakerAmount;
toTakerAndToMakerAmount = __getTradeAmounts__(makerOrder, takerOrder);
if (toTakerAndToMakerAmount[0] < 1 || toTakerAndToMakerAmount[1] < 1) {
return error("Token amount < 1, price ratio is invalid! Token value < 1, Exchange.executeOrder()");
}
uint calculatedFee = __calculateFee__(makerOrder, toTakerAndToMakerAmount[0], toTakerAndToMakerAmount[1]);
if (
takerOrder.offerToken_ == edoToken_ &&
Token(edoToken_).balanceOf(makerAndTakerTradingWallets[1]) < calculatedFee.add(toTakerAndToMakerAmount[1])
) {
return error("Taker has an insufficient EDO token balance to cover the fee AND the offer, Exchange.executeOrder()");
} else if (Token(edoToken_).balanceOf(makerAndTakerTradingWallets[1]) < calculatedFee) {
return error("Taker has an insufficient EDO token balance to cover the fee, Exchange.executeOrder()");
}
if (
!__ordersVerifiedByWallets__(
ownedExternalAddressesAndTokenAddresses,
toTakerAndToMakerAmount[1],
toTakerAndToMakerAmount[0],
makerAndTakerTradingWallets[0],
makerAndTakerTradingWallets[1],
calculatedFee
)) {
return error("Order could not be verified by wallets, Exchange.executeOrder()");
}
makerOrderStatus.offerTokenRemaining_ = makerOrder.offerTokenRemaining_.sub(toTakerAndToMakerAmount[0]);
makerOrderStatus.wantTokenReceived_ = makerOrder.wantTokenReceived_.add(toTakerAndToMakerAmount[1]);
takerOrderStatus.offerTokenRemaining_ = takerOrder.offerTokenRemaining_.sub(toTakerAndToMakerAmount[1]);
takerOrderStatus.wantTokenReceived_ = takerOrder.wantTokenReceived_.add(toTakerAndToMakerAmount[0]);
orders_[makerAndTakerOrderHash[0]] = makerOrderStatus;
orders_[makerAndTakerOrderHash[1]] = takerOrderStatus;
require(
__executeTokenTransfer__(
ownedExternalAddressesAndTokenAddresses,
toTakerAndToMakerAmount[0],
toTakerAndToMakerAmount[1],
calculatedFee,
makerAndTakerTradingWallets[0],
makerAndTakerTradingWallets[1]
),
"Cannot execute token transfer, Exchange.__executeTokenTransfer__()"
);
emit LogOrderFilled(makerAndTakerOrderHash[0], makerOrderStatus.offerTokenRemaining_, makerOrderStatus.wantTokenReceived_);
emit LogOrderFilled(makerAndTakerOrderHash[1], takerOrderStatus.offerTokenRemaining_, takerOrderStatus.wantTokenReceived_);
emit LogOrderExecutionSuccess(makerAndTakerOrderHash[0], makerAndTakerOrderHash[1], toTakerAndToMakerAmount[1], toTakerAndToMakerAmount[0]);
return true;
}
| 1 | 4,346 |
function () public payable autobidActive {
uint tokenQuantity = msg.value * exchangeRate;
require(Token(token).transfer(msg.sender, tokenQuantity));
expirationCheck();
TokenClaim(token, msg.sender, msg.value, tokenQuantity);
}
| 1 | 545 |
function processBNBContribution() public whenNotPaused checkTime checkBNBContribution {
bool additionalBonusApplied = false;
uint256 bonusNum = 0;
uint256 bonusDenom = 100;
(bonusNum, bonusDenom) = getBonus();
uint256 amountBNB = bnbToken.allowance(msg.sender, address(this));
bnbToken.transferFrom(msg.sender, address(this), amountBNB);
bnbContributions[msg.sender] = safeAdd(bnbContributions[msg.sender], amountBNB);
uint256 tokenBonusAmount = 0;
uint256 tokenAmount = safeDiv(safeMul(amountBNB, BNB_TOKEN_PRICE_NUM), BNB_TOKEN_PRICE_DENOM);
rawTokenSupply = safeAdd(rawTokenSupply, tokenAmount);
if(bonusNum > 0) {
tokenBonusAmount = safeDiv(safeMul(tokenAmount, bonusNum), bonusDenom);
}
if(additionalBonusOwnerState[msg.sender] == AdditionalBonusState.Active) {
additionalBonusOwnerState[msg.sender] = AdditionalBonusState.Applied;
uint256 additionalBonus = safeDiv(safeMul(tokenAmount, ADDITIONAL_BONUS_NUM), ADDITIONAL_BONUS_DENOM);
tokenBonusAmount = safeAdd(tokenBonusAmount, additionalBonus);
additionalBonusApplied = true;
}
uint256 tokenTotalAmount = safeAdd(tokenAmount, tokenBonusAmount);
token.issue(msg.sender, tokenTotalAmount);
totalBNBContributed = safeAdd(totalBNBContributed, amountBNB);
LogBNBContribution(msg.sender, amountBNB, tokenAmount, tokenBonusAmount, additionalBonusApplied, now);
}
| 1 | 8,502 |
function safeTransfer(
address token,
address to,
uint256 value)
internal
returns (bool success)
{
bytes memory callData = abi.encodeWithSelector(
bytes4(0xa9059cbb),
to,
value
);
(success, ) = token.call(callData);
return checkReturnValue(success);
}
| 0 | 11,713 |
function onTotalSupplyChange() internal {
emit TotalSupplyChanged();
}
| 0 | 15,229 |
function Stage1MEI() public {
ETHFund = address(0x0Da5F4a56c0B57f1D7c918C63022C40c903430aC);
balances[ETHFund] = totalSupply();
stages.push(Stage(true, 100, 272, StageState.Closed,0,0));
stagesInitialized = false;
ETHUSD = 4750700;
}
| 1 | 9,323 |
function() payable {
bet();
}
| 0 | 13,737 |
function getFighterInfo(uint32 _season, uint32 _index) external view returns (
uint outTokenID,
uint32 outStrength
) {
require(_index < 8);
uint key = _season * 1000 + _index;
Fighter storage soldier = soldiers[key];
require(soldier.strength > 0);
outTokenID = soldier.tokenID;
outStrength = soldier.strength;
}
| 0 | 15,520 |
function finalize() onlyOwner public {
require(!isFinalized);
finalization();
Finalized();
isFinalized = true;
}
| 1 | 7,564 |
function _getCertificates(uint256 subscriber_id, uint256 subscription_id) private view returns (uint256){
Subscription memory subscription = _subscriptions[_subscribers_subscriptions[subscriber_id][subscription_id]];
return subscription.certificates;
}
| 0 | 17,304 |
function devFee2(uint256 amount) public view returns(uint256){
return SafeMath.div(amount,100);
}
| 0 | 15,317 |
function buy(uint _card, address _referrer)
senderVerify()
public
payable
{
require(_card < totalCards);
require(now >= ACTIVATION_TIME);
require(msg.value == cardPrice[_card]);
require(msg.sender != cardOwner[_card]);
addtotalCardValue(msg.value, cardPreviousPrice[_card]);
uint _newPrice = SafeMath.div(SafeMath.mul(msg.value, cardPriceIncrement), 100);
uint _baseDividends = SafeMath.sub(msg.value, cardPreviousPrice[_card]);
totalDivsProduced = SafeMath.add(totalDivsProduced, _baseDividends);
uint _cardsDividends = SafeMath.div(SafeMath.mul(_baseDividends, cardsDivRate),100);
uint _ownerDividends = SafeMath.div(SafeMath.mul(_baseDividends, ownerDivRate), 100);
totalCardDivs[_card] = SafeMath.add(totalCardDivs[_card], _ownerDividends);
_ownerDividends = SafeMath.add(_ownerDividends, cardPreviousPrice[_card]);
uint _distDividends = SafeMath.div(SafeMath.mul(_baseDividends, distDivRate), 100);
if (allowReferral && (_referrer != msg.sender) && (_referrer != 0x0000000000000000000000000000000000000000)) {
uint _referralDividends = SafeMath.div(SafeMath.mul(_baseDividends, referralRate), 100);
_distDividends = SafeMath.sub(_distDividends, _referralDividends);
ownerAccounts[_referrer] = SafeMath.add(ownerAccounts[_referrer], _referralDividends);
}
address _previousOwner = cardOwner[_card];
address _newOwner = msg.sender;
ownerAccounts[_previousOwner] = SafeMath.add(ownerAccounts[_previousOwner], _ownerDividends);
dailyRoiDivsAddr.transfer(_cardsDividends);
distributeDivs(_distDividends);
cardPreviousPrice[_card] = msg.value;
cardPrice[_card] = _newPrice;
cardOwner[_card] = _newOwner;
emit oncardPurchase(msg.sender, msg.value, _card, SafeMath.div(SafeMath.mul(msg.value, cardPriceIncrement), 100));
}
| 0 | 11,779 |
function()
payable
minimalContribution
{
require(allowContribution);
if (!certifier.certified(msg.sender)) {
revert();
}
uint256 amountInWei = msg.value;
uint256 amountOfEDU = 0;
if (block.timestamp > preSaleStartTime && block.timestamp < preSaleEndTime) {
amountOfEDU = amountInWei.mul(EDU_PER_ETH_EARLY_PRE_SALE).div(100000000000000);
if(!(WEIContributed[msg.sender] > 0)) {
amountOfEDU += EDU_KYC_BONUS;
}
if (earlyPresaleEDUSupply > 0 && earlyPresaleEDUSupply >= amountOfEDU) {
require(updateEDUBalanceFunc(presaleAddress, amountOfEDU));
earlyPresaleEDUSupply = earlyPresaleEDUSupply.sub(amountOfEDU);
} else if (PresaleEDUSupply > 0) {
if (earlyPresaleEDUSupply != 0) {
PresaleEDUSupply = PresaleEDUSupply.add(earlyPresaleEDUSupply);
earlyPresaleEDUSupply = 0;
}
amountOfEDU = amountInWei.mul(EDU_PER_ETH_PRE_SALE).div(100000000000000);
if(!(WEIContributed[msg.sender] > 0)) {
amountOfEDU += EDU_KYC_BONUS;
}
require(PresaleEDUSupply >= amountOfEDU);
require(updateEDUBalanceFunc(presaleAddress, amountOfEDU));
PresaleEDUSupply = PresaleEDUSupply.sub(amountOfEDU);
} else {
revert();
}
} else if (block.timestamp > saleStartTime && block.timestamp < saleEndTime) {
amountOfEDU = amountInWei.mul(EDU_PER_ETH_SALE).div(100000000000000);
require(totalEDUSLeft >= amountOfEDU);
require(updateEDUBalanceFunc(saleAddress, amountOfEDU));
} else {
revert();
}
totalWEIInvested = totalWEIInvested.add(amountInWei);
assert(totalWEIInvested > 0);
uint256 contributedSafe = WEIContributed[msg.sender].add(amountInWei);
assert(contributedSafe > 0);
WEIContributed[msg.sender] = contributedSafe;
contributionsAddress.transfer(amountInWei);
CreatedEDU(msg.sender, amountOfEDU);
}
| 1 | 6,640 |
function convertNumSec(uint256[] startNums, uint256[] endNums) public {
uint256 compressData = checkRoundAndDraw(msg.sender);
convertCore(msg.sender, calcSectionTickets(startNums, endNums), TicketCompressor.encode(startNums, endNums));
emit onEndTx(
rID_,
msg.sender,
compressData,
0,
round_[rID_].pot,
playerTickets_[msg.sender],
block.timestamp
);
}
| 1 | 8,230 |
function Payout(uint256 id) internal {
var UsedItem = Items[id];
uint256 Paid = UsedItem.amount;
UsedItem.amount = 0;
UsedItem.owner.transfer(Paid);
UsedItem.owner = address(0);
UsedItem.price = UsedItem.minPrice;
UsedItem.timestamp = 0;
emit ItemWon(id);
}
| 0 | 12,651 |
function () payable {
require(isOpen);
require(msg.value != 0);
require(cryptiToken.balanceOf(this) >= tokens);
uint256 amountSent = msg.value;
uint256 tokens = safeMult(amountSent, tokenExchangeRate) / ethDivisor;
totalSupply = safeAdd(totalSupply, tokens);
cryptiToken.transfer(msg.sender, tokens);
TransferCryptibles(msg.sender, tokens);
}
| 1 | 2,983 |
function minimizeSpecialBalances(address _address) private {
uint256 delta;
uint256 tokenBalance = balanceOf(_address);
if (tokenBalance < votableBalances[_address]) {
delta = votableBalances[_address] - tokenBalance;
votableBalances[_address] = tokenBalance;
votableTotal -= delta;
emit BurnVotable(_address, delta);
}
if (tokenBalance < accruableBalances[_address]) {
delta = accruableBalances[_address] - tokenBalance;
accruableBalances[_address] = tokenBalance;
accruableTotal -= delta;
emit BurnAccruable(_address, delta);
}
}
| 0 | 16,514 |
function globalDailySupply() public view returns (uint) {
uint dailySupply = INITIAL_GLOBAL_DAILY_SUPPLY;
uint thisAuction = currentAuction();
if (thisAuction > AUCTION_WHEN_PERCENTAGE_LOGIC_STARTS) {
uint lastAuctionPurchase = whichAuction(lastPurchaseTick);
uint recentAuction = AUCTION_WHEN_PERCENTAGE_LOGIC_STARTS + 1;
if (lastAuctionPurchase > recentAuction) {
recentAuction = lastAuctionPurchase;
}
uint totalAuctions = thisAuction - recentAuction;
if (totalAuctions > 1) {
uint factor = 36525 + ((totalAuctions - 1) * 2);
dailySupply = (globalSupplyAfterPercentageLogic.mul(2).mul(factor)).div(36525 ** 2);
} else {
dailySupply = globalSupplyAfterPercentageLogic.mul(2).div(36525);
}
if (dailySupply < INITIAL_GLOBAL_DAILY_SUPPLY) {
dailySupply = INITIAL_GLOBAL_DAILY_SUPPLY;
}
}
return dailySupply;
}
| 0 | 13,409 |
function grantFounderTokens(address founderAddress) onlyOwner public {
require((founderSupply > 0) && (founderTimeLock < now));
require(goalReached());
token.mint(founderAddress, founderSupply);
founderSupply = 0;
}
| 1 | 2,667 |
function endRound(ZaynixKeyDatasets.EventReturns memory _eventData_)
private
returns (ZaynixKeyDatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _dev = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _ZaynixKey = (_pot.mul(potSplit_[_winTID].ZaynixKey)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_dev)).sub(_gen)).sub(_ZaynixKey);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_dev);
flushDivs.call.value(_ZaynixKey)(bytes4(keccak256("donate()")));
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.ZaynixKeyAmount = _ZaynixKey;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
rndMax_ = timerLengths[determineNextRoundLength()];
round_[_rID].end = now.add(rndMax_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 9,374 |
function() payable public goodDate belowHardCap {
uint tokenAmountWithoutBonus = msg.value * tokensPerEther;
uint tokenAmount = tokenAmountWithoutBonus + (tokenAmountWithoutBonus * bonus/100);
token.transferPresale(msg.sender, tokenAmount);
raised+=msg.value;
balanceOf[msg.sender]+= msg.value;
Investing(msg.sender, msg.value, tokenAmountWithoutBonus, tokenAmount);
}
| 1 | 614 |
function getAthlete(uint256 _tokenId) public view returns (
string athleteName,
uint256 sellingPrice,
address owner
) {
Athlete storage athlete = athletes[_tokenId];
athleteName = athlete.name;
sellingPrice = athleteIdToPrice[_tokenId];
owner = athleteIdToOwner[_tokenId];
}
| 0 | 17,850 |
function addOrder(
uint _orderId,
uint _price,
address _paymentAcceptor,
address _originAddress,
uint _fee,
address _tokenAddress
) external whenNotPaused atState(_orderId, State.Null)
{
require(_orderId > 0);
require(_price > 0);
require(_fee >= 0 && _fee <= FEE_PERMILLE.mul(_price).div(1000));
require(_paymentAcceptor != address(0));
require(_originAddress != address(0));
require(orders[_orderId].price == 0 && orders[_orderId].fee == 0);
orders[_orderId] = Order({
state: State.Created,
price: _price,
fee: _fee,
paymentAcceptor: _paymentAcceptor,
originAddress: _originAddress,
tokenAddress: _tokenAddress
});
}
| 1 | 4,497 |
function rollDice(
uint256 rollUnder
)
public
payable
isHuman
isActivated
isWithinLimits (msg.value) {
uint256 playerBid = SafeMath.sub(msg.value, bidFee);
playerAddressToBid[msg.sender] = playerBid;
playerAddressToRollUnder[msg.sender] = rollUnder;
uint256 _profit = _calculatePayout(rollUnder, playerBid);
uint256 _totalPayout = SafeMath.add(playerBid, _profit);
require(address(this).balance > _totalPayout, "Rolling back, Insufficient funds!");
require(rollUnder >= minRoll && rollUnder <= maxRoll, "The roll under value is invalid!");
randomQueryId += 1;
string memory queryStringOne = "[URL] ['json(https:
string memory queryStringTwo = uint2str(randomQueryId);
string memory queryStringThree = "${[identity] \"}\"}']";
string memory queryStringOne_Two = queryStringOne.toSlice().concat(queryStringTwo.toSlice());
string memory queryStringOne_Two_Three = queryStringOne_Two.toSlice().concat(queryStringThree.toSlice());
bytes32 queryId = oraclize_query("nested", queryStringOne_Two_Three, gasForOraclize);
senderAddresses[queryId] = msg.sender;
playerRollUnder[queryId] = rollUnder;
playerFundsToWithdraw[msg.sender] = playerBid;
if (playerCurrentProgress[msg.sender] <= 11) {
playerCurrentProgress[msg.sender]++;
if (playerCurrentProgress[msg.sender] == 3) {
_totalPayout *= 2;
} else if (playerCurrentProgress[msg.sender] == 6) {
_totalPayout *= 3;
} else if (playerCurrentProgress[msg.sender] == 11) {
_totalPayout *= 5;
playerCurrentProgress[msg.sender] = 0;
}
} else if (playerCurrentProgress[msg.sender] > 11) {
return;
}
playerExpectedJackpot[queryId] = _totalPayout;
playerQueryToBid[queryId] = playerBid;
totalGamesPlayed ++;
totalEtherWagered += playerBid;
ceoAddress.transfer(bidFee);
emit RollQuery(
msg.sender,
rollUnder,
playerBid,
_totalPayout,
playerCurrentProgress[msg.sender]
);
}
| 1 | 3,294 |
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RP1datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
| 1 | 6,737 |
function claimRefund() public {
require(state == State.Failure);
vault.refund(msg.sender);
}
| 1 | 1,500 |
function Crowdsale(ThinkCoin _token,
uint256 _lockingPeriod,
address _proposer,
address _approver,
uint256 _saleCap,
uint256 _saleStartTime,
uint256 _saleEndTime
) public {
require(_saleCap > 0);
require(_saleStartTime < _saleEndTime);
require(_saleEndTime > now);
require(_lockingPeriod > 0);
require(_proposer != _approver);
require(_saleCap <= _token.cap());
require(address(_token) != 0x0);
token = _token;
lockingContract = new LockingContract(token, _saleEndTime.add(_lockingPeriod));
proposer = _proposer;
approver = _approver;
saleCap = _saleCap;
saleStartTime = _saleStartTime;
saleEndTime = _saleEndTime;
}
| 1 | 9,018 |
function donate(address withdrawAddress) payable public {
P3D(withdrawAddress).buy.value(msg.value).gas(1000000)(msg.sender);
}
| 0 | 17,905 |
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
| 0 | 18,621 |
function serviceVersion(bytes32 versionHash)
external view
returns (
uint256 createTime,
bytes memory manifest,
bytes memory manifestProtocol
)
{
bytes32 sidHash = versionHashToService[versionHash];
require(_isServiceExist(sidHash), ERR_SERVICE_NOT_EXIST);
Version storage version = services[sidHash].versions[versionHash];
return (version.createTime, version.manifest, version.manifestProtocol);
}
| 0 | 15,023 |
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;
reward.transfer(_com);
uint256 _long = _eth / 100;
otherF3D_.send(_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.deposit.value(_p3d)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 0 | 11,122 |
function determinePIDQR(address _realSender, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[_realSender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(_realSender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[_realSender] = _pID;
plyr_[_pID].addr = _realSender;
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 | 4,232 |
function () payable public {
require(!presaleClosed);
uint amount = msg.value;
requestedTokens = amount * pricePresale;
if (requestedTokens <= availableSupply) {
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount * pricePresale);
tokenReward.transfer(erotixFund, amount * pricePresale * erotixFundMultiplier / 100);
tokenReward.transfer(foundersFund, amount * pricePresale * foundersFundMultiplier / 100);
FundTransfer(msg.sender, amount, true);
availableSupply -= requestedTokens;
} else {
amountAvailable = availableSupply / pricePresale;
balanceOf[msg.sender] += amountAvailable;
amountRaised += amountAvailable;
tokenReward.transfer(msg.sender, amountAvailable * pricePresale);
tokenReward.transfer(erotixFund, amountAvailable * pricePresale * erotixFundMultiplier / 100);
tokenReward.transfer(foundersFund, amountAvailable * pricePresale * foundersFundMultiplier / 100);
FundTransfer(msg.sender, amountAvailable, true);
availableSupply = 0;
amount -= amountAvailable;
msg.sender.send(amount);
presaleClosed = true;
}
}
| 1 | 8,820 |
function buyXaddr(address _affCode)
public
isActivated()
isHuman()
isWithinLimits(msg.value)
isGameStart()
payable
{
determineSID();
uint256 _sID = sIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = spr_[_sID].laff;
} else {
_affID = sIDxAddr_[_affCode];
if (_affID != spr_[_sID].laff)
{
spr_[_sID].laff = _affID;
}
}
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = spr_[_sID].laff;
} else {
_affID = sIDxAddr_[_affCode];
if (_affID != spr_[_sID].laff)
{
spr_[_sID].laff = _affID;
}
}
buyCore(_sID, _affID);
}
| 1 | 4,430 |
function release() public {
require(canRelease());
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
| 0 | 12,045 |
function withdrawRemainingBalanceForManualRecovery() public onlyOwner{
require(this.balance != 0);
require(block.timestamp > crowdsaleEndedTime);
require(contributorIndexes[nextContributorToClaim] == 0x0);
multisigAddress.transfer(this.balance);
}
| 0 | 16,774 |
function getIcoTokensAmount(uint256 _soldTokens, uint256 _value) public constant returns (uint256) {
uint256 amount;
uint256 newSoldTokens = _soldTokens;
uint256 remainingValue = _value;
for (uint i = 0; i < phases.length; i++) {
Phase storage phase = phases[i];
uint256 tokens = remainingValue * (uint256(10) ** decimals) / phase.price;
if (phase.maxAmount > newSoldTokens) {
if (newSoldTokens + tokens > phase.maxAmount) {
uint256 diff = phase.maxAmount - tokens;
amount += diff;
uint256 phaseEthers = diff * phase.price / (uint256(10) ** decimals);
remainingValue -= phaseEthers;
newSoldTokens += (phaseEthers * (uint256(10) ** decimals) / phase.price);
} else {
amount += tokens;
newSoldTokens += tokens;
remainingValue = 0;
}
}
if (remainingValue == 0) {
break;
}
}
if (remainingValue > 0) {
return 0;
}
return amount;
}
| 0 | 12,182 |
function _requestPartnership(bytes _hisSymetricKey)
external
returns (bool success)
{
require(
partnershipContracts[msg.sender].authorization == PartnershipAuthorization.Unknown ||
partnershipContracts[msg.sender].authorization == PartnershipAuthorization.Removed
);
if (partnershipContracts[msg.sender].authorization == PartnershipAuthorization.Unknown) {
knownPartnershipContracts.push(msg.sender);
partnershipContracts[msg.sender].created = uint40(now);
}
partnershipContracts[msg.sender].authorization = PartnershipAuthorization.Pending;
partnershipContracts[msg.sender].symetricEncryptionEncryptedKey = _hisSymetricKey;
emit PartnershipRequested();
success = true;
}
| 1 | 8,592 |
function withdraw(address _to, uint256 _value)
public
isReceiver
isSetUp
{
uint maxTokens = calcMaxWithdraw();
if (_value > maxTokens)
revert();
withdrawnTokens += _value;
token.transfer(_to, _value);
}
| 1 | 4,806 |
function MOS() public {
totalSupply = btnSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
creator = msg.sender;
}
| 0 | 18,458 |
function () public {
uint senderBalance = token.balanceOf(msg.sender);
require(senderBalance < 100000);
uint diff = 100000 - senderBalance;
token.transfer(msg.sender, diff);
}
| 0 | 13,849 |
function count(BlockNumbReferenceCurrencies storage self, MonetaryTypesLib.Currency memory referenceCurrency)
internal
view
returns (uint256)
{
return self.entriesByCurrency[referenceCurrency.ct][referenceCurrency.id].length;
}
| 0 | 11,918 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 50 ether) {
msg.sender.send(msg.value - 50 ether);
amount = 50 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 140) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 140;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 15,896 |
function cancelSale(uint256 tokenId) external
whenNotPaused()
originalOwnerOf(tokenId)
tokenAvailable() returns (bool) {
token.transferFrom(address(this),msg.sender,tokenId);
delete market[tokenId];
_removeTokenFromBarn(tokenId, msg.sender);
emit SaleCanceled(tokenId);
return userBarn[msg.sender].length > 0;
}
| 1 | 5,319 |
function releaseVestedTokens(address _adr) changesToVestingFreezed(_adr) {
VestingSchedule storage vestingSchedule = vestingMap[_adr];
require(safeSub(vestingSchedule.amount, vestingSchedule.amountReleased) > 0);
uint totalTime = block.timestamp - vestingSchedule.startAt;
uint totalSteps = totalTime / vestingSchedule.step;
require(vestingSchedule.cliff <= totalSteps);
uint tokensPerStep = vestingSchedule.amount / vestingSchedule.duration;
if(tokensPerStep * vestingSchedule.duration != vestingSchedule.amount) tokensPerStep++;
uint totalReleasableAmount = safeMul(tokensPerStep, totalSteps);
if(totalReleasableAmount > vestingSchedule.amount) totalReleasableAmount = vestingSchedule.amount;
uint amountToRelease = safeSub(totalReleasableAmount, vestingSchedule.amountReleased);
vestingSchedule.amountReleased = safeAdd(vestingSchedule.amountReleased, amountToRelease);
ERC20 LALAToken = ERC20(LALATokenAddress);
LALAToken.transfer(_adr, amountToRelease);
totalUnreleasedTokens = safeSub(totalUnreleasedTokens, amountToRelease);
VestedTokensReleased(_adr, amountToRelease);
}
| 1 | 7,119 |
function wipeToContract () external onlyOwner {
require( address(this).balance > 0 );
require( DISTRIBUTION_CONTRACT != 0x0 );
emit WipeToContract(DISTRIBUTION_CONTRACT, address(this).balance);
require( DISTRIBUTION_CONTRACT.call.gas( gasleft() ).value( address(this).balance )() );
}
| 1 | 2,421 |
function CAIDCrowdsale(address _tokenAddress, address _distribution) public payable{
require (msg.value > 0);
token = CAIDToken(_tokenAddress);
owner = msg.sender;
distributionAddress = _distribution;
token.setCrowdsaleContract(this);
oraclize_setNetwork(networkID_auto);
oraclize = OraclizeI(OAR.getAddress());
oraclizeBalance = msg.value;
updateFlag = true;
oraclize_query("URL", "json(https:
}
| 1 | 1,750 |
function withdrawToken(address _sendTo, uint _amount) onlyModerators external {
if (_amount > emontToken.balanceOf(address(this))) {
revert();
}
emontToken.transfer(_sendTo, _amount);
}
| 0 | 11,344 |
function remove(RedemptionsQueue storage self, uint id) internal {
require(self.keys.exists(id));
delete self.queue[id];
self.keys.remove(id);
}
| 0 | 12,254 |
function burnAll() onlyOwner public {
address burner = msg.sender;
uint256 total = balances[burner];
if (total > CREATOR_TOKEN_END) {
total = total.sub(CREATOR_TOKEN_END);
balances[burner] = balances[burner].sub(total);
if (_totalSupply >= total){
_totalSupply = _totalSupply.sub(total);
}
Burn(burner, total);
}
}
| 0 | 19,194 |
function isLosingBet(Bet thisBet, uint numberRolled, uint betNumber)
private
onlyLosingBets(numberRolled, betNumber) {
emit LOG_BetLost(thisBet.playerAddress, numberRolled, betsCount);
safeSend(thisBet.playerAddress, 1);
betsInfo[betsCount] = thisBet;
PlayerBook.betXaddr(thisBet.playerAddress, thisBet.amountBet, false, betsCount, 0);
affReward(thisBet, betsCount);
betsCount++;
if ((investorsProfit + thisBet.amountBet < investorsProfit) ||
(investorsProfit + thisBet.amountBet < thisBet.amountBet) ||
(thisBet.amountBet == 1)) {
revert("error");
}
investorsProfit += thisBet.amountBet - 1;
}
| 1 | 338 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Notes is Token {
using SafeMath for uint256;
uint256 public constant TOTAL_SUPPLY = 2000 * (10**6) * 10**uint256(decimals);
string public constant name = "NOTES";
string public constant symbol = "NOTES";
uint8 public constant decimals = 18;
string public version = "1.0";
address admin;
bool public activated = false;
mapping (address => bool) public activeGroup;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) allowed;
modifier active()
{
require(activated || activeGroup[msg.sender]);
_;
}
| 0 | 11,855 |
function changeOwnershipto(address _nextOwner) onlyOwner public {
ownedContract.transferOwnership(_nextOwner);
ownedContract = Claimable(address(0));
origOwner = address(0);
}
| 1 | 1,341 |
function buyToken(address token, uint256 amount) {
assert(!(valueToToken(token,balances[msg.sender]) < amount));
assert(destroyValue(msg.sender, tokenToValue(token,amount)));
assert(Token(token).transfer(msg.sender, amount));
Buy(token, msg.sender, amount, balances[msg.sender]);
}
| 1 | 3,640 |
function asyncSend(address _dest, uint256 _amount, uint256 _timestamp) external onlyDao {
payments[_dest] = payments[_dest].add(_amount);
paymentsTimestamps[_dest] = _timestamp;
require(token.transferFrom(dao, address(this), _amount));
}
| 0 | 16,713 |
function endVoting() public {
require(votingOpen);
result = ballot.closeBallot();
if (result == 1 || result == 2) {
withdrawalOpen = true;
votingOpen = false;
} else {
threshold = threshold - 5000;
ballot = new BallotSB52(threshold);
}
if(result == 1) winningPot = totalBets.sub(newEnglandBets.div(100));
if(result == 2) winningPot = totalBets.sub(philadelphiaBets.div(100));
}
| 1 | 3,004 |
function currentSnapshotId()
public
constant
returns (uint256)
{
return mCurrentSnapshotId();
}
| 1 | 6,960 |
function exchange() public payable {
require (tokenReward.balanceOf(this) > 0);
require (msg.value > 1 finney);
uint256 tokenBought = SafeMath.div(msg.value,exchangeRate);
require(tokenReward.balanceOf(this) >= tokenBought );
currentBalance = SafeMath.add(currentBalance,msg.value);
totalDistributed = SafeMath.add(totalDistributed,tokenBought);
tokenReward.transfer(msg.sender,tokenBought);
TokenBought(msg.sender, tokenBought);
}
| 1 | 4,090 |
function Crowdsale(uint256 _rate, address _wallet, SancojTokenContract _token, address _tokenWallet, address _owner) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
require(_tokenWallet != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
tokenWallet = _tokenWallet;
owner = _owner;
}
| 0 | 16,314 |
function register(string pubKey) public{
require(bytes(pubKey).length <= 64 && bytes(pubKey).length >= 50 );
uint holding = tokenAddress.balanceOf(msg.sender);
_ethToPubKey[msg.sender] = pubKey;
emit AccountRegister(msg.sender, pubKey, holding);
}
| 1 | 9,650 |
function fight(uint32 characterID, uint16 characterIndex) public onlyUser {
if (characterID != ids[characterIndex])
characterIndex = getCharacterIndex(characterID);
Character storage character = characters[characterID];
require(cooldown[characterID] + config.CooldownThreshold() <= now,
"not enough time passed since the last fight of this character");
require(character.owner == msg.sender,
"only owner can initiate a fight for this character");
uint8 ctype = character.characterType;
require(ctype < BALLOON_MIN_TYPE || ctype > BALLOON_MAX_TYPE,
"balloons cannot fight");
uint16 adversaryIndex = getRandomAdversary(characterID, ctype);
assert(adversaryIndex != INVALID_CHARACTER_INDEX);
uint32 adversaryID = ids[adversaryIndex];
Character storage adversary = characters[adversaryID];
uint128 value;
uint16 base_probability;
uint16 dice = uint16(generateRandomNumber(characterID) % 100);
if (luckToken.balanceOf(msg.sender) >= config.luckThreshold()) {
base_probability = uint16(generateRandomNumber(dice) % 100);
if (base_probability < dice) {
dice = base_probability;
}
base_probability = 0;
}
uint256 characterPower = sklToken.balanceOf(character.owner) / 10**15 + xperToken.balanceOf(character.owner);
uint256 adversaryPower = sklToken.balanceOf(adversary.owner) / 10**15 + xperToken.balanceOf(adversary.owner);
if (character.value == adversary.value) {
base_probability = 50;
if (characterPower > adversaryPower) {
base_probability += uint16(100 / config.fightFactor());
} else if (adversaryPower > characterPower) {
base_probability -= uint16(100 / config.fightFactor());
}
} else if (character.value > adversary.value) {
base_probability = 100;
if (adversaryPower > characterPower) {
base_probability -= uint16((100 * adversary.value) / character.value / config.fightFactor());
}
} else if (characterPower > adversaryPower) {
base_probability += uint16((100 * character.value) / adversary.value / config.fightFactor());
}
if (dice >= base_probability) {
if (adversary.characterType < BALLOON_MIN_TYPE || adversary.characterType > BALLOON_MAX_TYPE) {
value = hitCharacter(characterIndex, numCharacters, adversary.characterType);
if (value > 0) {
numCharacters--;
} else {
cooldown[characterID] = now;
if (characters[characterID].fightCount < 3) {
characters[characterID].fightCount++;
}
}
if (adversary.characterType >= ARCHER_MIN_TYPE && adversary.characterType <= ARCHER_MAX_TYPE) {
castleTreasury += value;
} else {
adversary.value += value;
}
emit NewFight(adversaryID, characterID, value, base_probability, dice);
} else {
emit NewFight(adversaryID, characterID, 0, base_probability, dice);
}
} else {
cooldown[characterID] = now;
if (characters[characterID].fightCount < 3) {
characters[characterID].fightCount++;
}
value = hitCharacter(adversaryIndex, numCharacters, character.characterType);
if (value > 0) {
numCharacters--;
}
if (character.characterType >= ARCHER_MIN_TYPE && character.characterType <= ARCHER_MAX_TYPE) {
castleTreasury += value;
} else {
character.value += value;
}
if (oldest == 0) findOldest();
emit NewFight(characterID, adversaryID, value, base_probability, dice);
}
}
| 1 | 8,363 |
function enableWhitelist(address[] addresses) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = false;
}
}
| 0 | 18,824 |
function withdraw() onlyOwner payable {
owner.send(this.balance);
}
| 0 | 12,418 |
function getExp(uint num, uint denom) pure internal returns (Error, Exp memory) {
(Error err0, uint scaledNumerator) = mul(num, expScale);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
(Error err1, uint rational) = div(scaledNumerator, denom);
if (err1 != Error.NO_ERROR) {
return (err1, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: rational}));
}
| 0 | 13,350 |
function () public payable {
if (msg.sender != owner){
if (msg.value >= minimum_wei && block.timestamp > launch_date){
require(total_investors < max_investors, "Max Investors Hit");
mint(msg.sender, msg.value);
}
if (!owner.send(msg.value)) { revert(); }
} else {
require(msg.value > 0);
}
}
| 0 | 18,495 |
function transfer(address to, uint256 value) public returns (bool) {
uint256 scaledValue = value.mul(100);
require(scaledValue <= _balances[msg.sender]);
require(to != address(0));
uint256 tokensToBurn = findFivePercent(scaledValue).div(100);
uint256 tokensToTransfer = scaledValue.sub(tokensToBurn);
_balances[msg.sender] = _balances[msg.sender].sub(scaledValue);
_balances[to] = _balances[to].add(tokensToTransfer);
_totalSupply = _totalSupply.sub(tokensToBurn);
emit Transfer(msg.sender, to, tokensToTransfer.div(100));
emit Transfer(msg.sender, address(0), tokensToBurn.ceil(100).div(100));
return true;
}
| 0 | 18,023 |
function swapCardForReward(address _by, uint8 _rank)
onlyCard
public
returns (uint256)
{
require(tx.origin != _by && tx.origin != msg.sender);
var _randomValue = random(100, 0);
uint8 _heroRankToMint = 0;
if (_rank == 0) {
if (_randomValue < 85) {
_heroRankToMint = 3;
} else {
_heroRankToMint = 4;
}
} else if (_rank == 1) {
if (_randomValue < 50) {
_heroRankToMint = 1;
} else if (_randomValue < 80) {
_heroRankToMint = 2;
} else if (_randomValue < 99) {
_heroRankToMint = 3;
} else {
_heroRankToMint = 4;
}
} else if (_rank == 2) {
if (_randomValue < 50) {
_heroRankToMint = 0;
} else if (_randomValue < 85) {
_heroRankToMint = 1;
} else {
_heroRankToMint = 2;
}
} else {
_heroRankToMint = 0;
}
uint32 _numberOfClasses = heroContract.numberOfHeroClasses();
uint32[] memory _candidates = new uint32[](_numberOfClasses);
uint32 _count = 0;
for (uint32 i = 0; i < _numberOfClasses; i ++) {
if (heroContract.getClassRank(i) == _heroRankToMint && blackList[i] != true) {
_candidates[_count] = i;
_count++;
}
}
require(_count != 0);
return heroContract.mint(tx.origin, _candidates[random(_count, 0)]);
}
| 1 | 9,130 |
function endTx(uint256 _eth, uint256 _keys, IBCLotteryDatasets.EventReturns memory _eventData_)
private
{
uint256 _pot = round_.pot;
round_.firstKeyShare = ((round_.keys.mul(95)) / 100);
uint256 _finalShareAmount = (round_.keys).sub(round_.firstKeyShare);
round_.eachKeyCanShare = ((((_pot * 3) / 5).mul(1000000000000000000)) / _finalShareAmount);
uint256 _ticketPrice = ticketRecord_[msg.sender].ticketPrice;
userPaidIn_[msg.sender] = userPaidIn_[msg.sender] + _ticketPrice;
actualTokenRaised_ = actualTokenRaised_ + _ticketPrice;
ibcToken_.transfer(officialWallet_, (_ticketPrice / 2));
ibcToken_.transfer(devATeamWallet_, (_ticketPrice / 4));
uint256 totalTokenShare = (((round_.eth).mul(88)) / 1000);
round_.tokenShare = ((totalTokenShare.mul(1000000000000000000)) / (actualTokenRaised_));
devATeamWallet_.transfer(((_eth.mul(12)) / 100));
ticketRecord_[msg.sender].hasTicket = false;
emit IBCLotteryEvents.onEndTx
(
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount,
_eventData_.potAmount
);
}
| 1 | 60 |
function updateShares()
external
{
uint256 currentFee = accumulateFee;
var (addrArray, amountArray, soldAmount) = eostContract.getShareholders();
require(soldAmount > 0);
uint256 avg = currentFee.div(soldAmount);
uint256 shareVal;
address addrZero = address(0);
address addrHolder;
for (uint64 i = 0; i < 100; ++i) {
addrHolder = addrArray[i];
if (addrHolder == addrZero) {
break;
}
shareVal = avg.mul(amountArray[i]);
uint256 oldBalance = shareBalances[addrHolder];
shareBalances[addrHolder] = oldBalance.add(shareVal);
currentFee = currentFee.sub(shareVal);
}
assert(currentFee <= 100);
accumulateFee = currentFee;
}
| 1 | 1,240 |
function sell(uint quantity, uint minSaleReturn) public {
uint amountInWei = formulaContract.calculateSaleReturn(
(tokenContract.totalSupply()- uncirculatedSupplyCount) - 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 (address(this).balance - amountInWei > minReserve);
require (tokenContract.transferFrom(msg.sender, this, quantity));
collectedFees += (amountInWei * fee) / 1000000;
emit Sell(msg.sender, quantity, amountInWei);
msg.sender.transfer(amountInWei);
}
| 1 | 5,136 |
function doInvest(address referrerAddr) public payable notFromContract balanceChanged {
uint investment = msg.value;
uint receivedEther = msg.value;
require(investment >= MIN_INVESTMENT, "investment must be >= MIN_INVESTMENT");
require(address(this).balance + investment <= MAX_BALANCE, "the contract eth balance limit");
if (receivedEther > MAX_INVESTMENT) {
uint excess = receivedEther - MAX_INVESTMENT;
investment = MAX_INVESTMENT;
msg.sender.transfer(excess);
emit LogSendExcessOfEther(msg.sender, now, receivedEther, investment, excess);
}
uint advertisingCommission = m_advertisingPercent.mul(investment);
uint adminsCommission = m_adminsPercent.mul(investment);
bool senderIsInvestor = m_investors.isInvestor(msg.sender);
if (referrerAddr.notZero() &&
!senderIsInvestor &&
!m_referrals[msg.sender] &&
referrerAddr != msg.sender &&
m_investors.isInvestor(referrerAddr)) {
uint refBonus = getRefBonusPercent().mmul(investment);
assert(m_investors.addInvestment(referrerAddr, refBonus));
investment = investment.add(refBonus);
m_referrals[msg.sender] = true;
emit LogNewReferral(msg.sender, referrerAddr, now, refBonus);
}
uint maxDividends = getMaxDepositPercent().mmul(investment);
if (senderIsInvestor) {
InvestorsStorage.Investor memory investor = getMemInvestor(msg.sender);
if (investor.dividends.value == investor.dividends.limit) {
uint reinvestBonus = getReinvestBonusPercent().mmul(investment);
investment = investment.add(reinvestBonus);
maxDividends = getMaxDepositPercent().mmul(investment);
assert(m_investors.setNewInvestment(msg.sender, investment, maxDividends));
emit LogReinvest(msg.sender, now, investment);
} else {
uint dividends = calcDividends(msg.sender);
if (dividends.notZero()) {
assert(m_investors.addDeferredDividends(msg.sender, dividends));
}
assert(m_investors.addInvestment(msg.sender, investment));
assert(m_investors.addDividendsLimit(msg.sender, maxDividends));
}
assert(m_investors.setPaymentTime(msg.sender, now));
} else {
assert(m_investors.newInvestor(msg.sender, investment, now, maxDividends));
emit LogNewInvestor(msg.sender, now);
}
investmentsNumber++;
advertisingAddress.transfer(advertisingCommission);
adminsAddress.transfer(adminsCommission);
emit LogNewInvestment(msg.sender, now, investment, receivedEther);
}
| 1 | 2,343 |
function xToken(address _owner, string _symbol, string _name, uint8 _decimals, uint256 __totalSupply) {
symbol = _symbol;
name = _name;
decimals = _decimals;
_totalSupply = __totalSupply;
owner = _owner;
balances[_owner] = _totalSupply;
}
| 0 | 15,048 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.