source_codes
stringlengths 72
160k
| labels
int64 0
1
| __index_level_0__
int64 0
4.4k
|
|---|---|---|
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,781 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract CryptualProjectToken is StandardToken, Ownable {
using SafeMath for uint256;
string public constant name = "Cryptual Project Token";
string public constant symbol = "CTL";
uint8 public constant decimals = 0;
uint256 public constant INITIAL_SUPPLY = 2480000000;
address public wallet;
uint256 public constant PRESALE_OPENING_TIME = 1535382000;
uint256 public constant PRESALE_CLOSING_TIME = 1536289200;
uint256 public constant PRESALE_RATE = 500000;
uint256 public constant PRESALE_WEI_CAP = 2500 ether;
uint256 public constant PRESALE_WEI_GOAL = 100 ether;
uint256 public constant CROWDSALE_OPENING_TIME = 1537542000;
uint256 public constant CROWDSALE_CLOSING_TIME = 1545361200;
uint256 public constant CROWDSALE_WEI_CAP = 20000 ether;
uint256 public constant CROWDSALE_WEI_GOAL = 800 ether;
uint256[] public crowdsaleWeiAvailableLevels = [2500 ether, 5000 ether, 12500 ether];
uint256[] public crowdsaleRates = [400000, 300000, 200000];
uint256[] public crowdsaleMinElapsedTimeLevels = [0, 12 * 3600, 18 * 3600, 21 * 3600, 22 * 3600];
uint256[] public crowdsaleUserCaps = [1 ether, 2 ether, 4 ether, 8 ether, CROWDSALE_WEI_CAP];
mapping(address => uint256) public crowdsaleContributions;
uint256 public presaleWeiRaised;
uint256 public crowdsaleWeiRaised;
constructor(
address _wallet
) public {
require(_wallet != address(0));
wallet = _wallet;
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
require(_beneficiary != address(0));
require(weiAmount != 0);
bool isPresale = block.timestamp >= PRESALE_OPENING_TIME && block.timestamp <= PRESALE_CLOSING_TIME && presaleWeiRaised.add(weiAmount) <= PRESALE_WEI_CAP;
bool isCrowdsale = block.timestamp >= CROWDSALE_OPENING_TIME && block.timestamp <= CROWDSALE_CLOSING_TIME && presaleGoalReached() && crowdsaleWeiRaised.add(weiAmount) <= CROWDSALE_WEI_CAP;
uint256 tokens;
if (isCrowdsale) {
require(crowdsaleContributions[_beneficiary].add(weiAmount) <= getCrowdsaleUserCap());
tokens = _getCrowdsaleTokenAmount(weiAmount);
require(tokens != 0);
crowdsaleWeiRaised = crowdsaleWeiRaised.add(weiAmount);
} else if (isPresale) {
require(whitelist[_beneficiary]);
tokens = weiAmount.mul(PRESALE_RATE).div(1 ether);
require(tokens != 0);
presaleWeiRaised = presaleWeiRaised.add(weiAmount);
} else {
revert();
}
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
if (isCrowdsale) {
crowdsaleContributions[_beneficiary] = crowdsaleContributions[_beneficiary].add(weiAmount);
crowdsaleDeposited[_beneficiary] = crowdsaleDeposited[_beneficiary].add(msg.value);
} else if (isPresale) {
presaleDeposited[_beneficiary] = presaleDeposited[_beneficiary].add(msg.value);
}
}
function getCrowdsaleUserCap() public view returns (uint256) {
require(block.timestamp >= CROWDSALE_OPENING_TIME && block.timestamp <= CROWDSALE_CLOSING_TIME);
uint256 elapsedTime = block.timestamp.sub(CROWDSALE_OPENING_TIME);
uint256 currentMinElapsedTime = 0;
uint256 currentCap = 0;
for (uint i = 0; i < crowdsaleUserCaps.length; i++) {
if (elapsedTime < crowdsaleMinElapsedTimeLevels[i]) continue;
if (crowdsaleMinElapsedTimeLevels[i] < currentMinElapsedTime) continue;
currentCap = crowdsaleUserCaps[i];
}
return currentCap;
}
function _getCrowdsaleTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint256 uncountedWeiRaised = crowdsaleWeiRaised;
uint256 uncountedWeiAmount = _weiAmount;
uint256 tokenAmount = 0;
for (uint i = 0; i < crowdsaleWeiAvailableLevels.length; i++) {
uint256 weiAvailable = crowdsaleWeiAvailableLevels[i];
uint256 rate = crowdsaleRates[i];
if (uncountedWeiRaised < weiAvailable) {
if (uncountedWeiRaised > 0) {
weiAvailable = weiAvailable.sub(uncountedWeiRaised);
uncountedWeiRaised = 0;
}
if (uncountedWeiAmount <= weiAvailable) {
tokenAmount = tokenAmount.add(uncountedWeiAmount.mul(rate));
break;
} else {
uncountedWeiAmount = uncountedWeiAmount.sub(weiAvailable);
tokenAmount = tokenAmount.add(weiAvailable.mul(rate));
}
} else {
uncountedWeiRaised = uncountedWeiRaised.sub(weiAvailable);
}
}
return tokenAmount.div(1 ether);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
totalSupply_ = totalSupply_.add(_tokenAmount);
balances[_beneficiary] = balances[_beneficiary].add(_tokenAmount);
emit Transfer(0x0, _beneficiary, _tokenAmount);
}
mapping(address => bool) public whitelist;
function addToPresaleWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = true;
}
function addManyToPresaleWhitelist(address[] _beneficiaries) external onlyOwner {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
}
function removeFromPresaleWhitelist(address _beneficiary) external onlyOwner {
whitelist[_beneficiary] = false;
}
bool public isPresaleFinalized = false;
bool public isCrowdsaleFinalized = false;
mapping (address => uint256) public presaleDeposited;
mapping (address => uint256) public crowdsaleDeposited;
event PresaleFinalized();
event CrowdsaleFinalized();
event RefundsEnabled();
event Refunded(address indexed beneficiary, uint256 weiAmount);
function finalizePresale() external {
require(!isPresaleFinalized);
require(block.timestamp > PRESALE_CLOSING_TIME);
if (presaleGoalReached()) {
wallet.transfer(address(this).balance > presaleWeiRaised ? presaleWeiRaised : address(this).balance);
} else {
emit RefundsEnabled();
}
emit PresaleFinalized();
isPresaleFinalized = true;
}
function finalizeCrowdsale() external {
require(isPresaleFinalized && presaleGoalReached());
require(!isCrowdsaleFinalized);
require(block.timestamp > CROWDSALE_CLOSING_TIME);
if (crowdsaleGoalReached()) {
wallet.transfer(address(this).balance);
} else {
emit RefundsEnabled();
}
emit CrowdsaleFinalized();
isCrowdsaleFinalized = true;
}
function claimRefund() external {
uint256 depositedValue = 0;
if (isCrowdsaleFinalized && !crowdsaleGoalReached()) {
require(crowdsaleDeposited[msg.sender] > 0);
depositedValue = crowdsaleDeposited[msg.sender];
crowdsaleDeposited[msg.sender] = 0;
} else if (isPresaleFinalized && !presaleGoalReached()) {
require(presaleDeposited[msg.sender] > 0);
depositedValue = presaleDeposited[msg.sender];
presaleDeposited[msg.sender] = 0;
}
require(depositedValue > 0);
msg.sender.transfer(depositedValue);
emit Refunded(msg.sender, depositedValue);
}
function presaleGoalReached() public view returns (bool) {
return presaleWeiRaised >= PRESALE_WEI_GOAL;
}
function crowdsaleGoalReached() public view returns (bool) {
return crowdsaleWeiRaised >= CROWDSALE_WEI_GOAL;
}
} | 0 | 1,376 |
pragma solidity ^0.4.25;
contract owned {
address public owner;
constructor() public{
owner = msg.sender;
}
modifier onlyOwner{
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns(bool);
}
contract game is owned{
bool public stop = false;
address public tokenAddress_GIC = 0x340e85491c5F581360811d0cE5CC7476c72900Ba;
address public tokenAddress_Arina = 0xE6987CD613Dfda0995A95b3E6acBAbECecd41376;
address public address_A = 0xcC22f3Bd8c684463c0Ed6659a001AA62e0a7A146;
address public address_B = 0xb0D63Fcfb2101C8a1B9b2f0Ff96A13CfEA1A2E65;
mapping (address => uint) readyTime;
uint public airdrop_GIC = 25*10**18 ;
uint public airdrop_Arina = 500*10**8 ;
uint public total_airdrop_GIC = 21000000*10**18;
uint public total_airdrop_Arina = 84000000*10**8;
uint public sent_times = 0;
uint public sent_limit = total_airdrop_GIC/airdrop_GIC;
uint public cooldown = 600;
uint24 public Probability = 1000000;
uint random_source = uint(keccak256(msg.sender, block.difficulty, now));
event Play_game(address indexed from, uint8 player, uint8 comp, uint8 record);
event Random(address indexed from, uint24 random_player, uint24 random_lottery);
function stop_game()onlyOwner public{
stop = true ;
}
function start_game()onlyOwner public{
stop = false ;
}
function set_address_GIC(address new_address)onlyOwner public{
tokenAddress_GIC = new_address;
}
function set_address_Arina(address new_address)onlyOwner public{
tokenAddress_Arina = new_address;
}
function set_address_A(address new_address)onlyOwner public{
address_A = new_address;
}
function set_address_B(address new_address)onlyOwner public{
address_B = new_address;
}
function set_cooldown(uint new_cooldown)onlyOwner public{
cooldown = new_cooldown;
}
function withdraw_GIC(uint _amount)onlyOwner public{
require(ERC20Basic(tokenAddress_GIC).transfer(owner, _amount*10**18));
}
function withdraw_Arina(uint _amount)onlyOwner public{
require(ERC20Basic(tokenAddress_Arina).transfer(owner, _amount*10**8));
}
function withdraw_eth()onlyOwner public{
owner.transfer(address(this).balance);
}
function () payable public{
if (msg.value == 0){
play_game(0);
}
}
function play_paper()public{
play_game(0);
}
function play_scissors()public{
play_game(1);
}
function play_stone()public{
play_game(2);
}
function play_game(uint8 player) internal{
require(stop == false);
require(readyTime[msg.sender] < block.timestamp);
require(player <= 2);
require(sent_times <= sent_limit);
random_source += 1;
uint8 comp=uint8(uint(keccak256(random_source, block.difficulty, block.timestamp))%3);
uint8 result = compare(player, comp);
if (result == 2){
sent_times +=1 ;
require(ERC20Basic(tokenAddress_GIC).transfer(msg.sender, airdrop_GIC));
(uint _player_amount,uint addressA_amount, uint addressB_amount)
= Arina_amount();
require(ERC20Basic(tokenAddress_Arina).transfer(msg.sender, _player_amount));
require(ERC20Basic(tokenAddress_Arina).transfer(address_A , addressA_amount));
require(ERC20Basic(tokenAddress_Arina).transfer(address_B, addressB_amount));
}
else if(result == 1){
}
else if(result == 0){
readyTime[msg.sender] = block.timestamp + cooldown;
}
else revert();
uint bal = ERC20Basic(tokenAddress_GIC).balanceOf(this) + ERC20Basic(tokenAddress_Arina).balanceOf(this);
uint24 random_player = uint24(keccak256(msg.sender, now, random_source))%Probability;
uint24 random_lottery = uint24(keccak256(random_source, block.difficulty, bal))%Probability;
emit Play_game(msg.sender, player, comp, result);
emit Random(msg.sender, random_player, random_lottery);
if (random_player == random_lottery){
uint8 _level = level_judgment(msg.sender);
uint _eth = eth_amount_judgment(_level);
if (address(this).balance >= _eth){
msg.sender.transfer(_eth);
}
else{
msg.sender.transfer(address(this).balance);
}
}
}
function compare(uint8 _player,uint _comp) pure internal returns(uint8 result){
uint8 _result;
if (_player==0 && _comp==2){
_result = 2;
}
else if(_player==2 && _comp==0){
_result = 0;
}
else if(_player == _comp){
_result = 1;
}
else{
if (_player > _comp){
_result = 2;
}
else{
_result = 0;
}
}
return _result;
}
function Arina_judgment() view public returns(uint _amount){
uint Arina_totBalance = ERC20Basic(tokenAddress_Arina).balanceOf(this);
if (Arina_totBalance >= total_airdrop_Arina/2){
return airdrop_Arina;
}
else if(total_airdrop_Arina/2 > Arina_totBalance
&& Arina_totBalance >= total_airdrop_Arina/4){
return airdrop_Arina/2;
}
else if(total_airdrop_Arina/4 > Arina_totBalance
&& Arina_totBalance >= total_airdrop_Arina/8){
return airdrop_Arina/4;
}
else if(total_airdrop_Arina/8 > Arina_totBalance
&& Arina_totBalance >= total_airdrop_Arina/16){
return airdrop_Arina/8;
}
else if(total_airdrop_Arina/16 > Arina_totBalance
&& Arina_totBalance >= total_airdrop_Arina/32){
return airdrop_Arina/16;
}
else if(total_airdrop_Arina/32 > Arina_totBalance
&& Arina_totBalance >= total_airdrop_Arina/64){
return airdrop_Arina/32;
}
else if(total_airdrop_Arina/64 > Arina_totBalance
&& Arina_totBalance >= total_airdrop_Arina/128){
return airdrop_Arina/64;
}
else if(total_airdrop_Arina/128 > Arina_totBalance
&& Arina_totBalance >= total_airdrop_Arina/256){
return airdrop_Arina/128;
}
else if(total_airdrop_Arina/256 > Arina_totBalance
&& Arina_totBalance >= total_airdrop_Arina/512){
return airdrop_Arina/256;
}
else if(total_airdrop_Arina/512 > Arina_totBalance){
return airdrop_Arina/512;
}
else revert();
}
function level_judgment(address _address) view public returns(uint8 _level){
uint GIC_balance = ERC20Basic(tokenAddress_GIC).balanceOf(_address);
if (GIC_balance <= 1000*10**18){
return 1;
}
else if(1000*10**18 < GIC_balance && GIC_balance <=10000*10**18){
return 2;
}
else if(10000*10**18 < GIC_balance && GIC_balance <=100000*10**18){
return 3;
}
else if(100000*10**18 < GIC_balance && GIC_balance <=500000*10**18){
return 4;
}
else if(500000*10**18 < GIC_balance){
return 5;
}
else revert();
}
function eth_amount_judgment(uint8 _level) pure public returns(uint _eth){
if (_level == 1){
return 1 ether;
}
else if (_level == 2){
return 3 ether;
}
else if (_level == 3){
return 5 ether;
}
else if (_level == 4){
return 10 ether;
}
else if (_level == 5){
return 20 ether;
}
else revert();
}
function Arina_amount_judgment(uint8 _level, uint _Arina)
pure public returns(uint _player, uint _addressA, uint _addressB){
if (_level == 1){
return (_Arina*5/10, _Arina*1/10, _Arina*4/10);
}
else if (_level == 2){
return (_Arina*6/10, _Arina*1/10, _Arina*3/10);
}
else if (_level == 3){
return (_Arina*7/10, _Arina*1/10, _Arina*2/10);
}
else if (_level == 4){
return (_Arina*8/10, _Arina*1/10, _Arina*1/10);
}
else if (_level == 5){
return (_Arina*9/10, _Arina*1/10, 0);
}
else revert();
}
function Arina_amount() view public returns(uint _player, uint _addressA, uint _addressB){
uint8 _level = level_judgment(msg.sender);
uint _amount = Arina_judgment();
return Arina_amount_judgment(_level, _amount);
}
function Arina_balance() view public returns(uint _balance){
return ERC20Basic(tokenAddress_Arina).balanceOf(this);
}
function view_readyTime(address _address) view public returns(uint _readyTime){
if (block.timestamp >= readyTime[_address]){
return 0 ;
}
else{
return readyTime[_address] - block.timestamp ;
}
}
function self_readyTime() view public returns(uint _readyTime){
return view_readyTime(msg.sender);
}
} | 0 | 72 |
pragma solidity ^0.4.11;
contract TimeBank {
struct Holder {
uint fundsDeposited;
uint withdrawTime;
}
mapping (address => Holder) holders;
function getInfo() constant returns(uint,uint,uint){
return(holders[msg.sender].fundsDeposited,holders[msg.sender].withdrawTime,block.timestamp);
}
function depositFunds(uint _withdrawTime) payable returns (uint _fundsDeposited){
require(msg.value > 0 && _withdrawTime > block.timestamp && _withdrawTime < block.timestamp + 157680000);
if (!(holders[msg.sender].withdrawTime > 0)) holders[msg.sender].withdrawTime = _withdrawTime;
holders[msg.sender].fundsDeposited += msg.value;
return msg.value;
}
function withdrawFunds() {
require(holders[msg.sender].withdrawTime < block.timestamp);
uint funds = holders[msg.sender].fundsDeposited;
holders[msg.sender].fundsDeposited = 0;
holders[msg.sender].withdrawTime = 0;
msg.sender.transfer(funds);
}
} | 0 | 1,922 |
pragma solidity ^ 0.4 .9;
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 Steemish {
using SafeMath
for uint256;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => uint256) balances;
uint256 public totalSupply;
uint256 public decimals;
address public owner;
bytes32 public symbol;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
function Steemish() {
totalSupply = 10100000;
symbol = 'Stish';
owner = 0xae684a264b43cce57a16883c6ef48cf1ae3d5261;
balances[owner] = totalSupply;
decimals = 0;
}
function balanceOf(address _owner) constant returns(uint256 balance) {
return balances[_owner];
}
function allowance(address _owner, address _spender) constant returns(uint256 remaining) {
return allowed[_owner][_spender];
}
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 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() {
revert();
}
} | 1 | 2,468 |
pragma solidity ^0.4.16;
contract Owned {
address public owner;
mapping(address => bool) public owners;
function Owned() public {
owner = msg.sender;
owners[msg.sender] = true;
}
modifier onlyOwners{
address sen = msg.sender;
require(owners[msg.sender] == true);
_;
}
modifier onlyOwner{
require(msg.sender == owner);
_;
}
modifier onlyOwnerOrigin{
require(tx.origin == owner);
_;
}
function addOwner(address newOwner) public onlyOwners{
owners[newOwner] = true;
}
function removeOwner() public onlyOwners{
owners[msg.sender] = false;
}
function removeOwner(address newOwner) public onlyOwner{
owners[newOwner] = false;
}
function isOwner(address o) public view returns(bool){
return owners[o] == true;
}
}
interface TokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract TokenERC20 is Owned {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed from, uint256 value);
function TokenERC20(uint256 initialSupply,
string tokenName,
string tokenSymbol,
uint8 dec) public {
totalSupply = initialSupply;
balanceOf[this] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = dec;
}
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;
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(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 MifflinToken is Owned, TokenERC20 {
uint8 public tokenId;
uint256 ethDolRate = 1000;
uint256 weiRate = 1000000000000000000;
address exchange;
uint256 public buyPrice;
uint256 public totalContribution = 0;
uint256 public highestContribution = 0;
uint256 public lowestContribution = 2 ** 256 - 1;
uint256 public totalBought = 0;
mapping(address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function MifflinToken(address exad,
uint8 tid,
uint256 issue,
string tokenName,
string tokenSymbol,
uint8 dec)
TokenERC20(issue * 10 ** uint256(dec), tokenName, tokenSymbol, dec) public {
tokenId = tid;
MifflinMarket e = MifflinMarket(exad);
e.setToken(tokenId,this);
exchange = exad;
addOwner(exchange);
}
function buy(uint _value) internal {
transfer(this, msg.sender, _value);
totalBought += _value;
}
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 give(address _to, uint256 _value) public onlyOwners returns(bool success){
transfer(this, _to, _value);
return true;
}
function take(address _from, uint256 _value) public onlyOwners returns(bool success){
transfer(_from, this, _value);
return true;
}
function freezeAccount(address target, bool freeze) public onlyOwners{
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function setBuyPrice(uint256 newBuyPrice) public onlyOwners{
buyPrice = newBuyPrice;
}
function contribution(uint256 amount)internal returns(int highlow){
owner.transfer(msg.value);
totalContribution += msg.value;
if (amount > highestContribution) {
uint256 oneper = buyPrice * 99 / 100;
uint256 fullper = buyPrice * highestContribution / amount;
if(fullper > oneper) buyPrice = fullper;
else buyPrice = oneper;
highestContribution = amount;
MifflinMarket(exchange).highContributionAward(msg.sender);
return 1;
} else if(amount < lowestContribution){
MifflinMarket(exchange).lowContributionAward(msg.sender);
lowestContribution = amount;
return -1;
} else return 0;
}
function sell(uint256 amount) public {
transfer(msg.sender, this, amount);
}
}
contract BeetBuck is Owned, MifflinToken {
function BeetBuck(address exchange)MifflinToken(exchange, 2, 2000000, "Beet Buck", "BEET", 8) public {
buyPrice = weiRate / ethDolRate / uint(10) ** decimals;
}
function () payable public {
contribution(msg.value);
uint256 amountToGive = 0;
uint256 price = buyPrice;
if (totalBought < 10000) {
price -= price * 15 / 100;
} else if (totalBought < 50000) {
price -= price / 10;
} else if (totalBought < 100000) {
price -= price / 20;
} else if (totalBought < 200000) {
price -= price / 100;
}
amountToGive += msg.value / price;
buy(amountToGive);
}
}
contract NapNickel is Owned, MifflinToken {
function NapNickel(address exchange)
MifflinToken(exchange, 3, 1000000000, "Nap Nickel", "NAPP", 8) public {
buyPrice = weiRate / ethDolRate / uint(10) ** decimals / 20;
}
function () payable public {
contribution(msg.value);
uint256 price = buyPrice;
uint256 estTime = block.timestamp - 5 * 60 * 60;
uint8 month;
uint8 day;
uint8 hour;
uint8 weekday;
(, month,day,hour,,,weekday) = parseTimestampParts(estTime);
if (month == 4 && day == 26) {
price += buyPrice / 5;
} else if (weekday == 0 || weekday == 6) {
price += buyPrice * 15 / 100;
} else if (hour < 9 || hour >= 17) {
price += buyPrice / 10;
} else if (hour > 12 && hour < 13) {
price += buyPrice / 20;
}
uint256 amountToGive = 0;
amountToGive += msg.value / price;
buy(amountToGive);
}
struct _DateTime {
uint16 year;
uint8 month;
uint8 day;
uint8 hour;
uint8 minute;
uint8 second;
uint8 weekday;
}
uint constant DAY_IN_SECONDS = 86400;
uint constant YEAR_IN_SECONDS = 31536000;
uint constant LEAP_YEAR_IN_SECONDS = 31622400;
uint constant HOUR_IN_SECONDS = 3600;
uint constant MINUTE_IN_SECONDS = 60;
uint16 constant ORIGIN_YEAR = 1970;
function isLeapYear(uint16 year) public pure returns (bool) {
if (year % 4 != 0) {
return false;
}
if (year % 100 != 0) {
return true;
}
if (year % 400 != 0) {
return false;
}
return true;
}
function leapYearsBefore(uint year) public pure returns (uint) {
year -= 1;
return year / 4 - year / 100 + year / 400;
}
function getDaysInMonth(uint8 month, uint16 year) public pure returns (uint8) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
return 31;
}
else if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
}
else if (isLeapYear(year)) {
return 29;
}
else {
return 28;
}
}
function parseTimestampParts(uint timestamp) public pure returns (uint16 year,uint8 month,uint8 day, uint8 hour,uint8 minute,uint8 second,uint8 weekday) {
_DateTime memory dt = parseTimestamp(timestamp);
return (dt.year,dt.month,dt.day,dt.hour,dt.minute,dt.second,dt.weekday);
}
function parseTimestamp(uint timestamp) internal pure returns (_DateTime dt) {
uint secondsAccountedFor = 0;
uint buf;
uint8 i;
dt.year = getYear(timestamp);
buf = leapYearsBefore(dt.year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
secondsAccountedFor += YEAR_IN_SECONDS * (dt.year - ORIGIN_YEAR - buf);
uint secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, dt.year);
if (secondsInMonth + secondsAccountedFor > timestamp) {
dt.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
for (i = 1; i <= getDaysInMonth(dt.month, dt.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > timestamp) {
dt.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
dt.hour = getHour(timestamp);
dt.minute = getMinute(timestamp);
dt.second = getSecond(timestamp);
dt.weekday = getWeekday(timestamp);
}
function getYear(uint timestamp) public pure returns (uint16) {
uint secondsAccountedFor = 0;
uint16 year;
uint numLeapYears;
year = uint16(ORIGIN_YEAR + timestamp / YEAR_IN_SECONDS);
numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);
while (secondsAccountedFor > timestamp) {
if (isLeapYear(uint16(year - 1))) {
secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
}
else {
secondsAccountedFor -= YEAR_IN_SECONDS;
}
year -= 1;
}
return year;
}
function getMonth(uint timestamp) public pure returns (uint8) {
return parseTimestamp(timestamp).month;
}
function getDay(uint timestamp) public pure returns (uint8) {
return parseTimestamp(timestamp).day;
}
function getHour(uint timestamp) public pure returns (uint8) {
return uint8((timestamp / 60 / 60) % 24);
}
function getMinute(uint timestamp) public pure returns (uint8) {
return uint8((timestamp / 60) % 60);
}
function getSecond(uint timestamp) public pure returns (uint8) {
return uint8(timestamp % 60);
}
function getWeekday(uint timestamp) public pure returns (uint8) {
return uint8((timestamp / DAY_IN_SECONDS + 4) % 7);
}
}
contract QuabityQuarter is Owned, MifflinToken {
uint lastContributionTime = 0;
function QuabityQuarter(address exchange)
MifflinToken(exchange, 4, 420000000, "Quabity Quarter", "QUAB", 8) public {
buyPrice = weiRate / ethDolRate / uint(10) ** decimals / 4;
}
function () payable public {
contribution(msg.value);
uint256 amountToGive = 0;
amountToGive += msg.value / buyPrice;
uint256 time = block.timestamp;
uint256 diff = time - lastContributionTime / 60 / 60;
uint256 chance = 0;
if (diff > 96)
chance = 50;
if (diff > 48)
chance = 40;
else if (diff > 24)
chance = 30;
else if (diff > 12)
chance = 20;
else if (diff > 1)
chance = 10;
else chance = 5;
if (chance > 0) {
uint256 lastBlockHash = uint256(keccak256(block.blockhash(block.number - 1), uint8(0)));
if (lastBlockHash % 100 < chance) {
amountToGive += amountToGive / 10;
}}
buy(amountToGive);
}
}
contract KelevinKoin is Owned, MifflinToken {
function KelevinKoin(address exchange)
MifflinToken(exchange, 5, 69000000, "Kelevin Koin", "KLEV", 8) public {
buyPrice = weiRate / ethDolRate / uint(10) ** decimals / 50;
}
function () payable public {
contribution(msg.value);
uint256 lastBlockHash = uint256(keccak256(block.blockhash(block.number - 1), uint8(0)));
uint256 newPrice = buyPrice + ((lastBlockHash % (buyPrice * 69 / 1000)) - (buyPrice * 69 * 2 / 1000));
buyPrice = newPrice;
uint256 amountToGive = msg.value / buyPrice;
if (buyPrice % msg.value == 0)
amountToGive += amountToGive * 69 / 1000;
buy(amountToGive);
}
}
contract NnexNote is Owned, MifflinToken {
function NnexNote(address exchange)
MifflinToken(exchange, 6, 666000000, "Nnex Note", "NNEX", 8) public {
buyPrice = weiRate / ethDolRate / uint(10) ** decimals / 100;
}
function () payable public {
contribution(msg.value);
uint maxDiscountRange = buyPrice * 100;
uint discountPercent;
if(msg.value >= maxDiscountRange) discountPercent = 100;
else discountPercent = msg.value / maxDiscountRange * 100;
uint price = buyPrice - (buyPrice / 2) * (discountPercent / 100);
uint amountToGive = msg.value / price;
buy(amountToGive);
}
}
contract DundieDollar is Owned, MifflinToken {
mapping(uint8 => string) public awards;
uint8 public awardsCount;
mapping(address => mapping(uint8 => uint256)) public awardsOf;
function DundieDollar(address exchange)
MifflinToken(exchange, 1, 1725000000, "Dundie Dollar", "DUND", 0) public {
buyPrice = weiRate / ethDolRate * 10;
awards[0] = "Best Dad Award";
awards[1] = "Best Mom Award";
awards[2] = "Hottest in the Office Award";
awards[3] = "Diabetes Award";
awards[4] = "Promising Assistant Manager Award";
awards[5] = "Cutest Redhead in the Office Award";
awards[6] = "Best Host Award";
awards[7] = "Doobie Doobie Pothead Stoner of the Year Award";
awards[8] = "Extreme Repulsiveness Award";
awards[9] = "Redefining Beauty Award";
awards[10] = "Kind of A Bitch Award";
awards[11] = "Moving On Up Award";
awards[12] = "Worst Salesman of the Year";
awards[13] = "Busiest Beaver Award";
awards[14] = "Tight-Ass Award";
awards[15] = "Spicy Curry Award";
awards[16] = "Don't Go in There After Me";
awards[17] = "Fine Work Award";
awards[18] = "Whitest Sneakers Award";
awards[19] = "Great Work Award";
awards[20] = "Longest Engagement Award";
awards[21] = "Show Me the Money Award";
awards[22] = "Best Boss Award";
awards[23] = "Grace Under Fire Award";
awardsCount = 24;
}
function addAward(string name) public onlyOwners{
awards[awardsCount] = name;
awardsCount++;
}
function () payable public {
contribution(msg.value);
uint256 amountToGive = msg.value / buyPrice;
buy(amountToGive);
}
function transfer(address _from, address _to, uint _value) internal {
super.transfer(_from,_to,_value);
transferAwards(_from,_to,_value);
}
function transferAwards(address _from, address _to, uint _value) internal {
uint256 lastBlockHash = uint256(keccak256(block.blockhash(block.number - 1), uint8(0))) + _value;
uint8 award = uint8(lastBlockHash % awardsCount);
if(_from == address(this)) {
transferAwards(_from,_to,award,_value);
} else {
uint left = _value;
for (uint8 i = 0; i < awardsCount; i++) {
uint256 bal = awardBalanceOf(_from,award);
if(bal > 0){
if(bal < left) {
transferAwards(_from,_to,award,bal);
left -= bal;
} else {
transferAwards(_from,_to,award,left);
left = 0;
}
}
if(left == 0) break;
award ++;
if(award == awardsCount - 1) award = 0;
}
}
}
function transferAwards(address from, address to, uint8 award , uint value) internal {
if(from != address(this)) {
require(awardBalanceOf(from,award) >= value );
awardsOf[from][award] -= value;
}
if(to != address(this)) awardsOf[to][award] += value;
}
function awardBalanceOf(address addy,uint8 award) view public returns(uint){
return awardsOf[addy][award];
}
function awardName(uint8 id) view public returns(string) {
return awards[id];
}
}
contract MifflinMarket is Owned {
mapping(uint8 => address) public tokenIds;
mapping(uint8 => mapping(uint8 => int256)) public totalExchanged;
uint8 rewardTokenId = 1;
bool active;
function MifflinMarket() public {
active = true;
}
modifier onlyTokens {
MifflinToken mt = MifflinToken(msg.sender);
require(tokenIds[mt.tokenId()] == msg.sender);
_;
}
function setToken(uint8 tid,address addy) public onlyOwnerOrigin {
tokenIds[tid] = addy;
}
function removeToken(uint8 id) public onlyOwner {
tokenIds[id] = 0;
}
function setActive(bool act) public onlyOwner {
active = act;
}
function getRewardToken() public view returns(MifflinToken){
return getTokenById(rewardTokenId);
}
function getTokenById(uint8 id) public view returns(MifflinToken){
require(tokenIds[id] > 0);
return MifflinToken(tokenIds[id]);
}
function getTokenByAddress(address addy) public view returns(MifflinToken){
MifflinToken token = MifflinToken(addy);
uint8 tokenId = token.tokenId();
require(tokenIds[tokenId] == addy);
return token;
}
function exchangeTokensByAddress(uint256 fromAmount, address from, address to) public {
require(active);
uint256 takeAmount = fromAmount;
MifflinToken fromToken = getTokenByAddress(from);
MifflinToken toToken = getTokenByAddress(to);
uint8 fromId = fromToken.tokenId();
uint8 toId = toToken.tokenId();
uint256 fromPrice = fromToken.buyPrice();
uint256 toPrice = toToken.buyPrice();
uint256 toAmount = fromAmount * fromPrice / toPrice;
takeAmount = toAmount * toPrice / fromPrice;
fromToken.take(msg.sender, takeAmount);
toToken.give(msg.sender, toAmount);
totalExchanged[fromId][toId] += int(toAmount);
totalExchanged[toId][fromId] -= int(takeAmount);
}
function exchangeTokensById(uint256 fromAmount, uint8 from, uint8 to) public {
address fromAddress = tokenIds[from];
address toAddress = tokenIds[to];
exchangeTokensByAddress(fromAmount,fromAddress,toAddress);
}
function highContributionAward(address to) public onlyTokens {
MifflinToken reward = getRewardToken();
if(reward.balanceOf(reward) > 0){
reward.give(to, 1);
}
}
function lowContributionAward(address to) public onlyTokens {
MifflinToken reward = getRewardToken();
if(reward.balanceOf(to) > 0){
reward.take(to, 1);
}
}
} | 0 | 1,764 |
pragma solidity ^0.4.13;
contract ReentrancyHandlingContract {
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
}
contract Owned {
address public owner;
address public newOwner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
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;
}
event OwnerUpdate(address _prevOwner, address _newOwner);
}
contract PriorityPassInterface {
function getAccountLimit(address _accountAddress) public constant returns (uint);
function getAccountActivity(address _accountAddress) public constant returns (bool);
}
contract ERC20TokenInterface {
function totalSupply() public constant returns (uint256 _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 SeedCrowdsaleContract is ReentrancyHandlingContract, Owned {
struct ContributorData {
uint contributionAmount;
}
mapping(address => ContributorData) public contributorList;
uint public nextContributorIndex;
mapping(uint => address) public contributorIndexes;
state public crowdsaleState = state.pendingStart;
enum state { pendingStart, priorityPass, openedPriorityPass, crowdsaleEnded }
uint public presaleStartTime;
uint public presaleUnlimitedStartTime;
uint public crowdsaleEndedTime;
event PresaleStarted(uint blocktime);
event PresaleUnlimitedStarted(uint blocktime);
event CrowdsaleEnded(uint blocktime);
event ErrorSendingETH(address to, uint amount);
event MinCapReached(uint blocktime);
event MaxCapReached(uint blocktime);
event ContributionMade(address indexed contributor, uint amount);
PriorityPassInterface priorityPassContract = PriorityPassInterface(0x0);
uint public minCap;
uint public maxP1Cap;
uint public maxCap;
uint public ethRaised;
address public multisigAddress;
uint nextContributorToClaim;
mapping(address => bool) hasClaimedEthWhenFail;
function() noReentrancy payable public {
require(msg.value != 0);
require(crowdsaleState != state.crowdsaleEnded);
bool stateChanged = checkCrowdsaleState();
if (crowdsaleState == state.priorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) {
processTransaction(msg.sender, msg.value);
} else {
refundTransaction(stateChanged);
}
} else if (crowdsaleState == state.openedPriorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) {
processTransaction(msg.sender, msg.value);
} else {
refundTransaction(stateChanged);
}
} else {
refundTransaction(stateChanged);
}
}
function checkCrowdsaleState() internal returns (bool) {
if (ethRaised == maxCap && crowdsaleState != state.crowdsaleEnded) {
crowdsaleState = state.crowdsaleEnded;
MaxCapReached(block.timestamp);
CrowdsaleEnded(block.timestamp);
return true;
}
if (block.timestamp > presaleStartTime && block.timestamp <= presaleUnlimitedStartTime) {
if (crowdsaleState != state.priorityPass) {
crowdsaleState = state.priorityPass;
PresaleStarted(block.timestamp);
return true;
}
} else if (block.timestamp > presaleUnlimitedStartTime && block.timestamp <= crowdsaleEndedTime) {
if (crowdsaleState != state.openedPriorityPass) {
crowdsaleState = state.openedPriorityPass;
PresaleUnlimitedStarted(block.timestamp);
return true;
}
} else {
if (crowdsaleState != state.crowdsaleEnded && block.timestamp > crowdsaleEndedTime) {
crowdsaleState = state.crowdsaleEnded;
CrowdsaleEnded(block.timestamp);
return true;
}
}
return false;
}
function refundTransaction(bool _stateChanged) internal {
if (_stateChanged) {
msg.sender.transfer(msg.value);
} else {
revert();
}
}
function calculateMaxContribution(address _contributor) constant public returns (uint maxContribution) {
uint maxContrib;
if (crowdsaleState == state.priorityPass) {
maxContrib = priorityPassContract.getAccountLimit(_contributor) - contributorList[_contributor].contributionAmount;
if (maxContrib > (maxP1Cap - ethRaised)) {
maxContrib = maxP1Cap - ethRaised;
}
} else {
maxContrib = maxCap - ethRaised;
}
return maxContrib;
}
function processTransaction(address _contributor, uint _amount) internal {
uint maxContribution = calculateMaxContribution(_contributor);
uint contributionAmount = _amount;
uint returnAmount = 0;
if (maxContribution < _amount) {
contributionAmount = maxContribution;
returnAmount = _amount - maxContribution;
}
if (ethRaised + contributionAmount >= minCap && minCap > ethRaised) {
MinCapReached(block.timestamp);
}
if (contributorList[_contributor].contributionAmount == 0) {
contributorList[_contributor].contributionAmount = contributionAmount;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
} else {
contributorList[_contributor].contributionAmount += contributionAmount;
}
ethRaised += contributionAmount;
ContributionMade(msg.sender, contributionAmount);
if (returnAmount != 0) {
_contributor.transfer(returnAmount);
}
}
function salvageTokensFromContract(address _tokenAddress, address _to, uint _amount) onlyOwner public {
ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
}
function withdrawEth() onlyOwner public {
require(this.balance != 0);
require(ethRaised >= minCap);
pendingEthWithdrawal = this.balance;
}
uint public pendingEthWithdrawal;
function pullBalance() public {
require(msg.sender == multisigAddress);
require(pendingEthWithdrawal > 0);
multisigAddress.transfer(pendingEthWithdrawal);
pendingEthWithdrawal = 0;
}
function batchReturnEthIfFailed(uint _numberOfReturns) onlyOwner public {
require(block.timestamp > crowdsaleEndedTime && 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;
if (!currentParticipantAddress.send(contribution)) {
ErrorSendingETH(currentParticipantAddress, contribution);
}
}
nextContributorToClaim += 1;
}
}
function withdrawRemainingBalanceForManualRecovery() onlyOwner public {
require(this.balance != 0);
require(block.timestamp > crowdsaleEndedTime);
require(contributorIndexes[nextContributorToClaim] == 0x0);
multisigAddress.transfer(this.balance);
}
function setMultisigAddress(address _newAddress) onlyOwner public {
multisigAddress = _newAddress;
}
function setPriorityPassContract(address _newAddress) onlyOwner public {
priorityPassContract = PriorityPassInterface(_newAddress);
}
function priorityPassContractAddress() constant public returns (address) {
return address(priorityPassContract);
}
function setCrowdsaleTimes(uint _presaleStartTime, uint _presaleUnlimitedStartTime, uint _crowdsaleEndedTime) onlyOwner public {
require(crowdsaleState == state.pendingStart);
require(_presaleStartTime != 0);
require(_presaleStartTime < _presaleUnlimitedStartTime);
require(_presaleUnlimitedStartTime != 0);
require(_presaleUnlimitedStartTime < _crowdsaleEndedTime);
require(_crowdsaleEndedTime != 0);
presaleStartTime = _presaleStartTime;
presaleUnlimitedStartTime = _presaleUnlimitedStartTime;
crowdsaleEndedTime = _crowdsaleEndedTime;
}
}
contract AversafeSeedCrowdsale is SeedCrowdsaleContract {
function AversafeSeedCrowdsale() {
presaleStartTime = 1512032400;
presaleUnlimitedStartTime = 1512063000;
crowdsaleEndedTime = 1512140400;
minCap = 451 ether;
maxP1Cap = 802 ether;
maxCap = 891 ether;
}
} | 0 | 743 |
pragma solidity ^0.6.12;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return _functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract RewardsDistribution is Ownable {
using SafeERC20 for IERC20;
using SafeMath for uint;
address public rewardsToken;
address[] public distributions;
mapping(address => uint) public shares;
event RewardDistributionAdded(uint index, address distribution, uint shares);
event RewardDistributionUpdated(address distribution, uint shares);
event RewardsDistributed(uint amount);
modifier onlyRewardsToken() {
require(msg.sender == address(rewardsToken) || msg.sender == owner(), "onlyRewardsToken");
_;
}
constructor(address _rewardsToken) public {
rewardsToken = _rewardsToken;
}
function addRewardDistribution(address _distribution, uint _shares) external onlyOwner {
require(_distribution != address(0), "distribution");
require(shares[_distribution] == 0, "shares");
distributions.push(_distribution);
shares[_distribution] = _shares;
emit RewardDistributionAdded(distributions.length - 1, _distribution, _shares);
}
function updateRewardDistribution(address _distribution, uint _shares) public onlyOwner {
require(_distribution != address(0), "distribution");
require(_shares > 0, "shares");
shares[_distribution] = _shares;
emit RewardDistributionUpdated(_distribution, _shares);
}
function removeRewardDistribution(uint index) external onlyOwner {
require(index <= distributions.length - 1, "index");
delete shares[distributions[index]];
delete distributions[index];
}
function distributeRewards(uint amount) external onlyRewardsToken returns (bool) {
require(rewardsToken != address(0), "rewardsToken");
require(amount > 0, "amount");
require(IERC20(rewardsToken).balanceOf(address(this)) >= amount, "balance");
uint remainder = amount;
for (uint i = 0; i < distributions.length; i++) {
address distribution = distributions[i];
uint amountOfShares = sharesOf(distribution, amount);
if (distribution != address(0) && amountOfShares != 0) {
remainder = remainder.sub(amountOfShares);
IERC20(rewardsToken).transfer(distribution, amountOfShares);
bytes memory payload = abi.encodeWithSignature("notifyRewardAmount(uint256)", amountOfShares);
distribution.call(payload);
}
}
emit RewardsDistributed(amount);
return true;
}
function totalShares() public view returns (uint) {
uint total = 0;
for (uint i = 0; i < distributions.length; i++) {
total = total.add(shares[distributions[i]]);
}
return total;
}
function sharesOf(address _distribution, uint _amount) public view returns (uint) {
uint _totalShares = totalShares();
if (_totalShares == 0) return 0;
return _amount.mul(shares[_distribution]).div(_totalShares);
}
} | 1 | 3,263 |
pragma solidity ^0.4.11;
contract RPS {
enum State { Unrealized, Created, Joined, Ended }
enum Result { Unfinished, Draw, Win, Loss, Forfeit }
struct Game {
address player1;
address player2;
uint value;
bytes32 hiddenMove1;
uint8 move1;
uint8 move2;
uint gameStart;
State state;
Result result;
}
address public owner1;
address public owner2;
uint8 constant feeDivisor = 100;
uint constant revealTime = 7 days;
bool paused;
bool expired;
uint gameIdCounter;
uint constant minimumNameLength = 1;
uint constant maximumNameLength = 25;
event NewName(address indexed player, string name);
event Donate(address indexed player, uint amount);
event Deposit(address indexed player, uint amount);
event Withdraw(address indexed player, uint amount);
event GameCreated(address indexed player1, address indexed player2, uint indexed gameId, uint value, bytes32 hiddenMove1);
event GameJoined(address indexed player1, address indexed player2, uint indexed gameId, uint value, uint8 move2, uint gameStart);
event GameEnded(address indexed player1, address indexed player2, uint indexed gameId, uint value, Result result);
mapping(address => uint) public balances;
mapping(address => uint) public totalWon;
mapping(address => uint) public totalLost;
Game [] public games;
mapping(address => string) public playerNames;
mapping(uint => bool) public nameTaken;
mapping(bytes32 => bool) public secretTaken;
modifier onlyOwner { require(msg.sender == owner1 || msg.sender == owner2); _; }
modifier notPaused { require(!paused); _; }
modifier notExpired { require(!expired); _; }
function RPS(address otherOwner) {
owner1 = msg.sender;
owner2 = otherOwner;
paused = true;
}
function getGames() constant internal returns (Game []) {
return games;
}
function totalProfit(address player) constant returns (int) {
if (totalLost[player] > totalWon[player]) {
return -int(totalLost[player] - totalWon[player]);
}
else {
return int(totalWon[player] - totalLost[player]);
}
}
function computeNameFuzzyHash(string _name) constant internal
returns (uint fuzzyHash) {
bytes memory nameBytes = bytes(_name);
uint h = 0;
uint len = nameBytes.length;
if (len > maximumNameLength) {
len = maximumNameLength;
}
for (uint i = 0; i < len; i++) {
uint mul = 128;
byte b = nameBytes[i];
uint ub = uint(b);
if (b >= 48 && b <= 57) {
h = h * mul + ub;
} else if (b >= 65 && b <= 90) {
h = h * mul + ub;
} else if (b >= 97 && b <= 122) {
uint upper = ub - 32;
h = h * mul + upper;
} else {
}
}
return h;
}
function validateNameInternal(string _name) constant internal
returns (bool allowed) {
bytes memory nameBytes = bytes(_name);
uint lengthBytes = nameBytes.length;
if (lengthBytes < minimumNameLength ||
lengthBytes > maximumNameLength) {
return false;
}
bool foundNonPunctuation = false;
for (uint i = 0; i < lengthBytes; i++) {
byte b = nameBytes[i];
if (
(b >= 48 && b <= 57) ||
(b >= 65 && b <= 90) ||
(b >= 97 && b <= 122)
) {
foundNonPunctuation = true;
continue;
}
if (
b == 32 ||
b == 33 ||
b == 40 ||
b == 41 ||
b == 45 ||
b == 46 ||
b == 95
) {
continue;
}
return false;
}
return foundNonPunctuation;
}
function() { require(false); }
function setName(string name) returns (bool success) {
require (validateNameInternal(name));
uint fuzzyHash = computeNameFuzzyHash(name);
uint oldFuzzyHash;
string storage oldName = playerNames[msg.sender];
bool oldNameEmpty = bytes(oldName).length == 0;
if (nameTaken[fuzzyHash]) {
require(!oldNameEmpty);
oldFuzzyHash = computeNameFuzzyHash(oldName);
require(fuzzyHash == oldFuzzyHash);
}
else {
if (!oldNameEmpty) {
oldFuzzyHash = computeNameFuzzyHash(oldName);
nameTaken[oldFuzzyHash] = false;
}
nameTaken[fuzzyHash] = true;
}
playerNames[msg.sender] = name;
NewName(msg.sender, name);
return true;
}
function createGame(bytes32 move, uint val, address player2)
payable notPaused notExpired returns (uint gameId) {
deposit();
require(balances[msg.sender] >= val);
require(!secretTaken[move]);
secretTaken[move] = true;
balances[msg.sender] -= val;
gameId = gameIdCounter;
games.push(Game(msg.sender, player2, val, move, 0, 0, 0, State.Created, Result(0)));
GameCreated(msg.sender, player2, gameId, val, move);
gameIdCounter++;
}
function abortGame(uint gameId) notPaused returns (bool success) {
Game storage thisGame = games[gameId];
require(thisGame.player1 == msg.sender);
require(thisGame.state == State.Created);
thisGame.state = State.Ended;
GameEnded(thisGame.player1, thisGame.player2, gameId, thisGame.value, Result(0));
msg.sender.transfer(thisGame.value);
return true;
}
function joinGame(uint gameId, uint8 move) payable notPaused returns (bool success) {
Game storage thisGame = games[gameId];
require(thisGame.state == State.Created);
require(move > 0 && move <= 3);
if (thisGame.player2 == 0x0) {
thisGame.player2 = msg.sender;
}
else {
require(thisGame.player2 == msg.sender);
}
require(thisGame.value == msg.value);
thisGame.gameStart = now;
thisGame.state = State.Joined;
thisGame.move2 = move;
GameJoined(thisGame.player1, thisGame.player2, gameId, thisGame.value, thisGame.move2, thisGame.gameStart);
return true;
}
function revealMove(uint gameId, uint8 move, string secret) notPaused returns (Result result) {
Game storage thisGame = games[gameId];
require(thisGame.state == State.Joined);
require(thisGame.player1 == msg.sender);
require(thisGame.gameStart + revealTime >= now);
require(thisGame.hiddenMove1 == keccak256(uint(move), secret));
thisGame.move1 = move;
if (move > 0 && move <= 3) {
result = Result(((3 + move - thisGame.move2) % 3) + 1);
}
else {
result = Result.Loss;
}
thisGame.state = State.Ended;
address winner;
if (result == Result.Draw) {
balances[thisGame.player1] += thisGame.value;
balances[thisGame.player2] += thisGame.value;
}
else {
if (result == Result.Win) {
winner = thisGame.player1;
totalLost[thisGame.player2] += thisGame.value;
}
else {
winner = thisGame.player2;
totalLost[thisGame.player1] += thisGame.value;
}
uint fee = (thisGame.value) / feeDivisor;
balances[owner1] += fee;
balances[owner2] += fee;
totalWon[winner] += thisGame.value - fee*2;
winner.transfer((thisGame.value*2) - fee*2);
}
thisGame.result = result;
GameEnded(thisGame.player1, thisGame.player2, gameId, thisGame.value, result);
}
function forfeitGame(uint gameId) notPaused returns (bool success) {
Game storage thisGame = games[gameId];
require(thisGame.state == State.Joined);
require(thisGame.player1 == msg.sender);
uint fee = (thisGame.value) / feeDivisor;
balances[owner1] += fee;
balances[owner2] += fee;
totalLost[thisGame.player1] += thisGame.value;
totalWon[thisGame.player2] += thisGame.value - fee*2;
thisGame.state = State.Ended;
thisGame.result = Result.Forfeit;
GameEnded(thisGame.player1, thisGame.player2, gameId, thisGame.value, thisGame.result);
thisGame.player2.transfer((thisGame.value*2) - fee*2);
return true;
}
function claimGame(uint gameId) notPaused returns (bool success) {
Game storage thisGame = games[gameId];
require(thisGame.state == State.Joined);
require(thisGame.player2 == msg.sender);
require(thisGame.gameStart + revealTime < now);
uint fee = (thisGame.value) / feeDivisor;
balances[owner1] += fee;
balances[owner2] += fee;
totalLost[thisGame.player1] += thisGame.value;
totalWon[thisGame.player2] += thisGame.value - fee*2;
thisGame.state = State.Ended;
thisGame.result = Result.Forfeit;
GameEnded(thisGame.player1, thisGame.player2, gameId, thisGame.value, thisGame.result);
thisGame.player2.transfer((thisGame.value*2) - fee*2);
return true;
}
function donate() payable returns (bool success) {
require(msg.value != 0);
balances[owner1] += msg.value/2;
balances[owner2] += msg.value - msg.value/2;
Donate(msg.sender, msg.value);
return true;
}
function deposit() payable returns (bool success) {
require(msg.value != 0);
balances[msg.sender] += msg.value;
Deposit(msg.sender, msg.value);
return true;
}
function withdraw() returns (bool success) {
uint amount = balances[msg.sender];
if (amount == 0) return false;
balances[msg.sender] = 0;
msg.sender.transfer(amount);
Withdraw(msg.sender, amount);
return true;
}
function pause(bool pause) onlyOwner {
paused = pause;
}
function expire(bool expire) onlyOwner {
expired = expire;
}
function setOwner1(address newOwner) {
require(msg.sender == owner1);
owner1 = newOwner;
}
function setOwner2(address newOwner) {
require(msg.sender == owner2);
owner2 = newOwner;
}
} | 0 | 1,005 |
pragma solidity ^0.4.23;
contract MonarchyGame {
struct Vars {
address monarch;
uint64 prizeGwei;
uint32 numOverthrows;
uint32 blockEnded;
uint32 prevBlock;
bool isPaid;
bytes23 decree;
}
struct Settings {
address collector;
uint64 initialPrizeGwei;
uint64 feeGwei;
int64 prizeIncrGwei;
uint32 reignBlocks;
}
Vars vars;
Settings settings;
uint constant version = 1;
event SendPrizeError(uint time, string msg);
event Started(uint time, uint initialBlocks);
event OverthrowOccurred(uint time, address indexed newMonarch, bytes23 decree, address indexed prevMonarch, uint fee);
event OverthrowRefundSuccess(uint time, string msg, address indexed recipient, uint amount);
event OverthrowRefundFailure(uint time, string msg, address indexed recipient, uint amount);
event SendPrizeSuccess(uint time, address indexed redeemer, address indexed recipient, uint amount, uint gasLimit);
event SendPrizeFailure(uint time, address indexed redeemer, address indexed recipient, uint amount, uint gasLimit);
event FeesSent(uint time, address indexed collector, uint amount);
constructor(
address _collector,
uint _initialPrize,
uint _fee,
int _prizeIncr,
uint _reignBlocks,
uint _initialBlocks
)
public
payable
{
require(_initialPrize >= 1e9);
require(_initialPrize < 1e6 * 1e18);
require(_initialPrize % 1e9 == 0);
require(_fee >= 1e6);
require(_fee < 1e6 * 1e18);
require(_fee % 1e9 == 0);
require(_prizeIncr <= int(_fee));
require(_prizeIncr >= -1*int(_initialPrize));
require(_prizeIncr % 1e9 == 0);
require(_reignBlocks >= 1);
require(_initialBlocks >= 1);
require(msg.value == _initialPrize);
settings.collector = _collector;
settings.initialPrizeGwei = uint64(_initialPrize / 1e9);
settings.feeGwei = uint64(_fee / 1e9);
settings.prizeIncrGwei = int64(_prizeIncr / 1e9);
settings.reignBlocks = uint32(_reignBlocks);
vars.prizeGwei = settings.initialPrizeGwei;
vars.monarch = _collector;
vars.prevBlock = uint32(block.number);
vars.blockEnded = uint32(block.number + _initialBlocks);
emit Started(now, _initialBlocks);
}
function()
public
payable
{
overthrow(0);
}
function overthrow(bytes23 _decree)
public
payable
{
if (isEnded())
return errorAndRefund("Game has already ended.");
if (msg.sender == vars.monarch)
return errorAndRefund("You are already the Monarch.");
if (msg.value != fee())
return errorAndRefund("Value sent must match fee.");
int _newPrizeGwei = int(vars.prizeGwei) + settings.prizeIncrGwei;
uint32 _newBlockEnded = uint32(block.number) + settings.reignBlocks;
uint32 _newNumOverthrows = vars.numOverthrows + 1;
address _prevMonarch = vars.monarch;
bool _isClean = (block.number != vars.prevBlock);
if (_newPrizeGwei < 0)
return errorAndRefund("Overthrowing would result in a negative prize.");
bool _wasRefundSuccess;
if (!_isClean) {
_wasRefundSuccess = _prevMonarch.send(msg.value);
}
if (_isClean) {
vars.monarch = msg.sender;
vars.numOverthrows = _newNumOverthrows;
vars.prizeGwei = uint64(_newPrizeGwei);
vars.blockEnded = _newBlockEnded;
vars.prevBlock = uint32(block.number);
vars.decree = _decree;
}
if (!_isClean && _wasRefundSuccess){
vars.monarch = msg.sender;
vars.decree = _decree;
}
if (!_isClean && !_wasRefundSuccess){
vars.monarch = msg.sender;
vars.prizeGwei = uint64(_newPrizeGwei);
vars.numOverthrows = _newNumOverthrows;
vars.decree = _decree;
}
if (!_isClean){
if (_wasRefundSuccess)
emit OverthrowRefundSuccess(now, "Another overthrow occurred on the same block.", _prevMonarch, msg.value);
else
emit OverthrowRefundFailure(now, ".send() failed.", _prevMonarch, msg.value);
}
emit OverthrowOccurred(now, msg.sender, _decree, _prevMonarch, msg.value);
}
function errorAndRefund(string _msg)
private
{
require(msg.sender.call.value(msg.value)());
emit OverthrowRefundSuccess(now, _msg, msg.sender, msg.value);
}
function sendPrize(uint _gasLimit)
public
returns (bool _success, uint _prizeSent)
{
if (!isEnded()) {
emit SendPrizeError(now, "The game has not ended.");
return (false, 0);
}
if (vars.isPaid) {
emit SendPrizeError(now, "The prize has already been paid.");
return (false, 0);
}
address _winner = vars.monarch;
uint _prize = prize();
bool _paySuccessful = false;
vars.isPaid = true;
if (_gasLimit == 0) {
_paySuccessful = _winner.call.value(_prize)();
} else {
_paySuccessful = _winner.call.value(_prize).gas(_gasLimit)();
}
if (_paySuccessful) {
emit SendPrizeSuccess({
time: now,
redeemer: msg.sender,
recipient: _winner,
amount: _prize,
gasLimit: _gasLimit
});
return (true, _prize);
} else {
vars.isPaid = false;
emit SendPrizeFailure({
time: now,
redeemer: msg.sender,
recipient: _winner,
amount: _prize,
gasLimit: _gasLimit
});
return (false, 0);
}
}
function sendFees()
public
returns (uint _feesSent)
{
_feesSent = fees();
if (_feesSent == 0) return;
require(settings.collector.call.value(_feesSent)());
emit FeesSent(now, settings.collector, _feesSent);
}
function monarch() public view returns (address) {
return vars.monarch;
}
function prize() public view returns (uint) {
return uint(vars.prizeGwei) * 1e9;
}
function numOverthrows() public view returns (uint) {
return vars.numOverthrows;
}
function blockEnded() public view returns (uint) {
return vars.blockEnded;
}
function prevBlock() public view returns (uint) {
return vars.prevBlock;
}
function isPaid() public view returns (bool) {
return vars.isPaid;
}
function decree() public view returns (bytes23) {
return vars.decree;
}
function collector() public view returns (address) {
return settings.collector;
}
function initialPrize() public view returns (uint){
return uint(settings.initialPrizeGwei) * 1e9;
}
function fee() public view returns (uint) {
return uint(settings.feeGwei) * 1e9;
}
function prizeIncr() public view returns (int) {
return int(settings.prizeIncrGwei) * 1e9;
}
function reignBlocks() public view returns (uint) {
return settings.reignBlocks;
}
function isEnded() public view returns (bool) {
return block.number > vars.blockEnded;
}
function getBlocksRemaining() public view returns (uint) {
if (isEnded()) return 0;
return (vars.blockEnded - block.number) + 1;
}
function fees() public view returns (uint) {
uint _balance = address(this).balance;
return vars.isPaid ? _balance : _balance - prize();
}
function totalFees() public view returns (uint) {
int _feePerOverthrowGwei = int(settings.feeGwei) - settings.prizeIncrGwei;
return uint(_feePerOverthrowGwei * vars.numOverthrows * 1e9);
}
} | 0 | 1,190 |
contract ReentrancyGuard {
bool private rentrancy_lock = false;
modifier nonReentrant() {
require(!rentrancy_lock);
rentrancy_lock = true;
_;
rentrancy_lock = false;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = 0x0;
}
}
contract HasNoContracts is Ownable {
function reclaimContract(address contractAddr) external onlyOwner {
Ownable contractInst = Ownable(contractAddr);
contractInst.transferOwnership(owner);
}
}
contract HasNoEther is Ownable {
function HasNoEther() payable {
require(msg.value == 0);
}
function() external {
}
function reclaimEther() external onlyOwner {
assert(owner.send(this.balance));
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract CanReclaimToken is Ownable {
using SafeERC20 for ERC20Basic;
function reclaimToken(ERC20Basic token) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.safeTransfer(owner, balance);
}
}
contract HasNoTokens is CanReclaimToken {
function tokenFallback(address from_, uint256 value_, bytes data_) external {
revert();
}
}
contract NoOwner is HasNoEther, HasNoTokens, HasNoContracts {
}
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 MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract Campaign is Claimable, HasNoTokens, ReentrancyGuard {
using SafeMath for uint256;
string constant public version = "1.0.0";
string public id;
string public name;
string public website;
bytes32 public whitePaperHash;
uint256 public fundingThreshold;
uint256 public fundingGoal;
uint256 public tokenPrice;
enum TimeMode {
Block,
Timestamp
}
TimeMode public timeMode;
uint256 public startTime;
uint256 public finishTime;
enum BonusMode {
Flat,
Block,
Timestamp,
AmountRaised,
ContributionAmount
}
BonusMode public bonusMode;
uint256[] public bonusLevels;
uint256[] public bonusRates;
address public beneficiary;
uint256 public amountRaised;
uint256 public minContribution;
uint256 public earlySuccessTimestamp;
uint256 public earlySuccessBlock;
mapping (address => uint256) public contributions;
Token public token;
enum Stage {
Init,
Ready,
InProgress,
Failure,
Success
}
function stage()
public
constant
returns (Stage)
{
if (token == address(0)) {
return Stage.Init;
}
var _time = timeMode == TimeMode.Timestamp ? block.timestamp : block.number;
if (_time < startTime) {
return Stage.Ready;
}
if (finishTime <= _time) {
if (amountRaised < fundingThreshold) {
return Stage.Failure;
}
return Stage.Success;
}
if (fundingGoal <= amountRaised) {
return Stage.Success;
}
return Stage.InProgress;
}
modifier atStage(Stage _stage) {
require(stage() == _stage);
_;
}
event Contribution(address sender, uint256 amount);
event Refund(address recipient, uint256 amount);
event Payout(address recipient, uint256 amount);
event EarlySuccess();
function Campaign(
string _id,
address _beneficiary,
string _name,
string _website,
bytes32 _whitePaperHash
)
public
{
id = _id;
beneficiary = _beneficiary;
name = _name;
website = _website;
whitePaperHash = _whitePaperHash;
}
function setParams(
uint256[] _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime,
uint8[] _timeMode_bonusMode,
uint256[] _bonusLevels,
uint256[] _bonusRates
)
public
onlyOwner
atStage(Stage.Init)
{
assert(fundingGoal == 0);
fundingThreshold = _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime[0];
fundingGoal = _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime[1];
tokenPrice = _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime[2];
timeMode = TimeMode(_timeMode_bonusMode[0]);
startTime = _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime[3];
finishTime = _fundingThreshold_fundingGoal_tokenPrice_startTime_finishTime[4];
bonusMode = BonusMode(_timeMode_bonusMode[1]);
bonusLevels = _bonusLevels;
bonusRates = _bonusRates;
require(fundingThreshold > 0);
require(fundingThreshold <= fundingGoal);
require(startTime < finishTime);
require((timeMode == TimeMode.Block ? block.number : block.timestamp) < startTime);
require(bonusLevels.length == bonusRates.length);
}
function createToken(
string _tokenName,
string _tokenSymbol,
uint8 _tokenDecimals,
address[] _distributionRecipients,
uint256[] _distributionAmounts,
uint256[] _releaseTimes
)
public
onlyOwner
atStage(Stage.Init)
{
assert(fundingGoal > 0);
token = new Token(
_tokenName,
_tokenSymbol,
_tokenDecimals,
_distributionRecipients,
_distributionAmounts,
_releaseTimes,
uint8(timeMode)
);
minContribution = tokenPrice.div(10 ** uint256(token.decimals()));
if (minContribution < 1 wei) {
minContribution = 1 wei;
}
}
function()
public
payable
atStage(Stage.InProgress)
{
require(minContribution <= msg.value);
contributions[msg.sender] = contributions[msg.sender].add(msg.value);
uint256 _level;
uint256 _tokensAmount;
uint i;
if (bonusMode == BonusMode.AmountRaised) {
_level = amountRaised;
uint256 _value = msg.value;
uint256 _weightedRateSum = 0;
uint256 _stepAmount;
for (i = 0; i < bonusLevels.length; i++) {
if (_level <= bonusLevels[i]) {
_stepAmount = bonusLevels[i].sub(_level);
if (_value <= _stepAmount) {
_level = _level.add(_value);
_weightedRateSum = _weightedRateSum.add(_value.mul(bonusRates[i]));
_value = 0;
break;
} else {
_level = _level.add(_stepAmount);
_weightedRateSum = _weightedRateSum.add(_stepAmount.mul(bonusRates[i]));
_value = _value.sub(_stepAmount);
}
}
}
_weightedRateSum = _weightedRateSum.add(_value.mul(1 ether));
_tokensAmount = _weightedRateSum.div(1 ether).mul(10 ** uint256(token.decimals())).div(tokenPrice);
} else {
_tokensAmount = msg.value.mul(10 ** uint256(token.decimals())).div(tokenPrice);
if (bonusMode == BonusMode.Block) {
_level = block.number;
}
if (bonusMode == BonusMode.Timestamp) {
_level = block.timestamp;
}
if (bonusMode == BonusMode.ContributionAmount) {
_level = msg.value;
}
for (i = 0; i < bonusLevels.length; i++) {
if (_level <= bonusLevels[i]) {
_tokensAmount = _tokensAmount.mul(bonusRates[i]).div(1 ether);
break;
}
}
}
amountRaised = amountRaised.add(msg.value);
require(amountRaised <= fundingGoal);
require(token.mint(msg.sender, _tokensAmount));
Contribution(msg.sender, msg.value);
if (fundingGoal <= amountRaised) {
earlySuccessTimestamp = block.timestamp;
earlySuccessBlock = block.number;
token.finishMinting();
EarlySuccess();
}
}
function withdrawPayout()
public
atStage(Stage.Success)
{
require(msg.sender == beneficiary);
if (!token.mintingFinished()) {
token.finishMinting();
}
var _amount = this.balance;
require(beneficiary.call.value(_amount)());
Payout(beneficiary, _amount);
}
function releaseTokens()
public
atStage(Stage.Success)
{
require(!token.mintingFinished());
token.finishMinting();
}
function withdrawRefund()
public
atStage(Stage.Failure)
nonReentrant
{
var _amount = contributions[msg.sender];
require(_amount > 0);
contributions[msg.sender] = 0;
msg.sender.transfer(_amount);
Refund(msg.sender, _amount);
}
}
contract Token is MintableToken, NoOwner {
string constant public version = "1.0.0";
string public name;
string public symbol;
uint8 public decimals;
enum TimeMode {
Block,
Timestamp
}
TimeMode public timeMode;
mapping (address => uint256) public releaseTimes;
function Token(
string _name,
string _symbol,
uint8 _decimals,
address[] _recipients,
uint256[] _amounts,
uint256[] _releaseTimes,
uint8 _timeMode
)
public
{
require(_recipients.length == _amounts.length);
require(_recipients.length == _releaseTimes.length);
name = _name;
symbol = _symbol;
decimals = _decimals;
timeMode = TimeMode(_timeMode);
for (uint256 i = 0; i < _recipients.length; i++) {
mint(_recipients[i], _amounts[i]);
if (_releaseTimes[i] > 0) {
releaseTimes[_recipients[i]] = _releaseTimes[i];
}
}
}
function transfer(address _to, uint256 _value)
public
returns (bool)
{
require(mintingFinished);
require(!timeLocked(msg.sender));
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value)
public
returns (bool)
{
require(mintingFinished);
require(!timeLocked(_from));
return super.transferFrom(_from, _to, _value);
}
function timeLocked(address _spender)
public
constant
returns (bool)
{
if (releaseTimes[_spender] == 0) {
return false;
}
var _time = timeMode == TimeMode.Timestamp ? block.timestamp : block.number;
if (releaseTimes[_spender] <= _time) {
delete releaseTimes[_spender];
return false;
}
return true;
}
} | 0 | 1,125 |
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;
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 = 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 invest(address receiver) inState(State.Funding) stopInEmergency payable public {
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);
}
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 PresaleFundCollector is Ownable {
using SafeMathLib for uint;
uint public MAX_INVESTORS = 32;
uint public investorCount;
address[] public investors;
mapping(address => uint) public balances;
uint public freezeEndsAt;
uint public weiMinimumLimit;
bool public moving;
Crowdsale public crowdsale;
event Invested(address investor, uint value);
event Refunded(address investor, uint value);
function PresaleFundCollector(address _owner, uint _freezeEndsAt, uint _weiMinimumLimit) {
owner = _owner;
if(_freezeEndsAt == 0) {
throw;
}
if(_weiMinimumLimit == 0) {
throw;
}
weiMinimumLimit = _weiMinimumLimit;
freezeEndsAt = _freezeEndsAt;
}
function invest() public payable {
if(moving) throw;
address investor = msg.sender;
bool existing = balances[investor] > 0;
balances[investor] = balances[investor].plus(msg.value);
if(balances[investor] < weiMinimumLimit) {
throw;
}
if(!existing) {
if(investorCount >= MAX_INVESTORS) throw;
investors.push(investor);
investorCount++;
}
Invested(investor, msg.value);
}
function parcipateCrowdsaleInvestor(address investor) public {
if(address(crowdsale) == 0) throw;
moving = true;
if(balances[investor] > 0) {
uint amount = balances[investor];
delete balances[investor];
crowdsale.invest.value(amount)(investor);
}
}
function parcipateCrowdsaleAll() public {
for(uint i=0; i<investors.length; i++) {
parcipateCrowdsaleInvestor(investors[i]);
}
}
function refund() {
if(now < freezeEndsAt) throw;
moving = true;
address investor = msg.sender;
if(balances[investor] == 0) throw;
uint amount = balances[investor];
delete balances[investor];
if(!investor.send(amount)) throw;
Refunded(investor, amount);
}
function setCrowdsale(Crowdsale _crowdsale) public onlyOwner {
crowdsale = _crowdsale;
}
function() payable {
throw;
}
} | 0 | 1,241 |
pragma solidity ^0.4.20;
contract SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
}
contract ERC20 {
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(address src, address dst, uint wad) public returns (bool);
}
contract BitFrank is SafeMath {
address public admin;
string public constant name = "BitFrank v1";
bool public suspendDeposit = false;
struct TOKEN_DETAIL {
uint8 level;
uint fee;
}
uint public marketRegisterCost = 99 * (10 ** 16);
uint public marketDefaultFeeLow = 2000;
uint public marketDefaultFeeHigh = 8000;
mapping (address => TOKEN_DETAIL) public tokenMarket;
address[] public tokenList;
mapping (address => mapping (address => uint)) public balance;
mapping (address => mapping (address => uint)) public balanceLocked;
uint public globalOrderSerial = 100000;
uint public PRICE_FACTOR = 10 ** 18;
struct ORDER {
address token;
bool isBuy;
address user;
uint wad;
uint wadFilled;
uint price;
uint listPosition;
}
mapping (uint => ORDER) public order;
uint[] public orderList;
event MARKET_CHANGE(address indexed token);
event DEPOSIT(address indexed user, address indexed token, uint wad, uint result);
event WITHDRAW(address indexed user, address indexed token, uint wad, uint result);
event ORDER_PLACE(address indexed user, address indexed token, bool isBuy, uint wad, uint price, uint indexed id);
event ORDER_CANCEL(address indexed user, address indexed token, uint indexed id);
event ORDER_MODIFY(address indexed user, address indexed token, uint indexed id, uint new_wad, uint new_price);
event ORDER_FILL(address indexed userTaker, address userMaker, address indexed token, bool isOriginalOrderBuy, uint fillAmt, uint price, uint indexed id);
event ORDER_DONE(address indexed userTaker, address userMaker, address indexed token, bool isOriginalOrderBuy, uint fillAmt, uint price, uint indexed id);
function getOrderCount() public constant returns (uint) {
return orderList.length;
}
function orderPlace(address token, bool isBuy, uint wad, uint price) public {
uint newLocked;
if (isBuy) {
newLocked = add(balanceLocked[0][msg.sender], mul(wad, price) / PRICE_FACTOR);
require(balance[0][msg.sender] >= newLocked);
balanceLocked[0][msg.sender] = newLocked;
} else {
newLocked = add(balanceLocked[token][msg.sender], wad);
require(balance[token][msg.sender] >= newLocked);
balanceLocked[token][msg.sender] = newLocked;
}
ORDER memory o;
o.token = token;
o.isBuy = isBuy;
o.wad = wad;
o.price = price;
o.user = msg.sender;
o.listPosition = orderList.length;
order[globalOrderSerial] = o;
orderList.push(globalOrderSerial);
ORDER_PLACE(msg.sender, token, isBuy, wad, price, globalOrderSerial);
globalOrderSerial++;
}
function orderTrade(uint orderID, uint wad, uint price) public {
ORDER storage o = order[orderID];
require(price == o.price);
uint fillAmt = sub(o.wad, o.wadFilled);
if (fillAmt > wad) fillAmt = wad;
uint fillETH = mul(fillAmt, price) / PRICE_FACTOR;
uint fee = mul(fillETH, tokenMarket[o.token].fee) / 1000000;
uint newTakerBalance;
if (o.isBuy) {
newTakerBalance = sub(balance[o.token][msg.sender], fillAmt);
require(newTakerBalance >= balanceLocked[o.token][msg.sender]);
balance[o.token][msg.sender] = newTakerBalance;
balance[0][o.user] = sub(balance[0][o.user], fillETH);
balanceLocked[0][o.user] = sub(balanceLocked[0][o.user], fillETH);
balance[o.token][o.user] = add(balance[o.token][o.user], fillAmt);
balance[0][msg.sender] = add(balance[0][msg.sender], sub(fillETH, fee));
} else {
newTakerBalance = sub(balance[0][msg.sender], add(fillETH, fee));
require(newTakerBalance >= balanceLocked[0][msg.sender]);
balance[0][msg.sender] = newTakerBalance;
balance[o.token][o.user] = sub(balance[o.token][o.user], fillAmt);
balanceLocked[o.token][o.user] = sub(balanceLocked[o.token][o.user], fillAmt);
balance[0][o.user] = add(balance[0][o.user], fillETH);
balance[o.token][msg.sender] = add(balance[o.token][msg.sender], fillAmt);
}
balance[0][admin] = add(balance[0][admin], fee);
o.wadFilled = add(o.wadFilled, fillAmt);
if (o.wadFilled >= o.wad) {
orderList[o.listPosition] = orderList[orderList.length - 1];
order[orderList[o.listPosition]].listPosition = o.listPosition;
orderList.length--;
ORDER_DONE(msg.sender, o.user, o.token, o.isBuy, fillAmt, price, orderID);
delete order[orderID];
} else {
ORDER_FILL(msg.sender, o.user, o.token, o.isBuy, fillAmt, price, orderID);
}
}
function orderCancel(uint orderID) public {
ORDER memory o = order[orderID];
require(o.user == msg.sender);
uint wadLeft = sub(o.wad, o.wadFilled);
if (o.isBuy) {
balanceLocked[0][msg.sender] = sub(balanceLocked[0][msg.sender], mul(o.price, wadLeft) / PRICE_FACTOR);
} else {
balanceLocked[o.token][msg.sender] = sub(balanceLocked[o.token][msg.sender], wadLeft);
}
ORDER_CANCEL(msg.sender, o.token, orderID);
orderList[o.listPosition] = orderList[orderList.length - 1];
order[orderList[o.listPosition]].listPosition = o.listPosition;
orderList.length--;
delete order[orderID];
}
function orderModify(uint orderID, uint new_wad, uint new_price) public {
ORDER storage o = order[orderID];
require(o.user == msg.sender);
require(o.wadFilled == 0);
uint newLocked;
if (o.isBuy) {
newLocked = sub(add(balanceLocked[0][msg.sender], mul(new_wad, new_price) / PRICE_FACTOR), mul(o.wad, o.price) / PRICE_FACTOR);
require(balance[0][msg.sender] >= newLocked);
balanceLocked[0][msg.sender] = newLocked;
} else {
newLocked = sub(add(balanceLocked[o.token][msg.sender], new_wad), o.wad);
require(balance[o.token][msg.sender] >= newLocked);
balanceLocked[o.token][msg.sender] = newLocked;
}
o.wad = new_wad;
o.price = new_price;
ORDER_MODIFY(msg.sender, o.token, orderID, new_wad, new_price);
}
function BitFrank() public {
admin = msg.sender;
adminSetMarket(0, 9, 0);
}
function adminSetAdmin(address newAdmin) public {
require(msg.sender == admin);
require(balance[0][newAdmin] > 0);
admin = newAdmin;
}
function adminSuspendDeposit(bool status) public {
require(msg.sender == admin);
suspendDeposit = status;
}
function adminSetMarket(address token, uint8 level_, uint fee_) public {
require(msg.sender == admin);
require(level_ != 0);
require(level_ <= 9);
if (tokenMarket[token].level == 0) {
tokenList.push(token);
}
tokenMarket[token].level = level_;
tokenMarket[token].fee = fee_;
MARKET_CHANGE(token);
}
function adminSetRegisterCost(uint cost_) public {
require(msg.sender == admin);
marketRegisterCost = cost_;
}
function adminSetDefaultFee(uint marketDefaultFeeLow_, uint marketDefaultFeeHigh_) public {
require(msg.sender == admin);
marketDefaultFeeLow = marketDefaultFeeLow_;
marketDefaultFeeHigh = marketDefaultFeeHigh_;
}
function marketRegisterToken(address token) public payable {
require(tokenMarket[token].level == 1);
require(msg.value >= marketRegisterCost);
balance[0][admin] = add(balance[0][admin], msg.value);
tokenMarket[token].level = 2;
tokenMarket[token].fee = marketDefaultFeeLow;
MARKET_CHANGE(token);
}
function getTokenCount() public constant returns (uint) {
return tokenList.length;
}
function depositETH() public payable {
require(!suspendDeposit);
balance[0][msg.sender] = add(balance[0][msg.sender], msg.value);
DEPOSIT(msg.sender, 0, msg.value, balance[0][msg.sender]);
}
function depositToken(address token, uint wad) public {
require(!suspendDeposit);
require(ERC20(token).transferFrom(msg.sender, this, wad));
if (tokenMarket[token].level == 0) {
tokenList.push(token);
tokenMarket[token].level = 1;
tokenMarket[token].fee = marketDefaultFeeHigh;
MARKET_CHANGE(token);
}
balance[token][msg.sender] = add(balance[token][msg.sender], wad);
DEPOSIT(msg.sender, token, wad, balance[token][msg.sender]);
}
function withdrawETH(uint wad) public {
balance[0][msg.sender] = sub(balance[0][msg.sender], wad);
require(balance[0][msg.sender] >= balanceLocked[0][msg.sender]);
msg.sender.transfer(wad);
WITHDRAW(msg.sender, 0, wad, balance[0][msg.sender]);
}
function withdrawToken(address token, uint wad) public {
require(token != 0);
balance[token][msg.sender] = sub(balance[token][msg.sender], wad);
require(balance[token][msg.sender] >= balanceLocked[token][msg.sender]);
require(ERC20(token).transfer(msg.sender, wad));
WITHDRAW(msg.sender, token, wad, balance[token][msg.sender]);
}
} | 1 | 3,357 |
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,686 |
pragma solidity ^0.4.19;
contract SVLightBallotBox {
address public owner;
bool public testMode = false;
struct Ballot {
bytes32 ballotData;
address sender;
uint32 blockN;
}
mapping (uint256 => Ballot) public ballotMap;
mapping (uint256 => bytes32) public associatedPubkeys;
uint256 public nVotesCast = 0;
mapping (address => uint256) public voterToBallotID;
bytes32 public ballotEncryptionSeckey;
bool seckeyRevealed = false;
uint64 public startTime;
uint64 public endTime;
uint64 public creationBlock;
uint64 public startingBlockAround;
bytes32 public specHash;
bool public useEncryption;
bool public deprecated = false;
event CreatedBallot(address _creator, uint64[2] _openPeriod, bool _useEncryption, bytes32 _specHash);
event SuccessfulPkVote(address voter, bytes32 ballot, bytes32 pubkey);
event SuccessfulVote(address voter, bytes32 ballot);
event SeckeyRevealed(bytes32 secretKey);
event TestingEnabled();
event Error(string error);
event DeprecatedContract();
event SetOwner(address _owner);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier ballotOpen {
require(uint64(block.timestamp) >= startTime && uint64(block.timestamp) < endTime);
_;
}
modifier onlyTesting {
require(testMode);
_;
}
modifier isTrue(bool _b) {
require(_b == true);
_;
}
modifier isFalse(bool _b) {
require(_b == false);
_;
}
uint16 constant F_USE_ENC = 0;
uint16 constant F_TESTING = 1;
function SVLightBallotBox(bytes32 _specHash, uint64[2] openPeriod, bool[2] flags) public {
owner = msg.sender;
startTime = max(openPeriod[0], uint64(block.timestamp));
endTime = openPeriod[1];
useEncryption = flags[F_USE_ENC];
specHash = _specHash;
creationBlock = uint64(block.number);
startingBlockAround = uint64((startTime - block.timestamp) / 15 + block.number);
if (flags[F_TESTING]) {
testMode = true;
TestingEnabled();
}
CreatedBallot(msg.sender, [startTime, endTime], useEncryption, specHash);
}
function submitBallotWithPk(bytes32 encryptedBallot, bytes32 senderPubkey) isTrue(useEncryption) ballotOpen public {
addBallotAndVoterWithPk(encryptedBallot, senderPubkey);
SuccessfulPkVote(msg.sender, encryptedBallot, senderPubkey);
}
function submitBallotNoPk(bytes32 ballot) isFalse(useEncryption) ballotOpen public {
addBallotAndVoterNoPk(ballot);
SuccessfulVote(msg.sender, ballot);
}
function addBallotAndVoterWithPk(bytes32 encryptedBallot, bytes32 senderPubkey) internal {
uint256 ballotNumber = addBallotAndVoterNoPk(encryptedBallot);
associatedPubkeys[ballotNumber] = senderPubkey;
}
function addBallotAndVoterNoPk(bytes32 encryptedBallot) internal returns (uint256) {
uint256 ballotNumber = nVotesCast;
ballotMap[ballotNumber] = Ballot(encryptedBallot, msg.sender, uint32(block.number));
voterToBallotID[msg.sender] = ballotNumber;
nVotesCast += 1;
return ballotNumber;
}
function revealSeckey(bytes32 _secKey) onlyOwner public {
require(block.timestamp > endTime);
ballotEncryptionSeckey = _secKey;
seckeyRevealed = true;
SeckeyRevealed(_secKey);
}
function getEncSeckey() public constant returns (bytes32) {
return ballotEncryptionSeckey;
}
function setEndTime(uint64 newEndTime) onlyTesting onlyOwner public {
endTime = newEndTime;
}
function setDeprecated() onlyOwner public {
deprecated = true;
DeprecatedContract();
}
function setOwner(address newOwner) onlyOwner public {
owner = newOwner;
SetOwner(newOwner);
}
function max(uint64 a, uint64 b) pure internal returns(uint64) {
if (a > b) {
return a;
}
return b;
}
}
contract SVLightIndexShim {
address public owner;
struct Ballot {
bytes32 specHash;
bytes32 extraData;
address votingContract;
uint64 startTs;
}
struct Democ {
string name;
address admin;
Ballot[] ballots;
}
mapping (bytes32 => Democ) public democs;
bytes32[] public democList;
bool public paymentEnabled = false;
SVLightIndexShim prevIndex;
event PaymentMade(uint128[2] valAndRemainder);
event DemocInit(string name, bytes32 democHash, address admin);
event BallotInit(bytes32 specHash, uint64[2] openPeriod, bool[2] flags);
event BallotAdded(bytes32 democHash, bytes32 specHash, bytes32 extraData, address votingContract);
event SetFees(uint128[2] _newFees);
event PaymentEnabled(bool _feeEnabled);
modifier onlyBy(address _account) {
require(msg.sender == _account);
_;
}
constructor(SVLightIndexShim _prevIndex) public {
owner = msg.sender;
prevIndex = _prevIndex;
bytes32 democHash;
bytes32 specHash;
bytes32 extraData;
address votingContract;
uint64 startTime;
for (uint i = 0; i < prevIndex.nDemocs(); i++) {
democHash = prevIndex.democList(i);
democList.push(democHash);
democs[democHash].admin = msg.sender;
for (uint j = 0; j < prevIndex.nBallots(democHash); j++) {
(specHash, extraData, votingContract, startTime) = prevIndex.getNthBallot(democHash, j);
democs[democHash].ballots.push(Ballot(specHash, extraData, votingContract, startTime));
}
}
}
function nDemocs() public constant returns (uint256) {
return democList.length;
}
function setOwner(address _owner) onlyBy(owner) public {
owner = _owner;
}
function setDemocAdminEmergency(bytes32 democHash, address newAdmin) onlyBy(owner) public {
democs[democHash].admin = newAdmin;
}
function getDemocInfo(bytes32 democHash) public constant returns (string name, address admin, uint256 nBallots) {
return ("SWM Governance", democs[democHash].admin, democs[democHash].ballots.length);
}
function setAdmin(bytes32 democHash, address newAdmin) onlyBy(democs[democHash].admin) public {
democs[democHash].admin = newAdmin;
}
function nBallots(bytes32 democHash) public constant returns (uint256) {
return democs[democHash].ballots.length;
}
function getNthBallot(bytes32 democHash, uint256 n) public constant returns (bytes32 specHash, bytes32 extraData, address votingContract, uint64 startTime) {
return (democs[democHash].ballots[n].specHash, democs[democHash].ballots[n].extraData, democs[democHash].ballots[n].votingContract, democs[democHash].ballots[n].startTs);
}
function _commitBallot(bytes32 democHash, bytes32 specHash, bytes32 extraData, address votingContract, uint64 startTs) internal {
democs[democHash].ballots.push(Ballot(specHash, extraData, votingContract, startTs));
BallotAdded(democHash, specHash, extraData, votingContract);
}
function addBallot(bytes32 democHash, bytes32 extraData, address votingContract)
onlyBy(democs[democHash].admin)
public
{
SVLightBallotBox bb = SVLightBallotBox(votingContract);
bytes32 specHash = bb.specHash();
uint64 startTs = bb.startTime();
_commitBallot(democHash, specHash, extraData, votingContract, startTs);
}
function deployBallot(bytes32 democHash, bytes32 specHash, bytes32 extraData,
uint64[2] openPeriod, bool[2] flags)
onlyBy(democs[democHash].admin)
public payable {
uint64 startTs = max(openPeriod[0], uint64(block.timestamp));
SVLightBallotBox votingContract = new SVLightBallotBox(specHash, [startTs, openPeriod[1]], flags);
votingContract.setOwner(msg.sender);
_commitBallot(democHash, specHash, extraData, address(votingContract), startTs);
BallotInit(specHash, [startTs, openPeriod[1]], flags);
}
function max(uint64 a, uint64 b) pure internal returns(uint64) {
if (a > b) {
return a;
}
return b;
}
} | 0 | 998 |
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;
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint indexed value, bytes data);
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract ERC223Token is ERC223Basic, BasicToken, ERC223Receiver {
using SafeMath for uint;
using AddressUtils for address;
function tokenFallback(address, uint, bytes) public {
revert();
}
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if (_to.isContract()) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
emit 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 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 ERC223MintableToken is MintableToken, ERC223Token {
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
bytes memory empty;
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
if (_to.isContract()) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(address(this), _amount, empty);
}
emit Mint(_to, _amount);
emit Transfer(msg.sender, _to, _amount, empty);
return true;
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "agrotoken";
string public constant TOKEN_SYMBOL = "AGRO";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x49ef7D625bF4Cc857fC4a16d13Aed0c5152b7Fb8;
bool public constant CONTINUE_MINTING = true;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
, ERC223MintableToken
{
event Initialized();
bool public initialized = false;
constructor() public {
init();
transferOwnership(TARGET_USER);
}
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 0 | 1,577 |
pragma solidity ^0.4.17;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract StandardMintableToken is ERC20, BasicToken, Ownable {
mapping (address => mapping (address => uint256)) allowed;
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
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];
}
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
}
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract SlotTicket is StandardMintableToken {
string public name = "Slot Ticket";
uint8 public decimals = 0;
string public symbol = "TICKET";
string public version = "0.7";
function destroy() onlyOwner {
selfdestruct(owner);
}
}
contract Slot is Ownable {
using SafeMath for uint256;
uint8 constant SIZE = 100;
uint32 constant JACKPOT_CHANCE = 1000000;
uint32 constant INACTIVITY = 160000;
uint256 constant PRICE = 100 finney;
uint256 constant JACK_DIST = 249 finney;
uint256 constant DIV_DIST = 249 finney;
uint256 constant GAS_REFUND = 2 finney;
mapping (uint => mapping (uint => address)) public participants;
SlotTicket public ticket;
uint256 public jackpotAmount;
uint256 public gameIndex;
uint256 public gameStartedAtBlock;
address public fund;
uint256[8] public prizes = [4 ether,
2 ether,
1 ether,
500 finney,
500 finney,
500 finney,
500 finney,
500 finney];
uint256 counter;
event ParticipantAdded(address indexed _participant, uint256 indexed _game, uint256 indexed _number);
event PrizeAwarded(uint256 indexed _game , address indexed _winner, uint256 indexed _amount);
event JackpotAwarded(uint256 indexed _game, address indexed _winner, uint256 indexed _amount);
event GameRefunded(uint256 _game);
function Slot(address _fundAddress) payable {
ticket = new SlotTicket();
fund = _fundAddress;
jackpotAmount = msg.value;
gameIndex = 0;
counter = 0;
gameStartedAtBlock = block.number;
}
function() payable {
buyTicketsFor(msg.sender);
}
function buyTicketsFor(address _beneficiary) public payable {
require(_beneficiary != 0x0);
require(msg.value >= PRICE);
uint256 change = msg.value%PRICE;
uint256 numberOfTickets = msg.value.sub(change).div(PRICE);
ticket.mint(_beneficiary, numberOfTickets);
addParticipant(_beneficiary, numberOfTickets);
msg.sender.transfer(change);
}
function addParticipant(address _participant, uint256 _numberOfTickets) private {
for (uint256 i = 0; i < _numberOfTickets; i++) {
participants[gameIndex][counter%SIZE] = _participant;
ParticipantAdded(_participant, gameIndex, counter%SIZE);
if (++counter%SIZE == 0) {
awardPrizes();
distributeRemaining();
increaseGame();
}
}
}
function awardPrizes() private {
uint256 hashNumber = uint256(keccak256(block.blockhash(block.number-1)));
uint256 winnerIndex = hashNumber%SIZE;
uint256 jackpotNumber = hashNumber%JACKPOT_CHANCE;
if (winnerIndex == jackpotNumber) {
distributeJackpot(winnerIndex);
}
for (uint8 i = 0; i < prizes.length; i++) {
participants[gameIndex][winnerIndex%SIZE].transfer(prizes[i]);
PrizeAwarded(gameIndex, participants[gameIndex][winnerIndex%SIZE], prizes[i]);
winnerIndex++;
}
}
function distributeJackpot(uint256 _winnerIndex) private {
uint256 amount = jackpotAmount;
jackpotAmount = 0;
participants[gameIndex][_winnerIndex].transfer(amount);
JackpotAwarded(gameIndex, participants[gameIndex][_winnerIndex], amount);
}
function distributeRemaining() private {
jackpotAmount = jackpotAmount.add(JACK_DIST);
fund.transfer(DIV_DIST);
msg.sender.transfer(GAS_REFUND);
}
function increaseGame() private {
gameIndex++;
gameStartedAtBlock = block.number;
}
function spotsLeft() public constant returns (uint8 spots) {
return SIZE - uint8(counter%SIZE);
}
function refundPlayersAfterVeryLongGame() public {
require(block.number.sub(gameStartedAtBlock) >= INACTIVITY);
require(counter%SIZE != 0);
uint256 _size = counter%SIZE;
counter -= _size;
for (uint8 i = 0; i < _size; i++) {
participants[gameIndex][i].transfer(PRICE);
}
GameRefunded(gameIndex);
increaseGame();
}
function destroy() public onlyOwner {
require(this.balance < 1 ether);
ticket.destroy();
selfdestruct(owner);
}
function changeTicketOwner(address _newOwner) public onlyOwner {
require(_newOwner != 0x0);
ticket.transferOwnership(_newOwner);
}
function changeFund(address _newFund) public onlyOwner {
require(_newFund != 0x0);
fund = _newFund;
}
function changeTicket(address _newTicket) public onlyOwner {
require(_newTicket != 0x0);
ticket = SlotTicket(_newTicket);
}
} | 1 | 4,217 |
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 Crowdsale {
using SafeMath for uint256;
MintableToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function hasEnded() public view returns (bool) {
return now > endTime;
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract 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 != address(0));
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);
}
}
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 = "ArgusNodeToken";
string constant TOKEN_SYMBOL = "ArNT";
bool constant PAUSED = false;
address constant TARGET_USER = 0x504FB379a29654A604FDe7B95972C74BFE07C118;
uint constant START_TIME = 1527818400;
bool constant CONTINUE_MINTING = false;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
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);
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function validPurchase() internal view returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
function hasEnded() public view returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public goal;
RefundVault public vault;
function RefundableCrowdsale(uint256 _goal) public {
require(_goal > 0);
vault = new RefundVault(wallet);
goal = _goal;
}
function forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
function claimRefund() public {
require(isFinalized);
require(!goalReached());
vault.refund(msg.sender);
}
function finalization() internal {
if (goalReached()) {
vault.close();
} else {
vault.enableRefunds();
}
super.finalization();
}
function goalReached() public view returns (bool) {
return weiRaised >= goal;
}
}
contract MainCrowdsale is Consts, FinalizableCrowdsale {
function hasStarted() public constant returns (bool) {
return now >= startTime;
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
token.finishMinting();
}
token.transferOwnership(TARGET_USER);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
}
contract Checkable {
address private serviceAccount;
bool private triggered = false;
event Triggered(uint balance);
event Checked(bool isAccident);
function Checkable() public {
serviceAccount = msg.sender;
}
function changeServiceAccount(address _account) onlyService public {
assert(_account != 0);
serviceAccount = _account;
}
function isServiceAccount() view public returns (bool) {
return msg.sender == serviceAccount;
}
function check() onlyService notTriggered payable public {
if (internalCheck()) {
Triggered(this.balance);
triggered = true;
internalAction();
}
}
function internalCheck() internal returns (bool);
function internalAction() internal;
modifier onlyService {
require(msg.sender == serviceAccount);
_;
}
modifier notTriggered() {
require(!triggered);
_;
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 bonusRate = getBonusRate(weiAmount);
uint256 tokens = weiAmount.mul(bonusRate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function getBonusRate(uint256 weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[3] memory weiRaisedStartsBoundaries = [uint(0),uint(100000000000000000000),uint(250000000000000000000)];
uint[3] memory weiRaisedEndsBoundaries = [uint(100000000000000000000),uint(250000000000000000000),uint(450000000000000000000)];
uint64[3] memory timeStartsBoundaries = [uint64(1527818400),uint64(1527818400),uint64(1527818400)];
uint64[3] memory timeEndsBoundaries = [uint64(1536544795),uint64(1536544795),uint64(1536544795)];
uint[3] memory weiRaisedAndTimeRates = [uint(150),uint(100),uint(50)];
for (uint i = 0; i < 3; i++) {
bool weiRaisedInBound = (weiRaisedStartsBoundaries[i] <= weiRaised) && (weiRaised < weiRaisedEndsBoundaries[i]);
bool timeInBound = (timeStartsBoundaries[i] <= now) && (now < timeEndsBoundaries[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
, CappedCrowdsale
, Checkable
{
event Initialized();
bool public initialized = false;
function TemplateCrowdsale(MintableToken _token) public
Crowdsale(START_TIME > now ? START_TIME : now, 1536544800, 1000 * TOKEN_DECIMAL_MULTIPLIER, 0x504FB379a29654A604FDe7B95972C74BFE07C118)
CappedCrowdsale(740000000000000000000)
{
token = _token;
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[1] memory addresses = [address(0x504fb379a29654a604fde7b95972c74bfe07c118)];
uint[1] memory amounts = [uint(460000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
Initialized();
}
function createTokenContract() internal returns (MintableToken) {
return MintableToken(0);
}
function internalCheck() internal returns (bool) {
bool result = !isFinalized && hasEnded();
Checked(result);
return result;
}
function internalAction() internal {
finalization();
Finalized();
isFinalized = true;
}
} | 0 | 1,826 |
pragma solidity 0.5.2;
contract EAO {
string public name = "EasyOption.io Assets Ownership";
string public symbol = "EAO";
uint256 public decimals = 8;
uint256 constant MAX_SUPPLY = 4800000000000000;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
uint256 public totalSupply = 0;
bool public stopped = false;
address owner = address(0);
modifier isOwner {
assert(owner == msg.sender);
_;
}
modifier isRunning {
assert (!stopped);
_;
}
modifier validAddress {
assert(address(0) != msg.sender);
_;
}
constructor() public {
owner = msg.sender;
totalSupply = MAX_SUPPLY;
balanceOf[msg.sender] = MAX_SUPPLY;
emit Transfer(address(0), msg.sender, MAX_SUPPLY);
}
function transfer(address _to, uint256 _value) public isRunning validAddress returns (bool success) {
require(balanceOf[msg.sender] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_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 isRunning validAddress returns (bool success) {
require(allowance[_from][msg.sender] >= _value);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
allowance[_from][msg.sender] -= _value;
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public isRunning validAddress returns (bool success) {
require(_value == 0 || allowance[msg.sender][_spender] == 0);
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function stop() public isOwner {
stopped = true;
}
function start() public isOwner {
stopped = false;
}
function setName(string memory _name) public isOwner {
name = _name;
}
function setSymbol(string memory _symbol) public isOwner {
symbol = _symbol;
}
function burn(uint256 _value) public {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
balanceOf[address(0)] += _value;
emit Transfer(msg.sender, address(0), _value);
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
} | 1 | 2,566 |
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;
}
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;
}
}
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 TokenLiquidityMarket {
using SafeMath for uint256;
address public platform;
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;
bool public admin_commission_activated;
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;
platform = msg.sender;
traded_token = _traded_token;
eth_seed_amount = _eth_seed_amount;
traded_token_seed_amount = _traded_token_seed_amount;
commission_ratio = _commission_ratio;
}
function change_admin(address _newAdmin) public only_admin() {
admin = _newAdmin;
}
function withdraw_arbitrary_token(address _token, uint256 _amount) public only_admin() {
require(_token != traded_token);
require(Token(_token).transfer(admin, _amount));
}
function withdraw_excess_tokens(uint256 _excess) public only_admin() {
require(Token(traded_token).transfer(address(this), traded_token_balance.add(_excess)));
require(Token(traded_token).transfer(admin, _excess));
}
function transfer_tokens_through_proxy_to_contract(address _from, address _to, uint256 _amount) private {
traded_token_balance = traded_token_balance.add(_amount);
require(Token(traded_token).transferFrom(_from,_to,_amount));
}
function transfer_tokens_from_contract(address _to, uint256 _amount) private {
traded_token_balance = traded_token_balance.sub(_amount);
require(Token(traded_token).transfer(_to,_amount));
}
function transfer_eth_to_contract() private {
eth_balance = eth_balance.add(msg.value);
}
function transfer_eth_from_contract(address _to, uint256 _amount) private {
eth_balance = eth_balance.sub(_amount);
_to.transfer(_amount);
}
function deposit_token(uint256 _amount) private {
transfer_tokens_through_proxy_to_contract(msg.sender, this, _amount);
}
function deposit_eth() private {
transfer_eth_to_contract();
}
function withdraw_token(uint256 _amount) public only_admin() {
transfer_tokens_from_contract(admin, _amount);
}
function withdraw_eth(uint256 _amount) public only_admin() {
transfer_eth_from_contract(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 (eth_balance.mul(_amount)).div(traded_token_balance_plus_amount_);
}
function get_amount_buy(uint256 _amount) public view returns(uint256) {
uint256 eth_balance_plus_amount_ = eth_balance.add(_amount);
return ((traded_token_balance).mul(_amount)).div(eth_balance_plus_amount_);
}
function get_amount_minus_commission(uint256 _amount) private view returns(uint256) {
return (_amount*(1 ether - commission_ratio))/(1 ether);
}
function activate_admin_commission() public only_admin() {
require(!admin_commission_activated);
admin_commission_activated = true;
}
function deactivate_admin_comission() public only_admin() {
require(admin_commission_activated);
admin_commission_activated = false;
}
function change_admin_commission(uint256 _new_commission_ratio) public only_admin() {
require(_new_commission_ratio != commission_ratio);
commission_ratio = _new_commission_ratio;
}
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 platform_commission_ = (amount_get_ - amount_get_minus_commission_) / 5;
uint256 admin_commission_ = ((amount_get_ - amount_get_minus_commission_) * 4) / 5;
transfer_tokens_through_proxy_to_contract(msg.sender,this,_amount_give);
transfer_eth_from_contract(msg.sender,amount_get_minus_commission_);
transfer_eth_from_contract(platform, platform_commission_);
if(admin_commission_activated) {
transfer_eth_from_contract(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 platform_commission_ = (amount_get_ - amount_get_minus_commission_) / 5;
uint256 admin_commission_ = ((amount_get_ - amount_get_minus_commission_) * 4) / 5;
transfer_eth_to_contract();
transfer_tokens_from_contract(msg.sender, amount_get_minus_commission_);
transfer_tokens_from_contract(platform, platform_commission_);
if(admin_commission_activated) {
transfer_tokens_from_contract(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 | 4,392 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract IVMToken {
string public name;
string public symbol;
uint8 public decimals = 12;
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 IVMToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
} | 1 | 2,942 |
pragma solidity ^0.4.9;
contract TimeLock {
address user;
uint balance;
uint depositTime;
function () payable {
if (user!=0)
throw;
user = msg.sender;
balance = msg.value;
depositTime = block.timestamp;
}
function withdraw (){
if (user==0){
throw;
}
if (block.timestamp-depositTime<20*60){
throw;
}
if(!user.send(balance))
throw;
delete user;
}
} | 0 | 440 |
pragma solidity ^0.4.6;
contract Presale {
string public constant VERSION = "0.1.4-beta";
uint public constant PRESALE_START = 3151809;
uint public constant PRESALE_END = 3152066;
uint public constant WITHDRAWAL_END = 3152323;
address public constant OWNER = 0xE76fE52a251C8F3a5dcD657E47A6C8D16Fdf4bFA;
uint public constant MIN_TOTAL_AMOUNT_TO_RECEIVE_ETH = 1;
uint public constant MAX_TOTAL_AMOUNT_TO_RECEIVE_ETH = 5;
uint public constant MIN_ACCEPTED_AMOUNT_FINNEY = 1;
string[5] private stateNames = ["BEFORE_START", "PRESALE_RUNNING", "WITHDRAWAL_RUNNING", "REFUND_RUNNING", "CLOSED" ];
enum State { BEFORE_START, PRESALE_RUNNING, WITHDRAWAL_RUNNING, REFUND_RUNNING, CLOSED }
uint public total_received_amount;
mapping (address => uint) public balances;
uint private constant MIN_TOTAL_AMOUNT_TO_RECEIVE = MIN_TOTAL_AMOUNT_TO_RECEIVE_ETH * 1 ether;
uint private constant MAX_TOTAL_AMOUNT_TO_RECEIVE = MAX_TOTAL_AMOUNT_TO_RECEIVE_ETH * 1 ether;
uint private constant MIN_ACCEPTED_AMOUNT = MIN_ACCEPTED_AMOUNT_FINNEY * 1 finney;
bool public isAborted = false;
function Presale () validSetupOnly() { }
function ()
payable
noReentrancy
{
State state = currentState();
if (state == State.PRESALE_RUNNING) {
receiveFunds();
} else if (state == State.REFUND_RUNNING) {
sendRefund();
} else {
throw;
}
}
function refund() external
inState(State.REFUND_RUNNING)
noReentrancy
{
sendRefund();
}
function withdrawFunds() external
inState(State.WITHDRAWAL_RUNNING)
onlyOwner
noReentrancy
{
if (!OWNER.send(this.balance)) throw;
}
function abort() external
inStateBefore(State.REFUND_RUNNING)
onlyOwner
{
isAborted = true;
}
function state() external constant
returns (string)
{
return stateNames[ uint(currentState()) ];
}
function sendRefund() private tokenHoldersOnly {
var amount_to_refund = balances[msg.sender] + msg.value;
balances[msg.sender] = 0;
if (!msg.sender.send(amount_to_refund)) throw;
}
function receiveFunds() private notTooSmallAmountOnly {
if (total_received_amount + msg.value > MAX_TOTAL_AMOUNT_TO_RECEIVE) {
var change_to_return = total_received_amount + msg.value - MAX_TOTAL_AMOUNT_TO_RECEIVE;
if (!msg.sender.send(change_to_return)) throw;
var acceptable_remainder = MAX_TOTAL_AMOUNT_TO_RECEIVE - total_received_amount;
balances[msg.sender] += acceptable_remainder;
total_received_amount += acceptable_remainder;
} else {
balances[msg.sender] += msg.value;
total_received_amount += msg.value;
}
}
function currentState() private constant returns (State) {
if (isAborted) {
return this.balance > 0
? State.REFUND_RUNNING
: State.CLOSED;
} else if (block.number < PRESALE_START) {
return State.BEFORE_START;
} else if (block.number <= PRESALE_END && total_received_amount < MAX_TOTAL_AMOUNT_TO_RECEIVE) {
return State.PRESALE_RUNNING;
} else if (this.balance == 0) {
return State.CLOSED;
} else if (block.number <= WITHDRAWAL_END && total_received_amount >= MIN_TOTAL_AMOUNT_TO_RECEIVE) {
return State.WITHDRAWAL_RUNNING;
} else {
return State.REFUND_RUNNING;
}
}
modifier inState(State state) {
if (state != currentState()) throw;
_;
}
modifier inStateBefore(State state) {
if (currentState() >= state) throw;
_;
}
modifier validSetupOnly() {
if ( OWNER == 0x0
|| PRESALE_START == 0
|| PRESALE_END == 0
|| WITHDRAWAL_END ==0
|| PRESALE_START <= block.number
|| PRESALE_START >= PRESALE_END
|| PRESALE_END >= WITHDRAWAL_END
|| MIN_TOTAL_AMOUNT_TO_RECEIVE > MAX_TOTAL_AMOUNT_TO_RECEIVE )
throw;
_;
}
modifier onlyOwner(){
if (msg.sender != OWNER) throw;
_;
}
modifier tokenHoldersOnly(){
if (balances[msg.sender] == 0) throw;
_;
}
modifier notTooSmallAmountOnly(){
if (msg.value < MIN_ACCEPTED_AMOUNT) throw;
_;
}
bool private locked = false;
modifier noReentrancy() {
if (locked) throw;
locked = true;
_;
locked = false;
}
} | 0 | 1,100 |
pragma solidity ^0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
pragma solidity ^0.5.2;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
pragma solidity ^0.5.2;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.2;
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 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) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
pragma solidity ^0.5.2;
contract Power {
string public version = "0.3";
uint256 private constant ONE = 1;
uint32 private constant MAX_WEIGHT = 1000000;
uint8 private constant MIN_PRECISION = 32;
uint8 private constant MAX_PRECISION = 127;
uint256 private constant FIXED_1 = 0x080000000000000000000000000000000;
uint256 private constant FIXED_2 = 0x100000000000000000000000000000000;
uint256 private constant MAX_NUM = 0x200000000000000000000000000000000;
uint256 private constant LN2_NUMERATOR = 0x3f80fe03f80fe03f80fe03f80fe03f8;
uint256 private constant LN2_DENOMINATOR = 0x5b9de1d10bf4103d647b0955897ba80;
uint256 private constant OPT_LOG_MAX_VAL =
0x15bf0a8b1457695355fb8ac404e7a79e3;
uint256 private constant OPT_EXP_MAX_VAL =
0x800000000000000000000000000000000;
uint256[128] private maxExpArray;
constructor() public {
maxExpArray[32] = 0x1c35fedd14ffffffffffffffffffffffff;
maxExpArray[33] = 0x1b0ce43b323fffffffffffffffffffffff;
maxExpArray[34] = 0x19f0028ec1ffffffffffffffffffffffff;
maxExpArray[35] = 0x18ded91f0e7fffffffffffffffffffffff;
maxExpArray[36] = 0x17d8ec7f0417ffffffffffffffffffffff;
maxExpArray[37] = 0x16ddc6556cdbffffffffffffffffffffff;
maxExpArray[38] = 0x15ecf52776a1ffffffffffffffffffffff;
maxExpArray[39] = 0x15060c256cb2ffffffffffffffffffffff;
maxExpArray[40] = 0x1428a2f98d72ffffffffffffffffffffff;
maxExpArray[41] = 0x13545598e5c23fffffffffffffffffffff;
maxExpArray[42] = 0x1288c4161ce1dfffffffffffffffffffff;
maxExpArray[43] = 0x11c592761c666fffffffffffffffffffff;
maxExpArray[44] = 0x110a688680a757ffffffffffffffffffff;
maxExpArray[45] = 0x1056f1b5bedf77ffffffffffffffffffff;
maxExpArray[46] = 0x0faadceceeff8bffffffffffffffffffff;
maxExpArray[47] = 0x0f05dc6b27edadffffffffffffffffffff;
maxExpArray[48] = 0x0e67a5a25da4107fffffffffffffffffff;
maxExpArray[49] = 0x0dcff115b14eedffffffffffffffffffff;
maxExpArray[50] = 0x0d3e7a392431239fffffffffffffffffff;
maxExpArray[51] = 0x0cb2ff529eb71e4fffffffffffffffffff;
maxExpArray[52] = 0x0c2d415c3db974afffffffffffffffffff;
maxExpArray[53] = 0x0bad03e7d883f69bffffffffffffffffff;
maxExpArray[54] = 0x0b320d03b2c343d5ffffffffffffffffff;
maxExpArray[55] = 0x0abc25204e02828dffffffffffffffffff;
maxExpArray[56] = 0x0a4b16f74ee4bb207fffffffffffffffff;
maxExpArray[57] = 0x09deaf736ac1f569ffffffffffffffffff;
maxExpArray[58] = 0x0976bd9952c7aa957fffffffffffffffff;
maxExpArray[59] = 0x09131271922eaa606fffffffffffffffff;
maxExpArray[60] = 0x08b380f3558668c46fffffffffffffffff;
maxExpArray[61] = 0x0857ddf0117efa215bffffffffffffffff;
maxExpArray[62] = 0x07ffffffffffffffffffffffffffffffff;
maxExpArray[63] = 0x07abbf6f6abb9d087fffffffffffffffff;
maxExpArray[64] = 0x075af62cbac95f7dfa7fffffffffffffff;
maxExpArray[65] = 0x070d7fb7452e187ac13fffffffffffffff;
maxExpArray[66] = 0x06c3390ecc8af379295fffffffffffffff;
maxExpArray[67] = 0x067c00a3b07ffc01fd6fffffffffffffff;
maxExpArray[68] = 0x0637b647c39cbb9d3d27ffffffffffffff;
maxExpArray[69] = 0x05f63b1fc104dbd39587ffffffffffffff;
maxExpArray[70] = 0x05b771955b36e12f7235ffffffffffffff;
maxExpArray[71] = 0x057b3d49dda84556d6f6ffffffffffffff;
maxExpArray[72] = 0x054183095b2c8ececf30ffffffffffffff;
maxExpArray[73] = 0x050a28be635ca2b888f77fffffffffffff;
maxExpArray[74] = 0x04d5156639708c9db33c3fffffffffffff;
maxExpArray[75] = 0x04a23105873875bd52dfdfffffffffffff;
maxExpArray[76] = 0x0471649d87199aa990756fffffffffffff;
maxExpArray[77] = 0x04429a21a029d4c1457cfbffffffffffff;
maxExpArray[78] = 0x0415bc6d6fb7dd71af2cb3ffffffffffff;
maxExpArray[79] = 0x03eab73b3bbfe282243ce1ffffffffffff;
maxExpArray[80] = 0x03c1771ac9fb6b4c18e229ffffffffffff;
maxExpArray[81] = 0x0399e96897690418f785257fffffffffff;
maxExpArray[82] = 0x0373fc456c53bb779bf0ea9fffffffffff;
maxExpArray[83] = 0x034f9e8e490c48e67e6ab8bfffffffffff;
maxExpArray[84] = 0x032cbfd4a7adc790560b3337ffffffffff;
maxExpArray[85] = 0x030b50570f6e5d2acca94613ffffffffff;
maxExpArray[86] = 0x02eb40f9f620fda6b56c2861ffffffffff;
maxExpArray[87] = 0x02cc8340ecb0d0f520a6af58ffffffffff;
maxExpArray[88] = 0x02af09481380a0a35cf1ba02ffffffffff;
maxExpArray[89] = 0x0292c5bdd3b92ec810287b1b3fffffffff;
maxExpArray[90] = 0x0277abdcdab07d5a77ac6d6b9fffffffff;
maxExpArray[91] = 0x025daf6654b1eaa55fd64df5efffffffff;
maxExpArray[92] = 0x0244c49c648baa98192dce88b7ffffffff;
maxExpArray[93] = 0x022ce03cd5619a311b2471268bffffffff;
maxExpArray[94] = 0x0215f77c045fbe885654a44a0fffffffff;
maxExpArray[95] = 0x01ffffffffffffffffffffffffffffffff;
maxExpArray[96] = 0x01eaefdbdaaee7421fc4d3ede5ffffffff;
maxExpArray[97] = 0x01d6bd8b2eb257df7e8ca57b09bfffffff;
maxExpArray[98] = 0x01c35fedd14b861eb0443f7f133fffffff;
maxExpArray[99] = 0x01b0ce43b322bcde4a56e8ada5afffffff;
maxExpArray[100] = 0x019f0028ec1fff007f5a195a39dfffffff;
maxExpArray[101] = 0x018ded91f0e72ee74f49b15ba527ffffff;
maxExpArray[102] = 0x017d8ec7f04136f4e5615fd41a63ffffff;
maxExpArray[103] = 0x016ddc6556cdb84bdc8d12d22e6fffffff;
maxExpArray[104] = 0x015ecf52776a1155b5bd8395814f7fffff;
maxExpArray[105] = 0x015060c256cb23b3b3cc3754cf40ffffff;
maxExpArray[106] = 0x01428a2f98d728ae223ddab715be3fffff;
maxExpArray[107] = 0x013545598e5c23276ccf0ede68034fffff;
maxExpArray[108] = 0x01288c4161ce1d6f54b7f61081194fffff;
maxExpArray[109] = 0x011c592761c666aa641d5a01a40f17ffff;
maxExpArray[110] = 0x0110a688680a7530515f3e6e6cfdcdffff;
maxExpArray[111] = 0x01056f1b5bedf75c6bcb2ce8aed428ffff;
maxExpArray[112] = 0x00faadceceeff8a0890f3875f008277fff;
maxExpArray[113] = 0x00f05dc6b27edad306388a600f6ba0bfff;
maxExpArray[114] = 0x00e67a5a25da41063de1495d5b18cdbfff;
maxExpArray[115] = 0x00dcff115b14eedde6fc3aa5353f2e4fff;
maxExpArray[116] = 0x00d3e7a3924312399f9aae2e0f868f8fff;
maxExpArray[117] = 0x00cb2ff529eb71e41582cccd5a1ee26fff;
maxExpArray[118] = 0x00c2d415c3db974ab32a51840c0b67edff;
maxExpArray[119] = 0x00bad03e7d883f69ad5b0a186184e06bff;
maxExpArray[120] = 0x00b320d03b2c343d4829abd6075f0cc5ff;
maxExpArray[121] = 0x00abc25204e02828d73c6e80bcdb1a95bf;
maxExpArray[122] = 0x00a4b16f74ee4bb2040a1ec6c15fbbf2df;
maxExpArray[123] = 0x009deaf736ac1f569deb1b5ae3f36c130f;
maxExpArray[124] = 0x00976bd9952c7aa957f5937d790ef65037;
maxExpArray[125] = 0x009131271922eaa6064b73a22d0bd4f2bf;
maxExpArray[126] = 0x008b380f3558668c46c91c49a2f8e967b9;
maxExpArray[127] = 0x00857ddf0117efa215952912839f6473e6;
}
function power(
uint256 _baseN,
uint256 _baseD,
uint32 _expN,
uint32 _expD
) internal view returns (uint256, uint8)
{
require(_baseN < MAX_NUM, "baseN exceeds max value.");
require(_baseN >= _baseD, "Bases < 1 are not supported.");
uint256 baseLog;
uint256 base = _baseN * FIXED_1 / _baseD;
if (base < OPT_LOG_MAX_VAL) {
baseLog = optimalLog(base);
} else {
baseLog = generalLog(base);
}
uint256 baseLogTimesExp = baseLog * _expN / _expD;
if (baseLogTimesExp < OPT_EXP_MAX_VAL) {
return (optimalExp(baseLogTimesExp), MAX_PRECISION);
} else {
uint8 precision = findPositionInMaxExpArray(baseLogTimesExp);
return (generalExp(baseLogTimesExp >> (MAX_PRECISION - precision), precision), precision);
}
}
function generalLog(uint256 _x) internal pure returns (uint256) {
uint256 res = 0;
uint256 x = _x;
if (x >= FIXED_2) {
uint8 count = floorLog2(x / FIXED_1);
x >>= count;
res = count * FIXED_1;
}
if (x > FIXED_1) {
for (uint8 i = MAX_PRECISION; i > 0; --i) {
x = (x * x) / FIXED_1;
if (x >= FIXED_2) {
x >>= 1;
res += ONE << (i - 1);
}
}
}
return res * LN2_NUMERATOR / LN2_DENOMINATOR;
}
function floorLog2(uint256 _n) internal pure returns (uint8) {
uint8 res = 0;
uint256 n = _n;
if (n < 256) {
while (n > 1) {
n >>= 1;
res += 1;
}
} else {
for (uint8 s = 128; s > 0; s >>= 1) {
if (n >= (ONE << s)) {
n >>= s;
res |= s;
}
}
}
return res;
}
function findPositionInMaxExpArray(uint256 _x)
internal view returns (uint8)
{
uint8 lo = MIN_PRECISION;
uint8 hi = MAX_PRECISION;
while (lo + 1 < hi) {
uint8 mid = (lo + hi) / 2;
if (maxExpArray[mid] >= _x)
lo = mid;
else
hi = mid;
}
if (maxExpArray[hi] >= _x)
return hi;
if (maxExpArray[lo] >= _x)
return lo;
assert(false);
return 0;
}
function generalExp(uint256 _x, uint8 _precision) internal pure returns (uint256) {
uint256 xi = _x;
uint256 res = 0;
xi = (xi * _x) >> _precision; res += xi * 0x3442c4e6074a82f1797f72ac0000000;
xi = (xi * _x) >> _precision; res += xi * 0x116b96f757c380fb287fd0e40000000;
xi = (xi * _x) >> _precision; res += xi * 0x045ae5bdd5f0e03eca1ff4390000000;
xi = (xi * _x) >> _precision; res += xi * 0x00defabf91302cd95b9ffda50000000;
xi = (xi * _x) >> _precision; res += xi * 0x002529ca9832b22439efff9b8000000;
xi = (xi * _x) >> _precision; res += xi * 0x00054f1cf12bd04e516b6da88000000;
xi = (xi * _x) >> _precision; res += xi * 0x0000a9e39e257a09ca2d6db51000000;
xi = (xi * _x) >> _precision; res += xi * 0x000012e066e7b839fa050c309000000;
xi = (xi * _x) >> _precision; res += xi * 0x000001e33d7d926c329a1ad1a800000;
xi = (xi * _x) >> _precision; res += xi * 0x0000002bee513bdb4a6b19b5f800000;
xi = (xi * _x) >> _precision; res += xi * 0x00000003a9316fa79b88eccf2a00000;
xi = (xi * _x) >> _precision; res += xi * 0x0000000048177ebe1fa812375200000;
xi = (xi * _x) >> _precision; res += xi * 0x0000000005263fe90242dcbacf00000;
xi = (xi * _x) >> _precision; res += xi * 0x000000000057e22099c030d94100000;
xi = (xi * _x) >> _precision; res += xi * 0x0000000000057e22099c030d9410000;
xi = (xi * _x) >> _precision; res += xi * 0x00000000000052b6b54569976310000;
xi = (xi * _x) >> _precision; res += xi * 0x00000000000004985f67696bf748000;
xi = (xi * _x) >> _precision; res += xi * 0x000000000000003dea12ea99e498000;
xi = (xi * _x) >> _precision; res += xi * 0x00000000000000031880f2214b6e000;
xi = (xi * _x) >> _precision; res += xi * 0x000000000000000025bcff56eb36000;
xi = (xi * _x) >> _precision; res += xi * 0x000000000000000001b722e10ab1000;
xi = (xi * _x) >> _precision; res += xi * 0x0000000000000000001317c70077000;
xi = (xi * _x) >> _precision; res += xi * 0x00000000000000000000cba84aafa00;
xi = (xi * _x) >> _precision; res += xi * 0x00000000000000000000082573a0a00;
xi = (xi * _x) >> _precision; res += xi * 0x00000000000000000000005035ad900;
xi = (xi * _x) >> _precision; res += xi * 0x000000000000000000000002f881b00;
xi = (xi * _x) >> _precision; res += xi * 0x0000000000000000000000001b29340;
xi = (xi * _x) >> _precision; res += xi * 0x00000000000000000000000000efc40;
xi = (xi * _x) >> _precision; res += xi * 0x0000000000000000000000000007fe0;
xi = (xi * _x) >> _precision; res += xi * 0x0000000000000000000000000000420;
xi = (xi * _x) >> _precision; res += xi * 0x0000000000000000000000000000021;
xi = (xi * _x) >> _precision; res += xi * 0x0000000000000000000000000000001;
return res / 0x688589cc0e9505e2f2fee5580000000 + _x + (ONE << _precision);
}
function optimalLog(uint256 x) internal pure returns (uint256) {
uint256 res = 0;
uint256 y;
uint256 z;
uint256 w;
if (x >= 0xd3094c70f034de4b96ff7d5b6f99fcd8) {res += 0x40000000000000000000000000000000; x = x * FIXED_1 / 0xd3094c70f034de4b96ff7d5b6f99fcd8;}
if (x >= 0xa45af1e1f40c333b3de1db4dd55f29a7) {res += 0x20000000000000000000000000000000; x = x * FIXED_1 / 0xa45af1e1f40c333b3de1db4dd55f29a7;}
if (x >= 0x910b022db7ae67ce76b441c27035c6a1) {res += 0x10000000000000000000000000000000; x = x * FIXED_1 / 0x910b022db7ae67ce76b441c27035c6a1;}
if (x >= 0x88415abbe9a76bead8d00cf112e4d4a8) {res += 0x08000000000000000000000000000000; x = x * FIXED_1 / 0x88415abbe9a76bead8d00cf112e4d4a8;}
if (x >= 0x84102b00893f64c705e841d5d4064bd3) {res += 0x04000000000000000000000000000000; x = x * FIXED_1 / 0x84102b00893f64c705e841d5d4064bd3;}
if (x >= 0x8204055aaef1c8bd5c3259f4822735a2) {res += 0x02000000000000000000000000000000; x = x * FIXED_1 / 0x8204055aaef1c8bd5c3259f4822735a2;}
if (x >= 0x810100ab00222d861931c15e39b44e99) {res += 0x01000000000000000000000000000000; x = x * FIXED_1 / 0x810100ab00222d861931c15e39b44e99;}
if (x >= 0x808040155aabbbe9451521693554f733) {res += 0x00800000000000000000000000000000; x = x * FIXED_1 / 0x808040155aabbbe9451521693554f733;}
z = y = x - FIXED_1;
w = y * y / FIXED_1;
res += z * (0x100000000000000000000000000000000 - y) / 0x100000000000000000000000000000000; z = z * w / FIXED_1;
res += z * (0x0aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa - y) / 0x200000000000000000000000000000000; z = z * w / FIXED_1;
res += z * (0x099999999999999999999999999999999 - y) / 0x300000000000000000000000000000000; z = z * w / FIXED_1;
res += z * (0x092492492492492492492492492492492 - y) / 0x400000000000000000000000000000000; z = z * w / FIXED_1;
res += z * (0x08e38e38e38e38e38e38e38e38e38e38e - y) / 0x500000000000000000000000000000000; z = z * w / FIXED_1;
res += z * (0x08ba2e8ba2e8ba2e8ba2e8ba2e8ba2e8b - y) / 0x600000000000000000000000000000000; z = z * w / FIXED_1;
res += z * (0x089d89d89d89d89d89d89d89d89d89d89 - y) / 0x700000000000000000000000000000000; z = z * w / FIXED_1;
res += z * (0x088888888888888888888888888888888 - y) / 0x800000000000000000000000000000000;
return res;
}
function optimalExp(uint256 x) internal pure returns (uint256) {
uint256 res = 0;
uint256 y;
uint256 z;
z = y = x % 0x10000000000000000000000000000000;
z = z * y / FIXED_1; res += z * 0x10e1b3be415a0000;
z = z * y / FIXED_1; res += z * 0x05a0913f6b1e0000;
z = z * y / FIXED_1; res += z * 0x0168244fdac78000;
z = z * y / FIXED_1; res += z * 0x004807432bc18000;
z = z * y / FIXED_1; res += z * 0x000c0135dca04000;
z = z * y / FIXED_1; res += z * 0x0001b707b1cdc000;
z = z * y / FIXED_1; res += z * 0x000036e0f639b800;
z = z * y / FIXED_1; res += z * 0x00000618fee9f800;
z = z * y / FIXED_1; res += z * 0x0000009c197dcc00;
z = z * y / FIXED_1; res += z * 0x0000000e30dce400;
z = z * y / FIXED_1; res += z * 0x000000012ebd1300;
z = z * y / FIXED_1; res += z * 0x0000000017499f00;
z = z * y / FIXED_1; res += z * 0x0000000001a9d480;
z = z * y / FIXED_1; res += z * 0x00000000001c6380;
z = z * y / FIXED_1; res += z * 0x000000000001c638;
z = z * y / FIXED_1; res += z * 0x0000000000001ab8;
z = z * y / FIXED_1; res += z * 0x000000000000017c;
z = z * y / FIXED_1; res += z * 0x0000000000000014;
z = z * y / FIXED_1; res += z * 0x0000000000000001;
res = res / 0x21c3677c82b40000 + y + FIXED_1;
if ((x & 0x010000000000000000000000000000000) != 0) res = res * 0x1c3d6a24ed82218787d624d3e5eba95f9 / 0x18ebef9eac820ae8682b9793ac6d1e776;
if ((x & 0x020000000000000000000000000000000) != 0) res = res * 0x18ebef9eac820ae8682b9793ac6d1e778 / 0x1368b2fc6f9609fe7aceb46aa619baed4;
if ((x & 0x040000000000000000000000000000000) != 0) res = res * 0x1368b2fc6f9609fe7aceb46aa619baed5 / 0x0bc5ab1b16779be3575bd8f0520a9f21f;
if ((x & 0x080000000000000000000000000000000) != 0) res = res * 0x0bc5ab1b16779be3575bd8f0520a9f21e / 0x0454aaa8efe072e7f6ddbab84b40a55c9;
if ((x & 0x100000000000000000000000000000000) != 0) res = res * 0x0454aaa8efe072e7f6ddbab84b40a55c5 / 0x00960aadc109e7a3bf4578099615711ea;
if ((x & 0x200000000000000000000000000000000) != 0) res = res * 0x00960aadc109e7a3bf4578099615711d7 / 0x0002bf84208204f5977f9a8cf01fdce3d;
if ((x & 0x400000000000000000000000000000000) != 0) res = res * 0x0002bf84208204f5977f9a8cf01fdc307 / 0x0000003c6ab775dd0b95b4cbee7e65d11;
return res;
}
}
pragma solidity ^0.5.2;
contract BancorBondingCurve is Power {
using SafeMath for uint256;
uint32 private constant MAX_RESERVE_RATIO = 1000000;
function calculatePurchaseReturn(
uint256 _supply,
uint256 _reserveBalance,
uint32 _reserveRatio,
uint256 _depositAmount) public view returns (uint256)
{
require(_supply > 0 && _reserveBalance > 0 && _reserveRatio > 0 && _reserveRatio <= MAX_RESERVE_RATIO);
if (_depositAmount == 0) {
return 0;
}
if (_reserveRatio == MAX_RESERVE_RATIO) {
return _supply.mul(_depositAmount).div(_reserveBalance);
}
uint256 result;
uint8 precision;
uint256 baseN = _depositAmount.add(_reserveBalance);
(result, precision) = power(
baseN, _reserveBalance, _reserveRatio, MAX_RESERVE_RATIO
);
uint256 newTokenSupply = _supply.mul(result) >> precision;
return newTokenSupply - _supply;
}
function calculateSaleReturn(
uint256 _supply,
uint256 _reserveBalance,
uint32 _reserveRatio,
uint256 _sellAmount) public view returns (uint256)
{
require(_supply > 0 && _reserveBalance > 0 && _reserveRatio > 0 && _reserveRatio <= MAX_RESERVE_RATIO && _sellAmount <= _supply);
if (_sellAmount == 0) {
return 0;
}
if (_sellAmount == _supply) {
return _reserveBalance;
}
if (_reserveRatio == MAX_RESERVE_RATIO) {
return _reserveBalance.mul(_sellAmount).div(_supply);
}
uint256 result;
uint8 precision;
uint256 baseD = _supply - _sellAmount;
(result, precision) = power(
_supply, baseD, MAX_RESERVE_RATIO, _reserveRatio
);
uint256 oldBalance = _reserveBalance.mul(result);
uint256 newBalance = _reserveBalance << precision;
return oldBalance.sub(newBalance).div(result);
}
}
pragma solidity ^0.5.2;
contract ContinuousToken is BancorBondingCurve, Ownable, ERC20 {
using SafeMath for uint256;
uint256 public scale = 10**18;
uint256 public reserveBalance = 10*scale;
uint256 public reserveRatio = 500000;
constructor() public {
_mint(msg.sender, 1*scale);
}
function mint(address reciever, uint value) internal {
require(value > 0, "Must send ether to buy tokens.");
_continuousMint(reciever, value);
}
function burn(uint256 _amount) public {
uint256 returnAmount = _continuousBurn(_amount);
msg.sender.transfer(returnAmount);
}
function calculateContinuousMintReturn(uint256 _amount)
public view returns (uint256 mintAmount)
{
return calculatePurchaseReturn(totalSupply(), reserveBalance, uint32(reserveRatio), _amount);
}
function calculateContinuousBurnReturn(uint256 _amount)
public view returns (uint256 burnAmount)
{
return calculateSaleReturn(totalSupply(), reserveBalance, uint32(reserveRatio), _amount);
}
function _continuousMint(address reciever, uint value)
internal returns (uint256)
{
require(value > 0, "Deposit must be non-zero.");
uint256 amount = calculateContinuousMintReturn(value);
_mint(reciever, amount);
reserveBalance = reserveBalance.add(value);
return amount;
}
function _continuousBurn(uint256 _amount)
internal returns (uint256)
{
require(_amount > 0, "Amount must be non-zero.");
require(balanceOf(msg.sender) >= _amount, "Insufficient tokens to burn.");
uint256 reimburseAmount = calculateContinuousBurnReturn(_amount);
reserveBalance = reserveBalance.sub(reimburseAmount);
_burn(msg.sender, _amount);
return reimburseAmount;
}
}
pragma solidity ^0.5.2;
contract SpaceMiners is Ownable, ContinuousToken {
using SafeMath for uint;
uint public PRICE_TO_MINE = 20 finney;
uint public PLANET_CAPACITY = 6;
uint public NUM_WINNERS = 3;
uint constant OWNER_FEE_PERCENT = 5;
address[] miners = new address[](PLANET_CAPACITY);
uint public planetPopulation = 0;
uint ownerHoldings = 1;
string public constant name = "Kerium Crystals";
string public constant symbol = "KMC";
uint8 public constant decimals = 18;
function setGameSettings(uint priceToMine, uint planetCapacity, uint numWinners) public payable onlyOwner {
PRICE_TO_MINE = priceToMine;
PLANET_CAPACITY = planetCapacity;
NUM_WINNERS = numWinners;
}
function getNumUsersMinersOnPlanet(address miner) public view returns (uint) {
uint count = 0;
for (uint i = 0; i < planetPopulation; i++) {
if (miners[i] == miner) {
count++;
}
}
return count;
}
function sendSingleMinerToPlanet(address miner) internal {
miners[planetPopulation] = miner;
planetPopulation = planetPopulation.add(1);
if (planetPopulation == PLANET_CAPACITY) {
rewardMiners();
planetPopulation = 0;
}
}
function sendMinersToPlanet(uint numMiners) public payable {
require(msg.value >= numMiners * PRICE_TO_MINE, "Not enough paid");
require(planetPopulation < PLANET_CAPACITY, "Planet is full");
mint(msg.sender, numMiners);
for (uint i = 0; i < numMiners; i++) {
sendSingleMinerToPlanet(msg.sender);
}
}
function percentOfValue(uint percent, uint value) pure internal returns (uint) {
return (value.mul(percent)).div(100);
}
function getRandom(uint cap) view internal returns (uint) {
return uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % cap;
}
function rewardMiners() internal {
uint roundEarnings = PRICE_TO_MINE * PLANET_CAPACITY;
uint ownerFee = percentOfValue(OWNER_FEE_PERCENT, roundEarnings);
ownerHoldings = ownerHoldings.add(ownerFee);
roundEarnings = roundEarnings.sub(ownerFee);
uint rewardAmount = roundEarnings.div(NUM_WINNERS);
uint rnd = getRandom(PLANET_CAPACITY);
for (uint i = rnd; i < rnd + NUM_WINNERS; i++) {
if (i >= PLANET_CAPACITY) {
mint(miners[i - PLANET_CAPACITY], rewardAmount);
} else {
mint(miners[i], rewardAmount);
}
}
}
function cashOutOwnerFee() public payable onlyOwner {
require(ownerHoldings > 1);
msg.sender.transfer(ownerHoldings - 1);
ownerHoldings = 1;
}
function() external payable {
address payable payableAddress = address(uint160(owner()));
payableAddress.transfer(msg.value);
}
} | 1 | 2,377 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract HoldToken is MintableToken {
using SafeMath for uint256;
string public name = 'HOLD';
string public symbol = 'HOLD';
uint8 public decimals = 18;
event Burn(address indexed burner, uint256 value);
event BurnTransferred(address indexed previousBurner, address indexed newBurner);
address burnerRole;
modifier onlyBurner() {
require(msg.sender == burnerRole);
_;
}
function HoldToken(address _burner) public {
burnerRole = _burner;
}
function transferBurnRole(address newBurner) public onlyBurner {
require(newBurner != address(0));
BurnTransferred(burnerRole, newBurner);
burnerRole = newBurner;
}
function burn(uint256 _value) public onlyBurner {
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(msg.sender, _value);
Transfer(msg.sender, address(0), _value);
}
}
contract Crowdsale {
using SafeMath for uint256;
HoldToken public token;
uint256 public startTime;
uint256 public endTime;
uint256 public rate;
address public wallet;
uint256 public weiRaised;
event TokenPurchase(address indexed beneficiary, uint256 indexed value, uint256 indexed amount, uint256 transactionId);
function Crowdsale(
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
address _wallet,
uint256 _initialWeiRaised
) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_wallet != address(0));
require(_rate > 0);
token = new HoldToken(_wallet);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
weiRaised = _initialWeiRaised;
}
function hasEnded() public view returns (bool) {
return now > endTime;
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
address public beneficiary;
uint256 public releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
contract CappedCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
uint256 public hardCap;
uint256 public tokensToLock;
uint256 public releaseTime;
bool public isFinalized = false;
TokenTimelock public timeLock;
event Finalized();
event FinishMinting();
event TokensMinted(
address indexed beneficiary,
uint256 indexed amount
);
function CappedCrowdsale(uint256 _hardCap, uint256 _tokensToLock, uint256 _releaseTime) public {
require(_hardCap > 0);
require(_tokensToLock > 0);
require(_releaseTime > endTime);
hardCap = _hardCap;
releaseTime = _releaseTime;
tokensToLock = _tokensToLock;
timeLock = new TokenTimelock(token, wallet, releaseTime);
}
function finalize() onlyOwner public {
require(!isFinalized);
token.mint(address(timeLock), tokensToLock);
Finalized();
isFinalized = true;
}
function finishMinting() onlyOwner public {
require(token.mintingFinished() == false);
require(isFinalized);
token.finishMinting();
FinishMinting();
}
function mint(address beneficiary, uint256 amount) onlyOwner public {
require(!token.mintingFinished());
require(isFinalized);
require(amount > 0);
require(beneficiary != address(0));
token.mint(beneficiary, amount);
TokensMinted(beneficiary, amount);
}
function hasEnded() public view returns (bool) {
bool capReached = weiRaised >= hardCap;
return super.hasEnded() || capReached || isFinalized;
}
}
contract OnlyWhiteListedAddresses is Ownable {
using SafeMath for uint256;
address utilityAccount;
mapping (address => bool) whitelist;
mapping (address => address) public referrals;
modifier onlyOwnerOrUtility() {
require(msg.sender == owner || msg.sender == utilityAccount);
_;
}
event WhitelistedAddresses(
address[] users
);
event ReferralsAdded(
address[] user,
address[] referral
);
function OnlyWhiteListedAddresses(address _utilityAccount) public {
utilityAccount = _utilityAccount;
}
function whitelistAddress (address[] users) public onlyOwnerOrUtility {
for (uint i = 0; i < users.length; i++) {
whitelist[users[i]] = true;
}
WhitelistedAddresses(users);
}
function addAddressReferrals (address[] users, address[] _referrals) public onlyOwnerOrUtility {
require(users.length == _referrals.length);
for (uint i = 0; i < users.length; i++) {
require(isWhiteListedAddress(users[i]));
referrals[users[i]] = _referrals[i];
}
ReferralsAdded(users, _referrals);
}
function isWhiteListedAddress (address addr) public view returns (bool) {
return whitelist[addr];
}
}
contract HoldCrowdsale is CappedCrowdsale, OnlyWhiteListedAddresses {
using SafeMath for uint256;
struct TokenPurchaseRecord {
uint256 timestamp;
uint256 weiAmount;
address beneficiary;
}
uint256 transactionId = 1;
mapping (uint256 => TokenPurchaseRecord) pendingTransactions;
mapping (uint256 => bool) completedTransactions;
uint256 public referralPercentage;
uint256 public individualCap;
event TokenPurchaseRequest(
uint256 indexed transactionId,
address beneficiary,
uint256 indexed timestamp,
uint256 indexed weiAmount,
uint256 tokensAmount
);
event ReferralTokensSent(
address indexed beneficiary,
uint256 indexed tokensAmount,
uint256 indexed transactionId
);
event BonusTokensSent(
address indexed beneficiary,
uint256 indexed tokensAmount,
uint256 indexed transactionId
);
function HoldCrowdsale(
uint256 _startTime,
uint256 _endTime,
uint256 _icoHardCapWei,
uint256 _referralPercentage,
uint256 _rate,
address _wallet,
uint256 _tokensToLock,
uint256 _releaseTime,
uint256 _privateWeiRaised,
uint256 _individualCap,
address _utilityAccount
) public
OnlyWhiteListedAddresses(_utilityAccount)
CappedCrowdsale(_icoHardCapWei, _tokensToLock, _releaseTime)
Crowdsale(_startTime, _endTime, _rate, _wallet, _privateWeiRaised)
{
referralPercentage = _referralPercentage;
individualCap = _individualCap;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(!isFinalized);
require(beneficiary == msg.sender);
require(msg.value != 0);
require(msg.value >= individualCap);
uint256 weiAmount = msg.value;
require(isWhiteListedAddress(beneficiary));
require(validPurchase(weiAmount));
weiRaised = weiRaised.add(weiAmount);
uint256 _transactionId = transactionId;
uint256 tokensAmount = weiAmount.mul(rate);
pendingTransactions[_transactionId] = TokenPurchaseRecord(now, weiAmount, beneficiary);
transactionId += 1;
TokenPurchaseRequest(_transactionId, beneficiary, now, weiAmount, tokensAmount);
forwardFunds();
}
function issueTokensMultiple(uint256[] _transactionIds, uint256[] bonusTokensAmounts) public onlyOwner {
require(isFinalized);
require(_transactionIds.length == bonusTokensAmounts.length);
for (uint i = 0; i < _transactionIds.length; i++) {
issueTokens(_transactionIds[i], bonusTokensAmounts[i]);
}
}
function issueTokens(uint256 _transactionId, uint256 bonusTokensAmount) internal {
require(completedTransactions[_transactionId] != true);
require(pendingTransactions[_transactionId].timestamp != 0);
TokenPurchaseRecord memory record = pendingTransactions[_transactionId];
uint256 tokens = record.weiAmount.mul(rate);
address referralAddress = referrals[record.beneficiary];
token.mint(record.beneficiary, tokens);
TokenPurchase(record.beneficiary, record.weiAmount, tokens, _transactionId);
completedTransactions[_transactionId] = true;
if (bonusTokensAmount != 0) {
require(bonusTokensAmount != 0);
token.mint(record.beneficiary, bonusTokensAmount);
BonusTokensSent(record.beneficiary, bonusTokensAmount, _transactionId);
}
if (referralAddress != address(0)) {
uint256 referralAmount = tokens.mul(referralPercentage).div(uint256(100));
token.mint(referralAddress, referralAmount);
ReferralTokensSent(referralAddress, referralAmount, _transactionId);
}
}
function validPurchase(uint256 weiAmount) internal view returns (bool) {
bool withinCap = weiRaised.add(weiAmount) <= hardCap;
bool withinCrowdsaleInterval = now >= startTime && now <= endTime;
return withinCrowdsaleInterval && withinCap;
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract Migrations {
address public owner;
uint public last_completed_migration;
modifier restricted() {
if (msg.sender == owner) _;
}
function Migrations() public {
owner = msg.sender;
}
function setCompleted(uint completed) public restricted {
last_completed_migration = completed;
}
function upgrade(address new_address) public restricted {
Migrations upgraded = Migrations(new_address);
upgraded.setCompleted(last_completed_migration);
}
} | 0 | 649 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "bitCRΞP";
string public constant TOKEN_SYMBOL = "CREP";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x1cb265d7a9d44d6fe34101c7e01d8461587f46fc;
uint public constant START_TIME = 1541890817;
bool public constant CONTINUE_MINTING = false;
}
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
contract MainCrowdsale is Consts, FinalizableCrowdsale, MintedCrowdsale, CappedCrowdsale {
function hasStarted() public view returns (bool) {
return now >= openingTime;
}
function startTime() public view returns (uint256) {
return openingTime;
}
function endTime() public view returns (uint256) {
return closingTime;
}
function hasClosed() public view returns (bool) {
return super.hasClosed() || capReached();
}
function hasEnded() public view returns (bool) {
return hasClosed();
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
require(MintableToken(token).finishMinting());
}
Ownable(token).transferOwnership(TARGET_USER);
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate).div(1 ether);
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 bonusRate = getBonusRate(_weiAmount);
return _weiAmount.mul(bonusRate).div(1 ether);
}
function getBonusRate(uint256 _weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[4] memory weiRaisedStartsBounds = [uint(0),uint(40000000000000000000000),uint(60000000000000000000000),uint(70000000000000000000000)];
uint[4] memory weiRaisedEndsBounds = [uint(40000000000000000000000),uint(60000000000000000000000),uint(70000000000000000000000),uint(80000000000000000000000)];
uint64[4] memory timeStartsBounds = [uint64(1541890817),uint64(1546124400),uint64(1552604400),uint64(1559167200)];
uint64[4] memory timeEndsBounds = [uint64(1546124400),uint64(1552604400),uint64(1559167200),uint64(1560722400)];
uint[4] memory weiRaisedAndTimeRates = [uint(500),uint(400),uint(300),uint(200)];
for (uint i = 0; i < 4; i++) {
bool weiRaisedInBound = (weiRaisedStartsBounds[i] <= weiRaised) && (weiRaised < weiRaisedEndsBounds[i]);
bool timeInBound = (timeStartsBounds[i] <= now) && (now < timeEndsBounds[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
uint[2] memory weiAmountBounds = [uint(8000000000000000000000),uint(800000000000000000000)];
uint[2] memory weiAmountRates = [uint(0),uint(1000)];
for (uint j = 0; j < 2; j++) {
if (_weiAmount >= weiAmountBounds[j]) {
bonusRate += bonusRate * weiAmountRates[j] / 1000;
break;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
{
event Initialized();
event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime);
bool public initialized = false;
constructor(MintableToken _token) public
Crowdsale(40 * TOKEN_DECIMAL_MULTIPLIER, 0xf227e2528e444394131b33f7174589c5d9f28357, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1565301600)
CappedCrowdsale(80000000000000000000000)
{
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
transferOwnership(TARGET_USER);
emit Initialized();
}
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 1000000000000000000;
return super.hasClosed() || remainValue;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= 1000000000000000000);
require(msg.value <= 3000000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 0 | 1,546 |
pragma solidity ^0.4.14;
contract DSMath {
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x + y) >= x);
}
function sub(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x - y) <= x);
}
function mul(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x * y) >= x);
}
function div(uint256 x, uint256 y) constant internal returns (uint256 z) {
z = x / y;
}
function min(uint256 x, uint256 y) constant internal returns (uint256 z) {
return x <= y ? x : y;
}
function max(uint256 x, uint256 y) constant internal returns (uint256 z) {
return x >= y ? x : y;
}
function hadd(uint128 x, uint128 y) constant internal returns (uint128 z) {
assert((z = x + y) >= x);
}
function hsub(uint128 x, uint128 y) constant internal returns (uint128 z) {
assert((z = x - y) <= x);
}
function hmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
assert((z = x * y) >= x);
}
function hdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = x / y;
}
function hmin(uint128 x, uint128 y) constant internal returns (uint128 z) {
return x <= y ? x : y;
}
function hmax(uint128 x, uint128 y) constant internal returns (uint128 z) {
return x >= y ? x : y;
}
function imin(int256 x, int256 y) constant internal returns (int256 z) {
return x <= y ? x : y;
}
function imax(int256 x, int256 y) constant internal returns (int256 z) {
return x >= y ? x : y;
}
uint128 constant WAD = 10 ** 18;
function wadd(uint128 x, uint128 y) constant internal returns (uint128) {
return hadd(x, y);
}
function wsub(uint128 x, uint128 y) constant internal returns (uint128) {
return hsub(x, y);
}
function wmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * y + WAD / 2) / WAD);
}
function wdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * WAD + y / 2) / y);
}
function wmin(uint128 x, uint128 y) constant internal returns (uint128) {
return hmin(x, y);
}
function wmax(uint128 x, uint128 y) constant internal returns (uint128) {
return hmax(x, y);
}
uint128 constant RAY = 10 ** 27;
function radd(uint128 x, uint128 y) constant internal returns (uint128) {
return hadd(x, y);
}
function rsub(uint128 x, uint128 y) constant internal returns (uint128) {
return hsub(x, y);
}
function rmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * y + RAY / 2) / RAY);
}
function rdiv(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * RAY + y / 2) / y);
}
function rpow(uint128 x, uint64 n) constant internal returns (uint128 z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
function rmin(uint128 x, uint128 y) constant internal returns (uint128) {
return hmin(x, y);
}
function rmax(uint128 x, uint128 y) constant internal returns (uint128) {
return hmax(x, y);
}
function cast(uint256 x) constant internal returns (uint128 z) {
assert((z = uint128(x)) == x);
}
}
contract Owned
{
address public owner;
function Owned()
{
owner = msg.sender;
}
modifier onlyOwner()
{
if (msg.sender != owner) revert();
_;
}
}
contract ProspectorsCrowdsale is Owned, DSMath
{
ProspectorsGoldToken public token;
address public dev_multisig;
uint public total_raised;
uint public contributors_count = 0;
uint public constant start_time = 1502377200;
uint public constant end_time = 1505055600;
uint public constant bonus_amount = 10000000 * 10**18;
uint public constant start_amount = 60000000 * 10**18;
uint public constant price = 0.0005 * 10**18;
uint public constant bonus_price = 0.0004 * 10**18;
uint public constant goal = 2000 ether;
bool private closed = false;
mapping(address => uint) funded;
modifier in_time
{
if (time() < start_time || time() > end_time) revert();
_;
}
function is_success() public constant returns (bool)
{
return closed == true && total_raised >= goal;
}
function time() public constant returns (uint)
{
return block.timestamp;
}
function my_token_balance() public constant returns (uint)
{
return token.balanceOf(this);
}
function available_with_bonus() public constant returns (uint)
{
return my_token_balance() >= min_balance_for_bonus() ?
my_token_balance() - min_balance_for_bonus()
:
0;
}
function available_without_bonus() private constant returns (uint)
{
return min(my_token_balance(), min_balance_for_bonus());
}
function min_balance_for_bonus() private constant returns (uint)
{
return start_amount - bonus_amount;
}
modifier has_value
{
if (msg.value < 0.01 ether) revert();
_;
}
function init(address _token_address, address _dev_multisig) onlyOwner
{
if (address(0) != address(token)) revert();
token = ProspectorsGoldToken(_token_address);
dev_multisig = _dev_multisig;
}
function participate() in_time has_value private {
if (my_token_balance() == 0 || closed == true) revert();
var remains = msg.value;
var can_with_bonus = wdiv(cast(remains), cast(bonus_price));
var buy_amount = cast(min(can_with_bonus, available_with_bonus()));
remains = sub(remains, wmul(buy_amount, cast(bonus_price)));
if (buy_amount < can_with_bonus)
{
var can_without_bonus = wdiv(cast(remains), cast(price));
var buy_without_bonus = cast(min(can_without_bonus, available_without_bonus()));
remains = sub(remains, wmul(buy_without_bonus, cast(price)));
buy_amount = hadd(buy_amount, buy_without_bonus);
}
if (remains > 0) revert();
total_raised = add(total_raised, msg.value);
if (funded[msg.sender] == 0) contributors_count++;
funded[msg.sender] = add(funded[msg.sender], msg.value);
token.transfer(msg.sender, buy_amount);
}
function refund()
{
if (total_raised >= goal || closed == false) revert();
var amount = funded[msg.sender];
if (amount > 0)
{
funded[msg.sender] = 0;
msg.sender.transfer(amount);
}
}
function closeCrowdsale()
{
if (closed == false && time() > start_time && (time() > end_time || my_token_balance() == 0))
{
closed = true;
if (is_success())
{
token.unlock();
if (my_token_balance() > 0)
{
token.transfer(0xb1, my_token_balance());
}
}
}
else
{
revert();
}
}
function collect()
{
if (total_raised < goal) revert();
dev_multisig.transfer(this.balance);
}
function () payable external
{
participate();
}
function destroy() onlyOwner
{
if (time() > end_time + 180 days)
{
selfdestruct(dev_multisig);
}
}
}
contract ProspectorsGoldToken {
function balanceOf( address who ) constant returns (uint value);
function transfer( address to, uint value) returns (bool ok);
function unlock() returns (bool ok);
} | 1 | 3,410 |
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 ERC20Token is StandardToken {
function () {
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = '1.0';
function ERC20Token(
) {
balances[msg.sender] = 500000000000000000;
totalSupply = 500000000000000000;
name = "HanRaCoin";
decimals = 8;
symbol = "HRC";
}
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,031 |
pragma solidity ^0.4.0;
contract EthBird {
address public owner;
address highScoreUser;
uint currentHighScore = 0;
uint contestStartTime = now;
mapping(address => bool) paidUsers;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function EthBird() public {
owner = msg.sender;
}
function payEntryFee() public payable {
if (msg.value >= 0.001 ether) {
paidUsers[msg.sender] = true;
}
}
function getCurrentHighscore() public constant returns (uint) {
return currentHighScore;
}
function getCurrentHighscoreUser() public constant returns (address) {
return highScoreUser;
}
function getCurrentJackpot() public constant returns (uint) {
return address(this).balance;
}
function getNextPayoutEstimation() public constant returns (uint) {
return (contestStartTime + 1 days) - now;
}
function recordHighScore(uint score, address userToScore) public onlyOwner returns (address) {
if(paidUsers[userToScore]){
if(score > 0 && score >= currentHighScore){
highScoreUser = userToScore;
currentHighScore = score;
}
if(now >= contestStartTime + 1 days){
awardHighScore();
}
}
return userToScore;
}
function awardHighScore() public onlyOwner {
uint256 ownerCommision = address(this).balance / 10;
address(owner).transfer(ownerCommision);
address(highScoreUser).transfer(address(this).balance);
contestStartTime = now;
}
} | 0 | 630 |
pragma solidity ^0.4.22;
contract LastManStanding {
uint lastBlock;
address owner;
modifier onlyowner {
require (msg.sender == owner);
_;
}
function LastManStanding() public {
owner = msg.sender;
}
function () public payable {
mineIsBigger();
}
function mineIsBigger() public payable {
if (msg.value > this.balance) {
owner = msg.sender;
lastBlock = now;
}
}
function withdraw() public onlyowner {
require(now > lastBlock + 5 hours);
msg.sender.transfer(this.balance);
}
} | 0 | 672 |
pragma solidity^0.4.11;
library AttributeStore {
struct Data {
mapping(bytes32 => uint) store;
}
function getAttribute(Data storage self, bytes32 _UUID, string _attrName)
public view returns (uint) {
bytes32 key = keccak256(_UUID, _attrName);
return self.store[key];
}
function setAttribute(Data storage self, bytes32 _UUID, string _attrName, uint _attrVal)
public {
bytes32 key = keccak256(_UUID, _attrName);
self.store[key] = _attrVal;
}
}
library DLL {
uint constant NULL_NODE_ID = 0;
struct Node {
uint next;
uint prev;
}
struct Data {
mapping(uint => Node) dll;
}
function isEmpty(Data storage self) public view returns (bool) {
return getStart(self) == NULL_NODE_ID;
}
function contains(Data storage self, uint _curr) public view returns (bool) {
if (isEmpty(self) || _curr == NULL_NODE_ID) {
return false;
}
bool isSingleNode = (getStart(self) == _curr) && (getEnd(self) == _curr);
bool isNullNode = (getNext(self, _curr) == NULL_NODE_ID) && (getPrev(self, _curr) == NULL_NODE_ID);
return isSingleNode || !isNullNode;
}
function getNext(Data storage self, uint _curr) public view returns (uint) {
return self.dll[_curr].next;
}
function getPrev(Data storage self, uint _curr) public view returns (uint) {
return self.dll[_curr].prev;
}
function getStart(Data storage self) public view returns (uint) {
return getNext(self, NULL_NODE_ID);
}
function getEnd(Data storage self) public view returns (uint) {
return getPrev(self, NULL_NODE_ID);
}
function insert(Data storage self, uint _prev, uint _curr, uint _next) public {
require(_curr != NULL_NODE_ID);
remove(self, _curr);
require(_prev == NULL_NODE_ID || contains(self, _prev));
require(_next == NULL_NODE_ID || contains(self, _next));
require(getNext(self, _prev) == _next);
require(getPrev(self, _next) == _prev);
self.dll[_curr].prev = _prev;
self.dll[_curr].next = _next;
self.dll[_prev].next = _curr;
self.dll[_next].prev = _curr;
}
function remove(Data storage self, uint _curr) public {
if (!contains(self, _curr)) {
return;
}
uint next = getNext(self, _curr);
uint prev = getPrev(self, _curr);
self.dll[next].prev = prev;
self.dll[prev].next = next;
delete self.dll[_curr];
}
}
contract EIP20Interface {
uint256 public totalSupply;
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
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 PLCRVoting {
event _VoteCommitted(uint indexed pollID, uint numTokens, address indexed voter);
event _VoteRevealed(uint indexed pollID, uint numTokens, uint votesFor, uint votesAgainst, uint indexed choice, address indexed voter, uint salt);
event _PollCreated(uint voteQuorum, uint commitEndDate, uint revealEndDate, uint indexed pollID, address indexed creator);
event _VotingRightsGranted(uint numTokens, address indexed voter);
event _VotingRightsWithdrawn(uint numTokens, address indexed voter);
event _TokensRescued(uint indexed pollID, address indexed voter);
using AttributeStore for AttributeStore.Data;
using DLL for DLL.Data;
using SafeMath for uint;
struct Poll {
uint commitEndDate;
uint revealEndDate;
uint voteQuorum;
uint votesFor;
uint votesAgainst;
mapping(address => bool) didCommit;
mapping(address => bool) didReveal;
mapping(address => uint) voteOptions;
}
uint constant public INITIAL_POLL_NONCE = 0;
uint public pollNonce;
mapping(uint => Poll) public pollMap;
mapping(address => uint) public voteTokenBalance;
mapping(address => DLL.Data) dllMap;
AttributeStore.Data store;
EIP20Interface public token;
function init(address _token) public {
require(_token != address(0) && address(token) == address(0));
token = EIP20Interface(_token);
pollNonce = INITIAL_POLL_NONCE;
}
function requestVotingRights(uint _numTokens) public {
require(token.balanceOf(msg.sender) >= _numTokens);
voteTokenBalance[msg.sender] += _numTokens;
require(token.transferFrom(msg.sender, this, _numTokens));
emit _VotingRightsGranted(_numTokens, msg.sender);
}
function withdrawVotingRights(uint _numTokens) external {
uint availableTokens = voteTokenBalance[msg.sender].sub(getLockedTokens(msg.sender));
require(availableTokens >= _numTokens);
voteTokenBalance[msg.sender] -= _numTokens;
require(token.transfer(msg.sender, _numTokens));
emit _VotingRightsWithdrawn(_numTokens, msg.sender);
}
function rescueTokens(uint _pollID) public {
require(isExpired(pollMap[_pollID].revealEndDate));
require(dllMap[msg.sender].contains(_pollID));
dllMap[msg.sender].remove(_pollID);
emit _TokensRescued(_pollID, msg.sender);
}
function rescueTokensInMultiplePolls(uint[] _pollIDs) public {
for (uint i = 0; i < _pollIDs.length; i++) {
rescueTokens(_pollIDs[i]);
}
}
function commitVote(uint _pollID, bytes32 _secretHash, uint _numTokens, uint _prevPollID) public {
require(commitPeriodActive(_pollID));
if (voteTokenBalance[msg.sender] < _numTokens) {
uint remainder = _numTokens.sub(voteTokenBalance[msg.sender]);
requestVotingRights(remainder);
}
require(voteTokenBalance[msg.sender] >= _numTokens);
require(_pollID != 0);
require(_secretHash != 0);
require(_prevPollID == 0 || dllMap[msg.sender].contains(_prevPollID));
uint nextPollID = dllMap[msg.sender].getNext(_prevPollID);
if (nextPollID == _pollID) {
nextPollID = dllMap[msg.sender].getNext(_pollID);
}
require(validPosition(_prevPollID, nextPollID, msg.sender, _numTokens));
dllMap[msg.sender].insert(_prevPollID, _pollID, nextPollID);
bytes32 UUID = attrUUID(msg.sender, _pollID);
store.setAttribute(UUID, "numTokens", _numTokens);
store.setAttribute(UUID, "commitHash", uint(_secretHash));
pollMap[_pollID].didCommit[msg.sender] = true;
emit _VoteCommitted(_pollID, _numTokens, msg.sender);
}
function commitVotes(uint[] _pollIDs, bytes32[] _secretHashes, uint[] _numsTokens, uint[] _prevPollIDs) external {
require(_pollIDs.length == _secretHashes.length);
require(_pollIDs.length == _numsTokens.length);
require(_pollIDs.length == _prevPollIDs.length);
for (uint i = 0; i < _pollIDs.length; i++) {
commitVote(_pollIDs[i], _secretHashes[i], _numsTokens[i], _prevPollIDs[i]);
}
}
function validPosition(uint _prevID, uint _nextID, address _voter, uint _numTokens) public constant returns (bool valid) {
bool prevValid = (_numTokens >= getNumTokens(_voter, _prevID));
bool nextValid = (_numTokens <= getNumTokens(_voter, _nextID) || _nextID == 0);
return prevValid && nextValid;
}
function revealVote(uint _pollID, uint _voteOption, uint _salt) public {
require(revealPeriodActive(_pollID));
require(pollMap[_pollID].didCommit[msg.sender]);
require(!pollMap[_pollID].didReveal[msg.sender]);
require(keccak256(abi.encodePacked(_voteOption, _salt)) == getCommitHash(msg.sender, _pollID));
uint numTokens = getNumTokens(msg.sender, _pollID);
if (_voteOption == 1) {
pollMap[_pollID].votesFor += numTokens;
} else {
pollMap[_pollID].votesAgainst += numTokens;
}
dllMap[msg.sender].remove(_pollID);
pollMap[_pollID].didReveal[msg.sender] = true;
pollMap[_pollID].voteOptions[msg.sender] = _voteOption;
emit _VoteRevealed(_pollID, numTokens, pollMap[_pollID].votesFor, pollMap[_pollID].votesAgainst, _voteOption, msg.sender, _salt);
}
function revealVotes(uint[] _pollIDs, uint[] _voteOptions, uint[] _salts) external {
require(_pollIDs.length == _voteOptions.length);
require(_pollIDs.length == _salts.length);
for (uint i = 0; i < _pollIDs.length; i++) {
revealVote(_pollIDs[i], _voteOptions[i], _salts[i]);
}
}
function getNumPassingTokens(address _voter, uint _pollID) public constant returns (uint correctVotes) {
require(pollEnded(_pollID));
require(pollMap[_pollID].didReveal[_voter]);
uint winningChoice = isPassed(_pollID) ? 1 : 0;
uint voterVoteOption = pollMap[_pollID].voteOptions[_voter];
require(voterVoteOption == winningChoice, "Voter revealed, but not in the majority");
return getNumTokens(_voter, _pollID);
}
function startPoll(uint _voteQuorum, uint _commitDuration, uint _revealDuration) public returns (uint pollID) {
pollNonce = pollNonce + 1;
uint commitEndDate = block.timestamp.add(_commitDuration);
uint revealEndDate = commitEndDate.add(_revealDuration);
pollMap[pollNonce] = Poll({
voteQuorum: _voteQuorum,
commitEndDate: commitEndDate,
revealEndDate: revealEndDate,
votesFor: 0,
votesAgainst: 0
});
emit _PollCreated(_voteQuorum, commitEndDate, revealEndDate, pollNonce, msg.sender);
return pollNonce;
}
function isPassed(uint _pollID) constant public returns (bool passed) {
require(pollEnded(_pollID));
Poll memory poll = pollMap[_pollID];
return (100 * poll.votesFor) > (poll.voteQuorum * (poll.votesFor + poll.votesAgainst));
}
function getTotalNumberOfTokensForWinningOption(uint _pollID) constant public returns (uint numTokens) {
require(pollEnded(_pollID));
if (isPassed(_pollID))
return pollMap[_pollID].votesFor;
else
return pollMap[_pollID].votesAgainst;
}
function pollEnded(uint _pollID) constant public returns (bool ended) {
require(pollExists(_pollID));
return isExpired(pollMap[_pollID].revealEndDate);
}
function commitPeriodActive(uint _pollID) constant public returns (bool active) {
require(pollExists(_pollID));
return !isExpired(pollMap[_pollID].commitEndDate);
}
function revealPeriodActive(uint _pollID) constant public returns (bool active) {
require(pollExists(_pollID));
return !isExpired(pollMap[_pollID].revealEndDate) && !commitPeriodActive(_pollID);
}
function didCommit(address _voter, uint _pollID) constant public returns (bool committed) {
require(pollExists(_pollID));
return pollMap[_pollID].didCommit[_voter];
}
function didReveal(address _voter, uint _pollID) constant public returns (bool revealed) {
require(pollExists(_pollID));
return pollMap[_pollID].didReveal[_voter];
}
function pollExists(uint _pollID) constant public returns (bool exists) {
return (_pollID != 0 && _pollID <= pollNonce);
}
function getCommitHash(address _voter, uint _pollID) constant public returns (bytes32 commitHash) {
return bytes32(store.getAttribute(attrUUID(_voter, _pollID), "commitHash"));
}
function getNumTokens(address _voter, uint _pollID) constant public returns (uint numTokens) {
return store.getAttribute(attrUUID(_voter, _pollID), "numTokens");
}
function getLastNode(address _voter) constant public returns (uint pollID) {
return dllMap[_voter].getPrev(0);
}
function getLockedTokens(address _voter) constant public returns (uint numTokens) {
return getNumTokens(_voter, getLastNode(_voter));
}
function getInsertPointForNumTokens(address _voter, uint _numTokens, uint _pollID)
constant public returns (uint prevNode) {
uint nodeID = getLastNode(_voter);
uint tokensInNode = getNumTokens(_voter, nodeID);
while(nodeID != 0) {
tokensInNode = getNumTokens(_voter, nodeID);
if(tokensInNode <= _numTokens) {
if(nodeID == _pollID) {
nodeID = dllMap[_voter].getPrev(nodeID);
}
return nodeID;
}
nodeID = dllMap[_voter].getPrev(nodeID);
}
return nodeID;
}
function isExpired(uint _terminationDate) constant public returns (bool expired) {
return (block.timestamp > _terminationDate);
}
function attrUUID(address _user, uint _pollID) public pure returns (bytes32 UUID) {
return keccak256(abi.encodePacked(_user, _pollID));
}
}
contract Parameterizer {
event _ReparameterizationProposal(string name, uint value, bytes32 propID, uint deposit, uint appEndDate, address indexed proposer);
event _NewChallenge(bytes32 indexed propID, uint challengeID, uint commitEndDate, uint revealEndDate, address indexed challenger);
event _ProposalAccepted(bytes32 indexed propID, string name, uint value);
event _ProposalExpired(bytes32 indexed propID);
event _ChallengeSucceeded(bytes32 indexed propID, uint indexed challengeID, uint rewardPool, uint totalTokens);
event _ChallengeFailed(bytes32 indexed propID, uint indexed challengeID, uint rewardPool, uint totalTokens);
event _RewardClaimed(uint indexed challengeID, uint reward, address indexed voter);
using SafeMath for uint;
struct ParamProposal {
uint appExpiry;
uint challengeID;
uint deposit;
string name;
address owner;
uint processBy;
uint value;
}
struct Challenge {
uint rewardPool;
address challenger;
bool resolved;
uint stake;
uint winningTokens;
mapping(address => bool) tokenClaims;
}
mapping(bytes32 => uint) public params;
mapping(uint => Challenge) public challenges;
mapping(bytes32 => ParamProposal) public proposals;
EIP20Interface public token;
PLCRVoting public voting;
uint public PROCESSBY = 604800;
function init(
address _token,
address _plcr,
uint[] _parameters
) public {
require(_token != 0 && address(token) == 0);
require(_plcr != 0 && address(voting) == 0);
token = EIP20Interface(_token);
voting = PLCRVoting(_plcr);
set("minDeposit", _parameters[0]);
set("pMinDeposit", _parameters[1]);
set("applyStageLen", _parameters[2]);
set("pApplyStageLen", _parameters[3]);
set("commitStageLen", _parameters[4]);
set("pCommitStageLen", _parameters[5]);
set("revealStageLen", _parameters[6]);
set("pRevealStageLen", _parameters[7]);
set("dispensationPct", _parameters[8]);
set("pDispensationPct", _parameters[9]);
set("voteQuorum", _parameters[10]);
set("pVoteQuorum", _parameters[11]);
set("exitTimeDelay", _parameters[12]);
set("exitPeriodLen", _parameters[13]);
}
function proposeReparameterization(string _name, uint _value) public returns (bytes32) {
uint deposit = get("pMinDeposit");
bytes32 propID = keccak256(abi.encodePacked(_name, _value));
if (keccak256(abi.encodePacked(_name)) == keccak256(abi.encodePacked("dispensationPct")) ||
keccak256(abi.encodePacked(_name)) == keccak256(abi.encodePacked("pDispensationPct"))) {
require(_value <= 100);
}
require(!propExists(propID));
require(get(_name) != _value);
proposals[propID] = ParamProposal({
appExpiry: now.add(get("pApplyStageLen")),
challengeID: 0,
deposit: deposit,
name: _name,
owner: msg.sender,
processBy: now.add(get("pApplyStageLen"))
.add(get("pCommitStageLen"))
.add(get("pRevealStageLen"))
.add(PROCESSBY),
value: _value
});
require(token.transferFrom(msg.sender, this, deposit));
emit _ReparameterizationProposal(_name, _value, propID, deposit, proposals[propID].appExpiry, msg.sender);
return propID;
}
function challengeReparameterization(bytes32 _propID) public returns (uint challengeID) {
ParamProposal memory prop = proposals[_propID];
uint deposit = prop.deposit;
require(propExists(_propID) && prop.challengeID == 0);
uint pollID = voting.startPoll(
get("pVoteQuorum"),
get("pCommitStageLen"),
get("pRevealStageLen")
);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: SafeMath.sub(100, get("pDispensationPct")).mul(deposit).div(100),
stake: deposit,
resolved: false,
winningTokens: 0
});
proposals[_propID].challengeID = pollID;
require(token.transferFrom(msg.sender, this, deposit));
(uint commitEndDate, uint revealEndDate,,,) = voting.pollMap(pollID);
emit _NewChallenge(_propID, pollID, commitEndDate, revealEndDate, msg.sender);
return pollID;
}
function processProposal(bytes32 _propID) public {
ParamProposal storage prop = proposals[_propID];
address propOwner = prop.owner;
uint propDeposit = prop.deposit;
if (canBeSet(_propID)) {
set(prop.name, prop.value);
emit _ProposalAccepted(_propID, prop.name, prop.value);
delete proposals[_propID];
require(token.transfer(propOwner, propDeposit));
} else if (challengeCanBeResolved(_propID)) {
resolveChallenge(_propID);
} else if (now > prop.processBy) {
emit _ProposalExpired(_propID);
delete proposals[_propID];
require(token.transfer(propOwner, propDeposit));
} else {
revert();
}
assert(get("dispensationPct") <= 100);
assert(get("pDispensationPct") <= 100);
now.add(get("pApplyStageLen"))
.add(get("pCommitStageLen"))
.add(get("pRevealStageLen"))
.add(PROCESSBY);
delete proposals[_propID];
}
function claimReward(uint _challengeID) public {
Challenge storage challenge = challenges[_challengeID];
require(challenge.tokenClaims[msg.sender] == false);
require(challenge.resolved == true);
uint voterTokens = voting.getNumPassingTokens(msg.sender, _challengeID);
uint reward = voterReward(msg.sender, _challengeID);
challenge.winningTokens -= voterTokens;
challenge.rewardPool -= reward;
challenge.tokenClaims[msg.sender] = true;
emit _RewardClaimed(_challengeID, reward, msg.sender);
require(token.transfer(msg.sender, reward));
}
function claimRewards(uint[] _challengeIDs) public {
for (uint i = 0; i < _challengeIDs.length; i++) {
claimReward(_challengeIDs[i]);
}
}
function voterReward(address _voter, uint _challengeID)
public view returns (uint) {
uint winningTokens = challenges[_challengeID].winningTokens;
uint rewardPool = challenges[_challengeID].rewardPool;
uint voterTokens = voting.getNumPassingTokens(_voter, _challengeID);
return (voterTokens * rewardPool) / winningTokens;
}
function canBeSet(bytes32 _propID) view public returns (bool) {
ParamProposal memory prop = proposals[_propID];
return (now > prop.appExpiry && now < prop.processBy && prop.challengeID == 0);
}
function propExists(bytes32 _propID) view public returns (bool) {
return proposals[_propID].processBy > 0;
}
function challengeCanBeResolved(bytes32 _propID) view public returns (bool) {
ParamProposal memory prop = proposals[_propID];
Challenge memory challenge = challenges[prop.challengeID];
return (prop.challengeID > 0 && challenge.resolved == false && voting.pollEnded(prop.challengeID));
}
function challengeWinnerReward(uint _challengeID) public view returns (uint) {
if(voting.getTotalNumberOfTokensForWinningOption(_challengeID) == 0) {
return 2 * challenges[_challengeID].stake;
}
return (2 * challenges[_challengeID].stake) - challenges[_challengeID].rewardPool;
}
function get(string _name) public view returns (uint value) {
return params[keccak256(abi.encodePacked(_name))];
}
function tokenClaims(uint _challengeID, address _voter) public view returns (bool) {
return challenges[_challengeID].tokenClaims[_voter];
}
function resolveChallenge(bytes32 _propID) private {
ParamProposal memory prop = proposals[_propID];
Challenge storage challenge = challenges[prop.challengeID];
uint reward = challengeWinnerReward(prop.challengeID);
challenge.winningTokens = voting.getTotalNumberOfTokensForWinningOption(prop.challengeID);
challenge.resolved = true;
if (voting.isPassed(prop.challengeID)) {
if(prop.processBy > now) {
set(prop.name, prop.value);
}
emit _ChallengeFailed(_propID, prop.challengeID, challenge.rewardPool, challenge.winningTokens);
require(token.transfer(prop.owner, reward));
}
else {
emit _ChallengeSucceeded(_propID, prop.challengeID, challenge.rewardPool, challenge.winningTokens);
require(token.transfer(challenges[prop.challengeID].challenger, reward));
}
}
function set(string _name, uint _value) private {
params[keccak256(abi.encodePacked(_name))] = _value;
}
} | 0 | 1,249 |
pragma solidity ^0.4.20;
interface ERC165 {
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
contract ERC721 is ERC165 {
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface ERC721TokenReceiver {
function onERC721Received(address _from, uint256 _tokenId, bytes data) external returns(bytes4);
}
contract AccessAdmin {
bool public isPaused = false;
address public addrAdmin;
event AdminTransferred(address indexed preAdmin, address indexed newAdmin);
function AccessAdmin() public {
addrAdmin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == addrAdmin);
_;
}
modifier whenNotPaused() {
require(!isPaused);
_;
}
modifier whenPaused {
require(isPaused);
_;
}
function setAdmin(address _newAdmin) external onlyAdmin {
require(_newAdmin != address(0));
AdminTransferred(addrAdmin, _newAdmin);
addrAdmin = _newAdmin;
}
function doPause() external onlyAdmin whenNotPaused {
isPaused = true;
}
function doUnpause() external onlyAdmin whenPaused {
isPaused = false;
}
}
contract AccessNoWithdraw is AccessAdmin {
address public addrService;
address public addrFinance;
modifier onlyService() {
require(msg.sender == addrService);
_;
}
modifier onlyFinance() {
require(msg.sender == addrFinance);
_;
}
modifier onlyManager() {
require(msg.sender == addrService || msg.sender == addrAdmin || msg.sender == addrFinance);
_;
}
function setService(address _newService) external {
require(msg.sender == addrService || msg.sender == addrAdmin);
require(_newService != address(0));
addrService = _newService;
}
function setFinance(address _newFinance) external {
require(msg.sender == addrFinance || msg.sender == addrAdmin);
require(_newFinance != address(0));
addrFinance = _newFinance;
}
}
interface IDataMining {
function getRecommender(address _target) external view returns(address);
function subFreeMineral(address _target) external returns(bool);
}
interface IDataEquip {
function isEquiped(address _target, uint256 _tokenId) external view returns(bool);
function isEquipedAny2(address _target, uint256 _tokenId1, uint256 _tokenId2) external view returns(bool);
function isEquipedAny3(address _target, uint256 _tokenId1, uint256 _tokenId2, uint256 _tokenId3) external view returns(bool);
}
interface IDataAuction {
function isOnSale(uint256 _tokenId) external view returns(bool);
function isOnSaleAny2(uint256 _tokenId1, uint256 _tokenId2) external view returns(bool);
function isOnSaleAny3(uint256 _tokenId1, uint256 _tokenId2, uint256 _tokenId3) external view returns(bool);
}
interface IEOMarketToken {
function transfer(address _to, uint256 _value) external;
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value) external;
function approveAndCall(address _spender, uint256 _value, bytes _extraData) external returns (bool);
function balanceOf(address _from) external view returns(uint256);
function totalSupply() external view returns(uint256);
function totalSold() external view returns(uint256);
function getShareholders() external view returns(address[100] addrArray, uint256[100] amountArray, uint256 soldAmount);
}
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 WarToken is ERC721, AccessAdmin {
struct Fashion {
uint16 protoId;
uint16 quality;
uint16 pos;
uint16 health;
uint16 atkMin;
uint16 atkMax;
uint16 defence;
uint16 crit;
uint16 isPercent;
uint16 attrExt1;
uint16 attrExt2;
uint16 attrExt3;
}
Fashion[] public fashionArray;
uint256 destroyFashionCount;
mapping (uint256 => address) fashionIdToOwner;
mapping (address => uint256[]) ownerToFashionArray;
mapping (uint256 => uint256) fashionIdToOwnerIndex;
mapping (uint256 => address) fashionIdToApprovals;
mapping (address => mapping (address => bool)) operatorToApprovals;
mapping (address => bool) actionContracts;
function setActionContract(address _actionAddr, bool _useful) external onlyAdmin {
actionContracts[_actionAddr] = _useful;
}
function getActionContract(address _actionAddr) external view onlyAdmin returns(bool) {
return actionContracts[_actionAddr];
}
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event CreateFashion(address indexed owner, uint256 tokenId, uint16 protoId, uint16 quality, uint16 pos, uint16 createType);
event ChangeFashion(address indexed owner, uint256 tokenId, uint16 changeType);
event DeleteFashion(address indexed owner, uint256 tokenId, uint16 deleteType);
function WarToken() public {
addrAdmin = msg.sender;
fashionArray.length += 1;
}
modifier isValidToken(uint256 _tokenId) {
require(_tokenId >= 1 && _tokenId <= fashionArray.length);
require(fashionIdToOwner[_tokenId] != address(0));
_;
}
modifier canTransfer(uint256 _tokenId) {
address owner = fashionIdToOwner[_tokenId];
require(msg.sender == owner || msg.sender == fashionIdToApprovals[_tokenId] || operatorToApprovals[owner][msg.sender]);
_;
}
function supportsInterface(bytes4 _interfaceId) external view returns(bool) {
return (_interfaceId == 0x01ffc9a7 || _interfaceId == 0x80ac58cd || _interfaceId == 0x8153916a) && (_interfaceId != 0xffffffff);
}
function name() public pure returns(string) {
return "WAR Token";
}
function symbol() public pure returns(string) {
return "WAR";
}
function balanceOf(address _owner) external view returns(uint256) {
require(_owner != address(0));
return ownerToFashionArray[_owner].length;
}
function ownerOf(uint256 _tokenId) external view returns (address owner) {
return fashionIdToOwner[_tokenId];
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data)
external
whenNotPaused
{
_safeTransferFrom(_from, _to, _tokenId, data);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
external
whenNotPaused
{
_safeTransferFrom(_from, _to, _tokenId, "");
}
function transferFrom(address _from, address _to, uint256 _tokenId)
external
whenNotPaused
isValidToken(_tokenId)
canTransfer(_tokenId)
{
address owner = fashionIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner == _from);
_transfer(_from, _to, _tokenId);
}
function approve(address _approved, uint256 _tokenId)
external
whenNotPaused
{
address owner = fashionIdToOwner[_tokenId];
require(owner != address(0));
require(msg.sender == owner || operatorToApprovals[owner][msg.sender]);
fashionIdToApprovals[_tokenId] = _approved;
Approval(owner, _approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved)
external
whenNotPaused
{
operatorToApprovals[msg.sender][_operator] = _approved;
ApprovalForAll(msg.sender, _operator, _approved);
}
function getApproved(uint256 _tokenId) external view isValidToken(_tokenId) returns (address) {
return fashionIdToApprovals[_tokenId];
}
function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
return operatorToApprovals[_owner][_operator];
}
function totalSupply() external view returns (uint256) {
return fashionArray.length - destroyFashionCount - 1;
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
if (_from != address(0)) {
uint256 indexFrom = fashionIdToOwnerIndex[_tokenId];
uint256[] storage fsArray = ownerToFashionArray[_from];
require(fsArray[indexFrom] == _tokenId);
if (indexFrom != fsArray.length - 1) {
uint256 lastTokenId = fsArray[fsArray.length - 1];
fsArray[indexFrom] = lastTokenId;
fashionIdToOwnerIndex[lastTokenId] = indexFrom;
}
fsArray.length -= 1;
if (fashionIdToApprovals[_tokenId] != address(0)) {
delete fashionIdToApprovals[_tokenId];
}
}
fashionIdToOwner[_tokenId] = _to;
ownerToFashionArray[_to].push(_tokenId);
fashionIdToOwnerIndex[_tokenId] = ownerToFashionArray[_to].length - 1;
Transfer(_from != address(0) ? _from : this, _to, _tokenId);
}
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data)
internal
isValidToken(_tokenId)
canTransfer(_tokenId)
{
address owner = fashionIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner == _from);
_transfer(_from, _to, _tokenId);
uint256 codeSize;
assembly { codeSize := extcodesize(_to) }
if (codeSize == 0) {
return;
}
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(_from, _tokenId, data);
require(retval == 0xf0b9e5ba);
}
function createFashion(address _owner, uint16[9] _attrs, uint16 _createType)
external
whenNotPaused
returns(uint256)
{
require(actionContracts[msg.sender]);
require(_owner != address(0));
uint256 newFashionId = fashionArray.length;
require(newFashionId < 4294967296);
fashionArray.length += 1;
Fashion storage fs = fashionArray[newFashionId];
fs.protoId = _attrs[0];
fs.quality = _attrs[1];
fs.pos = _attrs[2];
if (_attrs[3] != 0) {
fs.health = _attrs[3];
}
if (_attrs[4] != 0) {
fs.atkMin = _attrs[4];
fs.atkMax = _attrs[5];
}
if (_attrs[6] != 0) {
fs.defence = _attrs[6];
}
if (_attrs[7] != 0) {
fs.crit = _attrs[7];
}
if (_attrs[8] != 0) {
fs.isPercent = _attrs[8];
}
_transfer(0, _owner, newFashionId);
CreateFashion(_owner, newFashionId, _attrs[0], _attrs[1], _attrs[2], _createType);
return newFashionId;
}
function _changeAttrByIndex(Fashion storage _fs, uint16 _index, uint16 _val) internal {
if (_index == 3) {
_fs.health = _val;
} else if(_index == 4) {
_fs.atkMin = _val;
} else if(_index == 5) {
_fs.atkMax = _val;
} else if(_index == 6) {
_fs.defence = _val;
} else if(_index == 7) {
_fs.crit = _val;
} else if(_index == 9) {
_fs.attrExt1 = _val;
} else if(_index == 10) {
_fs.attrExt2 = _val;
} else if(_index == 11) {
_fs.attrExt3 = _val;
}
}
function changeFashionAttr(uint256 _tokenId, uint16[4] _idxArray, uint16[4] _params, uint16 _changeType)
external
whenNotPaused
isValidToken(_tokenId)
{
require(actionContracts[msg.sender]);
Fashion storage fs = fashionArray[_tokenId];
if (_idxArray[0] > 0) {
_changeAttrByIndex(fs, _idxArray[0], _params[0]);
}
if (_idxArray[1] > 0) {
_changeAttrByIndex(fs, _idxArray[1], _params[1]);
}
if (_idxArray[2] > 0) {
_changeAttrByIndex(fs, _idxArray[2], _params[2]);
}
if (_idxArray[3] > 0) {
_changeAttrByIndex(fs, _idxArray[3], _params[3]);
}
ChangeFashion(fashionIdToOwner[_tokenId], _tokenId, _changeType);
}
function destroyFashion(uint256 _tokenId, uint16 _deleteType)
external
whenNotPaused
isValidToken(_tokenId)
{
require(actionContracts[msg.sender]);
address _from = fashionIdToOwner[_tokenId];
uint256 indexFrom = fashionIdToOwnerIndex[_tokenId];
uint256[] storage fsArray = ownerToFashionArray[_from];
require(fsArray[indexFrom] == _tokenId);
if (indexFrom != fsArray.length - 1) {
uint256 lastTokenId = fsArray[fsArray.length - 1];
fsArray[indexFrom] = lastTokenId;
fashionIdToOwnerIndex[lastTokenId] = indexFrom;
}
fsArray.length -= 1;
fashionIdToOwner[_tokenId] = address(0);
delete fashionIdToOwnerIndex[_tokenId];
destroyFashionCount += 1;
Transfer(_from, 0, _tokenId);
DeleteFashion(_from, _tokenId, _deleteType);
}
function safeTransferByContract(uint256 _tokenId, address _to)
external
whenNotPaused
{
require(actionContracts[msg.sender]);
require(_tokenId >= 1 && _tokenId <= fashionArray.length);
address owner = fashionIdToOwner[_tokenId];
require(owner != address(0));
require(_to != address(0));
require(owner != _to);
_transfer(owner, _to, _tokenId);
}
function getFashion(uint256 _tokenId) external view isValidToken(_tokenId) returns (uint16[12] datas) {
Fashion storage fs = fashionArray[_tokenId];
datas[0] = fs.protoId;
datas[1] = fs.quality;
datas[2] = fs.pos;
datas[3] = fs.health;
datas[4] = fs.atkMin;
datas[5] = fs.atkMax;
datas[6] = fs.defence;
datas[7] = fs.crit;
datas[8] = fs.isPercent;
datas[9] = fs.attrExt1;
datas[10] = fs.attrExt2;
datas[11] = fs.attrExt3;
}
function getOwnFashions(address _owner) external view returns(uint256[] tokens, uint32[] flags) {
require(_owner != address(0));
uint256[] storage fsArray = ownerToFashionArray[_owner];
uint256 length = fsArray.length;
tokens = new uint256[](length);
flags = new uint32[](length);
for (uint256 i = 0; i < length; ++i) {
tokens[i] = fsArray[i];
Fashion storage fs = fashionArray[fsArray[i]];
flags[i] = uint32(uint32(fs.protoId) * 100 + uint32(fs.quality) * 10 + fs.pos);
}
}
function getFashionsAttrs(uint256[] _tokens) external view returns(uint16[] attrs) {
uint256 length = _tokens.length;
require(length <= 64);
attrs = new uint16[](length * 11);
uint256 tokenId;
uint256 index;
for (uint256 i = 0; i < length; ++i) {
tokenId = _tokens[i];
if (fashionIdToOwner[tokenId] != address(0)) {
index = i * 11;
Fashion storage fs = fashionArray[tokenId];
attrs[index] = fs.health;
attrs[index + 1] = fs.atkMin;
attrs[index + 2] = fs.atkMax;
attrs[index + 3] = fs.defence;
attrs[index + 4] = fs.crit;
attrs[index + 5] = fs.isPercent;
attrs[index + 6] = fs.attrExt1;
attrs[index + 7] = fs.attrExt2;
attrs[index + 8] = fs.attrExt3;
}
}
}
}
contract ActionAuction is AccessNoWithdraw {
using SafeMath for uint256;
event AuctionCreate(uint256 indexed index, address indexed seller, uint256 tokenId);
event AuctionSold(uint256 indexed index, address indexed seller, address indexed buyer, uint256 tokenId, uint256 price);
event AuctionCancel(uint256 indexed index, address indexed seller, uint256 tokenId);
event AuctionPriceChange(uint256 indexed index, address indexed seller, uint256 tokenId, uint64 newGwei);
struct Auction {
address seller;
uint64 tokenId;
uint64 price;
uint64 tmStart;
uint64 tmSell;
}
Auction[] public auctionArray;
mapping(uint256 => uint256) public latestAction;
WarToken public tokenContract;
IDataEquip public equipContract;
IEOMarketToken public eostContract;
IDataAuction public platAuction;
address public poolContract;
mapping(address => uint256) public shareBalances;
mapping(address => uint256) public shareHistory;
uint256 public accumulateFee;
uint64 public searchStartIndex;
uint64 public auctionDuration = 172800;
uint64 public auctionSumGwei;
function ActionAuction(address _nftAddr) public {
addrAdmin = msg.sender;
addrService = msg.sender;
addrFinance = msg.sender;
tokenContract = WarToken(_nftAddr);
Auction memory order = Auction(0, 0, 0, 1, 1);
auctionArray.push(order);
}
function() external {}
function setDataEquip(address _addr) external onlyAdmin {
require(_addr != address(0));
equipContract = IDataEquip(_addr);
}
function setEOMarketToken(address _addr) external onlyAdmin {
require(_addr != address(0));
eostContract = IEOMarketToken(_addr);
}
function setPlatAuction(address _addr) external onlyAdmin {
require(_addr != address(0));
platAuction = IDataAuction(_addr);
}
function setPrizePool(address _addr) external onlyAdmin {
require(_addr != address(0));
poolContract = _addr;
}
function setDuration(uint64 _duration) external onlyAdmin {
require(_duration >= 300 && _duration <= 8640000);
auctionDuration = _duration;
}
function newAuction(uint256 _tokenId, uint64 _priceGwei)
external
whenNotPaused
{
require(tokenContract.ownerOf(_tokenId) == msg.sender);
require(!equipContract.isEquiped(msg.sender, _tokenId));
require(_priceGwei >= 1000000 && _priceGwei <= 999000000000);
uint16[12] memory fashion = tokenContract.getFashion(_tokenId);
require(fashion[1] > 1);
uint64 tmNow = uint64(block.timestamp);
uint256 lastIndex = latestAction[_tokenId];
if (lastIndex > 0) {
Auction storage oldOrder = auctionArray[lastIndex];
require((oldOrder.tmStart + auctionDuration) <= tmNow || oldOrder.tmSell > 0);
}
if (address(platAuction) != address(0)) {
require(!platAuction.isOnSale(_tokenId));
}
uint256 newAuctionIndex = auctionArray.length;
auctionArray.length += 1;
Auction storage order = auctionArray[newAuctionIndex];
order.seller = msg.sender;
order.tokenId = uint64(_tokenId);
order.price = _priceGwei;
uint64 lastActionStart = auctionArray[newAuctionIndex - 1].tmStart;
if (tmNow >= lastActionStart) {
order.tmStart = tmNow;
} else {
order.tmStart = lastActionStart;
}
latestAction[_tokenId] = newAuctionIndex;
AuctionCreate(newAuctionIndex, msg.sender, _tokenId);
}
function cancelAuction(uint256 _tokenId) external whenNotPaused {
require(tokenContract.ownerOf(_tokenId) == msg.sender);
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
require(order.seller == msg.sender);
require(order.tmSell == 0);
order.tmSell = 1;
AuctionCancel(lastIndex, msg.sender, _tokenId);
}
function changePrice(uint256 _tokenId, uint64 _priceGwei) external whenNotPaused {
require(tokenContract.ownerOf(_tokenId) == msg.sender);
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
require(order.seller == msg.sender);
require(order.tmSell == 0);
uint64 tmNow = uint64(block.timestamp);
require(order.tmStart + auctionDuration > tmNow);
require(_priceGwei >= 1000000 && _priceGwei <= 999000000000);
order.price = _priceGwei;
AuctionPriceChange(lastIndex, msg.sender, _tokenId, _priceGwei);
}
function _shareDevCut(uint256 val) internal {
uint256 shareVal = val.mul(6).div(10);
uint256 leftVal = val.sub(shareVal);
uint256 devVal = leftVal.div(2);
accumulateFee = accumulateFee.add(shareVal);
addrFinance.transfer(devVal);
if (poolContract != address(0)) {
poolContract.transfer(leftVal.sub(devVal));
} else {
accumulateFee = accumulateFee.add(leftVal.sub(devVal));
}
}
function bid(uint256 _tokenId)
external
payable
whenNotPaused
{
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
uint64 tmNow = uint64(block.timestamp);
require(order.tmStart + auctionDuration > tmNow);
require(order.tmSell == 0);
address realOwner = tokenContract.ownerOf(_tokenId);
require(realOwner == order.seller);
require(realOwner != msg.sender);
uint256 price = order.price * 1000000000;
require(msg.value == price);
order.tmSell = tmNow;
auctionSumGwei += order.price;
uint256 sellerProceeds = price.mul(9).div(10);
uint256 devCut = price.sub(sellerProceeds);
tokenContract.safeTransferByContract(_tokenId, msg.sender);
_shareDevCut(devCut);
realOwner.transfer(sellerProceeds);
AuctionSold(lastIndex, realOwner, msg.sender, _tokenId, price);
}
function updateShares()
external
{
uint256 currentFee = accumulateFee;
var (addrArray, amountArray, soldAmount) = eostContract.getShareholders();
require(soldAmount > 0);
uint256 avg = currentFee.div(soldAmount);
uint256 shareVal;
address addrZero = address(0);
address addrHolder;
for (uint64 i = 0; i < 100; ++i) {
addrHolder = addrArray[i];
if (addrHolder == addrZero) {
break;
}
shareVal = avg.mul(amountArray[i]);
uint256 oldBalance = shareBalances[addrHolder];
shareBalances[addrHolder] = oldBalance.add(shareVal);
currentFee = currentFee.sub(shareVal);
}
assert(currentFee <= 100);
accumulateFee = currentFee;
}
function shareWithdraw() external {
address holder = msg.sender;
uint256 sBalance = shareBalances[holder];
require (sBalance > 0);
assert (sBalance <= this.balance);
shareBalances[holder] = 0;
shareHistory[holder] += sBalance;
holder.transfer(sBalance);
}
function depositBonus ()
external
payable
{
require (msg.value > 0);
accumulateFee.add(msg.value);
}
function _getStartIndex(uint64 startIndex) internal view returns(uint64) {
uint64 tmFind = uint64(block.timestamp) - auctionDuration;
uint64 first = startIndex;
uint64 middle;
uint64 half;
uint64 len = uint64(auctionArray.length - startIndex);
while(len > 0) {
half = len / 2;
middle = first + half;
if (auctionArray[middle].tmStart < tmFind) {
first = middle + 1;
len = len - half - 1;
} else {
len = half;
}
}
return first;
}
function resetSearchStartIndex () internal {
searchStartIndex = _getStartIndex(searchStartIndex);
}
function _getAuctionIdArray(uint64 _startIndex, uint64 _count)
internal
view
returns(uint64[])
{
uint64 tmFind = uint64(block.timestamp) - auctionDuration;
uint64 start = _startIndex > 0 ? _startIndex : _getStartIndex(0);
uint256 length = auctionArray.length;
uint256 maxLen = _count > 0 ? _count : length - start;
if (maxLen == 0) {
maxLen = 1;
}
uint64[] memory auctionIdArray = new uint64[](maxLen);
uint64 counter = 0;
for (uint64 i = start; i < length; ++i) {
if (auctionArray[i].tmStart > tmFind && auctionArray[i].tmSell == 0) {
auctionIdArray[counter++] = i;
if (_count > 0 && counter == _count) {
break;
}
}
}
if (counter == auctionIdArray.length) {
return auctionIdArray;
} else {
uint64[] memory realIdArray = new uint64[](counter);
for (uint256 j = 0; j < counter; ++j) {
realIdArray[j] = auctionIdArray[j];
}
return realIdArray;
}
}
function getAuctionIdArray(uint64 _startIndex, uint64 _count) external view returns(uint64[]) {
return _getAuctionIdArray(_startIndex, _count);
}
function getAuctionArray(uint64 _startIndex, uint64 _count)
external
view
returns(
uint64[] auctionIdArray,
address[] sellerArray,
uint64[] tokenIdArray,
uint64[] priceArray,
uint64[] tmStartArray)
{
auctionIdArray = _getAuctionIdArray(_startIndex, _count);
uint256 length = auctionIdArray.length;
sellerArray = new address[](length);
tokenIdArray = new uint64[](length);
priceArray = new uint64[](length);
tmStartArray = new uint64[](length);
for (uint256 i = 0; i < length; ++i) {
Auction storage tmpAuction = auctionArray[auctionIdArray[i]];
sellerArray[i] = tmpAuction.seller;
tokenIdArray[i] = tmpAuction.tokenId;
priceArray[i] = tmpAuction.price;
tmStartArray[i] = tmpAuction.tmStart;
}
}
function getAuction(uint64 auctionId) external view returns(
address seller,
uint64 tokenId,
uint64 price,
uint64 tmStart,
uint64 tmSell)
{
require (auctionId < auctionArray.length);
Auction memory auction = auctionArray[auctionId];
seller = auction.seller;
tokenId = auction.tokenId;
price = auction.price;
tmStart = auction.tmStart;
tmSell = auction.tmSell;
}
function getAuctionTotal() external view returns(uint256) {
return auctionArray.length - 1;
}
function getStartIndex(uint64 _startIndex) external view returns(uint256) {
require (_startIndex < auctionArray.length);
return _getStartIndex(_startIndex);
}
function isOnSale(uint256 _tokenId) external view returns(bool) {
uint256 lastIndex = latestAction[_tokenId];
if (lastIndex > 0) {
Auction storage order = auctionArray[lastIndex];
uint64 tmNow = uint64(block.timestamp);
if ((order.tmStart + auctionDuration > tmNow) && order.tmSell == 0) {
return true;
}
}
return false;
}
function isOnSaleAny2(uint256 _tokenId1, uint256 _tokenId2) external view returns(bool) {
uint256 lastIndex = latestAction[_tokenId1];
uint64 tmNow = uint64(block.timestamp);
if (lastIndex > 0) {
Auction storage order1 = auctionArray[lastIndex];
if ((order1.tmStart + auctionDuration > tmNow) && order1.tmSell == 0) {
return true;
}
}
lastIndex = latestAction[_tokenId2];
if (lastIndex > 0) {
Auction storage order2 = auctionArray[lastIndex];
if ((order2.tmStart + auctionDuration > tmNow) && order2.tmSell == 0) {
return true;
}
}
return false;
}
function isOnSaleAny3(uint256 _tokenId1, uint256 _tokenId2, uint256 _tokenId3) external view returns(bool) {
uint256 lastIndex = latestAction[_tokenId1];
uint64 tmNow = uint64(block.timestamp);
if (lastIndex > 0) {
Auction storage order1 = auctionArray[lastIndex];
if ((order1.tmStart + auctionDuration > tmNow) && order1.tmSell == 0) {
return true;
}
}
lastIndex = latestAction[_tokenId2];
if (lastIndex > 0) {
Auction storage order2 = auctionArray[lastIndex];
if ((order2.tmStart + auctionDuration > tmNow) && order2.tmSell == 0) {
return true;
}
}
lastIndex = latestAction[_tokenId3];
if (lastIndex > 0) {
Auction storage order3 = auctionArray[lastIndex];
if ((order3.tmStart + auctionDuration > tmNow) && order3.tmSell == 0) {
return true;
}
}
return false;
}
} | 0 | 482 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "Mapping Aggregation Platform";
string public constant TOKEN_SYMBOL = "MPLT";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0xd32Ca1815A347589E922c3A58d42c8f4F8A9770b;
uint public constant START_TIME = 1538847900;
bool public constant CONTINUE_MINTING = true;
}
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
contract MainCrowdsale is Consts, FinalizableCrowdsale, MintedCrowdsale, CappedCrowdsale {
function hasStarted() public view returns (bool) {
return now >= openingTime;
}
function startTime() public view returns (uint256) {
return openingTime;
}
function endTime() public view returns (uint256) {
return closingTime;
}
function hasClosed() public view returns (bool) {
return super.hasClosed() || capReached();
}
function hasEnded() public view returns (bool) {
return hasClosed();
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
require(MintableToken(token).finishMinting());
}
Ownable(token).transferOwnership(TARGET_USER);
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate).div(1 ether);
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 bonusRate = getBonusRate(_weiAmount);
return _weiAmount.mul(bonusRate).div(1 ether);
}
function getBonusRate(uint256 _weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[1] memory weiRaisedStartsBounds = [uint(0)];
uint[1] memory weiRaisedEndsBounds = [uint(6000000000000000000000)];
uint64[1] memory timeStartsBounds = [uint64(1538847960)];
uint64[1] memory timeEndsBounds = [uint64(1540443595)];
uint[1] memory weiRaisedAndTimeRates = [uint(300)];
for (uint i = 0; i < 1; i++) {
bool weiRaisedInBound = (weiRaisedStartsBounds[i] <= weiRaised) && (weiRaised < weiRaisedEndsBounds[i]);
bool timeInBound = (timeStartsBounds[i] <= now) && (now < timeEndsBounds[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
{
event Initialized();
event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime);
bool public initialized = false;
constructor(MintableToken _token) public
Crowdsale(1000 * TOKEN_DECIMAL_MULTIPLIER, 0xE140E24981573185A855087eC1F1C25B84C9f72d, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1540443600)
CappedCrowdsale(6000000000000000000000)
{
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[2] memory addresses = [address(0xaaa82e8eb37a78e29bc9b91d2e292968c1ac4d32),address(0x67d0feb8276c91d3fcada42f59113d9dd009b216)];
uint[2] memory amounts = [uint(100000000000000000000000),uint(900000000000000000000000)];
uint64[2] memory freezes = [uint64(0),uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
emit Initialized();
}
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 500000000000000000;
return super.hasClosed() || remainValue;
}
function setEndTime(uint _endTime) public onlyOwner {
require(now < closingTime);
require(now < _endTime);
require(_endTime > openingTime);
emit TimesChanged(openingTime, _endTime, openingTime, closingTime);
closingTime = _endTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= 500000000000000000);
require(msg.value <= 6000000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 0 | 1,584 |
contract Gamble {
address owner;
Bet[] bets;
address[] winners;
struct Bet {
address sender;
int8 range;
}
function Gamble() {
owner = msg.sender;
}
function place (int8 range) public payable {
if (msg.value >= 50 finney && range <= 100) {
bets[bets.length++] = Bet({sender: msg.sender, range: range});
}
}
function solve (int8 range) public {
if (msg.sender == owner && range <= 100) {
for (uint i = 0; i < bets.length; ++i) {
if (bets[i].range == range) {
winners[winners.length++] = bets[i].sender;
}
}
for (uint j = 0; j < winners.length; ++j) {
winners[j].send(winners.length / this.balance);
}
selfdestruct(owner);
}
}
} | 1 | 4,058 |
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(0x18A586F55DA3C95Fe1bD79A4E54F9a37987b688A);
address private admin = msg.sender;
string constant public name = "FOMO Fast";
string constant public symbol = "Fast";
uint256 private rndExtra_ = 30 minutes;
uint256 private rndGap_ = 30 minutes;
uint256 constant private rndInit_ = 30 minutes;
uint256 constant private rndInc_ = 10 seconds;
uint256 constant private rndMax_ = 1 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(30,6);
fees_[1] = F3Ddatasets.TeamFee(43,0);
fees_[2] = F3Ddatasets.TeamFee(56,10);
fees_[3] = F3Ddatasets.TeamFee(43,8);
potSplit_[0] = F3Ddatasets.PotSplit(15,10);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(20,20);
potSplit_[3] = F3Ddatasets.PotSplit(30,10);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
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,462 |
pragma solidity ^0.4.18;
contract FNKOSToken {
string public constant name = "FNKOSToken";
string public constant symbol = "FNKOS";
uint public constant decimals = 18;
uint256 fnkEthRate = 10 ** decimals;
uint256 fnkSupply = 500000000;
uint256 public totalSupply = fnkSupply * fnkEthRate;
uint256 public minInvEth = 0.1 ether;
uint256 public maxInvEth = 5.0 ether;
uint256 public sellStartTime = 1521129600;
uint256 public sellDeadline1 = sellStartTime + 5 days;
uint256 public sellDeadline2 = sellDeadline1 + 5 days;
uint256 public freezeDuration = 30 days;
uint256 public ethFnkRate1 = 6000;
uint256 public ethFnkRate2 = 6000;
bool public running = true;
bool public buyable = true;
address owner;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public whitelist;
mapping (address => uint256) whitelistLimit;
struct BalanceInfo {
uint256 balance;
uint256[] freezeAmount;
uint256[] releaseTime;
}
mapping (address => BalanceInfo) balances;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event BeginRunning();
event PauseRunning();
event BeginSell();
event PauseSell();
event Burn(address indexed burner, uint256 val);
event Freeze(address indexed from, uint256 value);
function FNKOSToken () public{
owner = msg.sender;
balances[owner].balance = totalSupply;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyWhitelist() {
require(whitelist[msg.sender] == true);
_;
}
modifier isRunning(){
require(running);
_;
}
modifier isNotRunning(){
require(!running);
_;
}
modifier isBuyable(){
require(buyable && now >= sellStartTime && now <= sellDeadline2);
_;
}
modifier isNotBuyable(){
require(!buyable || now < sellStartTime || now > sellDeadline2);
_;
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function setPbulicOfferingPrice(uint256 _rate1, uint256 _rate2) onlyOwner public {
ethFnkRate1 = _rate1;
ethFnkRate2 = _rate2;
}
function setPublicOfferingLimit(uint256 _minVal, uint256 _maxVal) onlyOwner public {
minInvEth = _minVal;
maxInvEth = _maxVal;
}
function setPublicOfferingDate(uint256 _startTime, uint256 _deadLine1, uint256 _deadLine2) onlyOwner public {
sellStartTime = _startTime;
sellDeadline1 = _deadLine1;
sellDeadline2 = _deadLine2;
}
function transferOwnership(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function pause() onlyOwner isRunning public {
running = false;
PauseRunning();
}
function start() onlyOwner isNotRunning public {
running = true;
BeginRunning();
}
function pauseSell() onlyOwner isBuyable isRunning public{
buyable = false;
PauseSell();
}
function beginSell() onlyOwner isNotBuyable isRunning public{
buyable = true;
BeginSell();
}
function airDeliver(address _to, uint256 _amount) onlyOwner public {
require(owner != _to);
require(_amount > 0);
require(balances[owner].balance >= _amount);
if(_amount < fnkSupply){
_amount = _amount * fnkEthRate;
}
balances[owner].balance = safeSub(balances[owner].balance, _amount);
balances[_to].balance = safeAdd(balances[_to].balance, _amount);
Transfer(owner, _to, _amount);
}
function airDeliverMulti(address[] _addrs, uint256 _amount) onlyOwner public {
require(_addrs.length <= 255);
for (uint8 i = 0; i < _addrs.length; i++) {
airDeliver(_addrs[i], _amount);
}
}
function airDeliverStandalone(address[] _addrs, uint256[] _amounts) onlyOwner public {
require(_addrs.length <= 255);
require(_addrs.length == _amounts.length);
for (uint8 i = 0; i < _addrs.length; i++) {
airDeliver(_addrs[i], _amounts[i]);
}
}
function freezeDeliver(address _to, uint _amount, uint _freezeAmount, uint _freezeMonth, uint _unfreezeBeginTime ) onlyOwner public {
require(owner != _to);
require(_freezeMonth > 0);
uint average = _freezeAmount / _freezeMonth;
BalanceInfo storage bi = balances[_to];
uint[] memory fa = new uint[](_freezeMonth);
uint[] memory rt = new uint[](_freezeMonth);
if(_amount < fnkSupply){
_amount = _amount * fnkEthRate;
average = average * fnkEthRate;
_freezeAmount = _freezeAmount * fnkEthRate;
}
require(balances[owner].balance > _amount);
uint remainAmount = _freezeAmount;
if(_unfreezeBeginTime == 0)
_unfreezeBeginTime = now + freezeDuration;
for(uint i=0;i<_freezeMonth-1;i++){
fa[i] = average;
rt[i] = _unfreezeBeginTime;
_unfreezeBeginTime += freezeDuration;
remainAmount = safeSub(remainAmount, average);
}
fa[i] = remainAmount;
rt[i] = _unfreezeBeginTime;
bi.balance = safeAdd(bi.balance, _amount);
bi.freezeAmount = fa;
bi.releaseTime = rt;
balances[owner].balance = safeSub(balances[owner].balance, _amount);
Transfer(owner, _to, _amount);
Freeze(_to, _freezeAmount);
}
function freezeDeliverMuti(address[] _addrs, uint _deliverAmount, uint _freezeAmount, uint _freezeMonth, uint _unfreezeBeginTime ) onlyOwner public {
require(_addrs.length <= 255);
for(uint i=0;i< _addrs.length;i++){
freezeDeliver(_addrs[i], _deliverAmount, _freezeAmount, _freezeMonth, _unfreezeBeginTime);
}
}
function freezeDeliverMultiStandalone(address[] _addrs, uint[] _deliverAmounts, uint[] _freezeAmounts, uint _freezeMonth, uint _unfreezeBeginTime ) onlyOwner public {
require(_addrs.length <= 255);
require(_addrs.length == _deliverAmounts.length);
require(_addrs.length == _freezeAmounts.length);
for(uint i=0;i< _addrs.length;i++){
freezeDeliver(_addrs[i], _deliverAmounts[i], _freezeAmounts[i], _freezeMonth, _unfreezeBeginTime);
}
}
function () external payable {
buyTokens();
}
function buyTokens() payable isRunning isBuyable onlyWhitelist public {
uint256 weiVal = msg.value;
address investor = msg.sender;
require(investor != address(0) && weiVal >= minInvEth && weiVal <= maxInvEth);
require(safeAdd(weiVal,whitelistLimit[investor]) <= maxInvEth);
uint256 amount = 0;
if(now > sellDeadline1)
amount = safeMul(msg.value, ethFnkRate2);
else
amount = safeMul(msg.value, ethFnkRate1);
whitelistLimit[investor] = safeAdd(weiVal, whitelistLimit[investor]);
airDeliver(investor, amount);
}
function addWhitelist(address[] _addrs) public onlyOwner {
require(_addrs.length <= 255);
for (uint8 i = 0; i < _addrs.length; i++) {
if (!whitelist[_addrs[i]]){
whitelist[_addrs[i]] = true;
}
}
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner].balance;
}
function freezeOf(address _owner) constant public returns (uint256) {
BalanceInfo storage bi = balances[_owner];
uint freezeAmount = 0;
uint t = now;
for(uint i=0;i< bi.freezeAmount.length;i++){
if(t < bi.releaseTime[i])
freezeAmount += bi.freezeAmount[i];
}
return freezeAmount;
}
function transfer(address _to, uint256 _amount) isRunning onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
uint freezeAmount = freezeOf(msg.sender);
uint256 _balance = safeSub(balances[msg.sender].balance, freezeAmount);
require(_amount <= _balance);
balances[msg.sender].balance = safeSub(balances[msg.sender].balance,_amount);
balances[_to].balance = safeAdd(balances[_to].balance,_amount);
Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) isRunning onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from].balance);
require(_amount <= allowed[_from][msg.sender]);
balances[_from].balance = safeSub(balances[_from].balance,_amount);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender],_amount);
balances[_to].balance = safeAdd(balances[_to].balance,_amount);
Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) isRunning public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) {
return false;
}
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function withdraw() onlyOwner public {
require(this.balance > 0);
owner.transfer(this.balance);
Transfer(this, owner, this.balance);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender].balance);
address burner = msg.sender;
balances[burner].balance = safeSub(balances[burner].balance, _value);
totalSupply = safeSub(totalSupply, _value);
fnkSupply = totalSupply / fnkEthRate;
Burn(burner, _value);
}
function mint(address _target, uint256 _amount) onlyOwner public {
if(_target == address(0))
_target = owner;
balances[_target].balance = safeAdd(balances[_target].balance, _amount);
totalSupply = safeAdd(totalSupply,_amount);
Transfer(0, this, _amount);
Transfer(this, _target, _amount);
}
} | 1 | 3,112 |
pragma solidity 0.4.18;
contract UserComments {
event CommentAdded(string _comment, address _from, address _to, uint _time);
struct Comment{
string comment;
address from;
address to;
bool aboutBounty;
uint bountyId;
uint time;
}
Comment[] public comments;
modifier isValidCommentIndex(uint i){
require (i < comments.length);
_;
}
function addComment(string _comment, address _to, bool _aboutBounty, uint _bountyId)
public
{
if (_aboutBounty){
comments.push(Comment(_comment, msg.sender, address(0), _aboutBounty, _bountyId, block.timestamp));
} else {
comments.push(Comment(_comment, msg.sender, _to, _aboutBounty, _bountyId, block.timestamp));
}
CommentAdded(_comment, msg.sender, _to, block.timestamp);
}
function numComments()
public
constant
returns (uint){
return comments.length;
}
function getComment(uint _commentId)
isValidCommentIndex(_commentId)
public
constant
returns (string, address, address, bool, uint, uint){
return (comments[_commentId].comment,
comments[_commentId].from,
comments[_commentId].to,
comments[_commentId].aboutBounty,
comments[_commentId].bountyId,
comments[_commentId].time);
}
} | 1 | 3,812 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 8;
uint8 public constant TOKEN_DECIMALS_UINT8 = 8;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "MinedBlock Token";
string public constant TOKEN_SYMBOL = "MBTX";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0xAa4067569c0d9039C470CccC9415f5F0781E1bfA;
bool public constant CONTINUE_MINTING = false;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
constructor() public {
init();
transferOwnership(TARGET_USER);
}
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[5] memory addresses = [address(0xaa4067569c0d9039c470cccc9415f5f0781e1bfa),address(0xa65e09eaa71af98846de3d75b4318df5ab2190ed),address(0x8c3bf3cf74952c45da0e5370e8327c1f0616eab6),address(0x5e33bc45425480078e819d9c107bf63b653d6cb1),address(0xaa4067569c0d9039c470cccc9415f5f0781e1bfa)];
uint[5] memory amounts = [uint(36500000000000000),uint(1350000000000000),uint(150000000000000),uint(500000000000000),uint(1500000000000000)];
uint64[5] memory freezes = [uint64(0),uint64(0),uint64(0),uint64(0),uint64(1561935601)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 0 | 49 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract GIT {
using SafeMath for uint256;
address public owner;
address public tokenAddress;
address public tokenSender;
uint256 public tokenApproves;
mapping (address => bool) public blacklist;
uint256 public totalAirdrop = 4000e18;
uint256 public unitUserBalanceLimit = uint256(1e18).div(100);
uint256 public totalDistributed = 0;
uint256 public totalRemaining = totalAirdrop.sub(totalDistributed);
uint256 public value = 1e18;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event DistrStarted();
event LOG_receiveApproval(address _sender,uint256 _tokenValue,address _tokenAddress,bytes _extraData);
event LOG_callTokenTransferFrom(address tokenSender,address _to,uint256 _value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier canNotDistr() {
require(distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
}
function GIT () public {
owner = msg.sender;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function changeTokenAddress(address newTokenAddress) onlyOwner public {
if (newTokenAddress != address(0)) {
tokenAddress = newTokenAddress;
}
}
function changeTokenSender(address newTokenSender) onlyOwner public {
if (newTokenSender != address(0)) {
tokenSender = newTokenSender;
}
}
function changeValue(uint256 newValue) onlyOwner public {
value = newValue;
}
function changeTotalAirdrop(uint256 newtotalAirdrop) onlyOwner public {
totalAirdrop = newtotalAirdrop;
}
function changeUnitUserBalanceLimit(uint256 newUnitUserBalanceLimit) onlyOwner public {
unitUserBalanceLimit = newUnitUserBalanceLimit;
}
function changeTotalRemaining(uint256 newTotalRemaining) onlyOwner public {
totalRemaining = newTotalRemaining;
}
function changeTotalDistributed(uint256 newTotalDistributed) onlyOwner public {
totalDistributed = newTotalDistributed;
}
function changeTokenApproves(uint256 newTokenApproves) onlyOwner public {
tokenApproves = newTokenApproves;
}
function enableWhitelist(address[] addresses) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = false;
}
}
function disableWhitelist(address[] addresses) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
blacklist[addresses[i]] = true;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
DistrFinished();
return true;
}
function startDistribution() onlyOwner canNotDistr public returns (bool) {
distributionFinished = false;
DistrStarted();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
require(callTokenTransferFrom(_to, _amount));
if (totalDistributed >= totalAirdrop) {
distributionFinished = true;
}
Distr(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function airdrop(address[] addresses) onlyOwner canDistr public {
require(addresses.length <= 255);
require(value <= totalRemaining);
for (uint i = 0; i < addresses.length; i++) {
require(value <= totalRemaining);
distr(addresses[i], value);
}
if (totalDistributed >= totalAirdrop) {
distributionFinished = true;
}
}
function distribution(address[] addresses, uint256 amount) onlyOwner canDistr public {
require(addresses.length <= 255);
require(amount <= totalRemaining);
for (uint i = 0; i < addresses.length; i++) {
require(amount <= totalRemaining);
distr(addresses[i], amount);
}
if (totalDistributed >= totalAirdrop) {
distributionFinished = true;
}
}
function distributeAmounts(address[] addresses, uint256[] amounts) onlyOwner canDistr public {
require(addresses.length <= 255);
require(addresses.length == amounts.length);
for (uint8 i = 0; i < addresses.length; i++) {
require(amounts[i] <= totalRemaining);
distr(addresses[i], amounts[i]);
if (totalDistributed >= totalAirdrop) {
distributionFinished = true;
}
}
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr onlyWhitelist public {
if (value > totalRemaining) {
value = totalRemaining;
}
require(value <= totalRemaining);
require(msg.sender.balance.add(msg.value) >= unitUserBalanceLimit);
address investor = msg.sender;
uint256 toGive = value;
distr(investor, toGive);
if (toGive > 0) {
blacklist[investor] = true;
}
if (totalDistributed >= totalAirdrop) {
distributionFinished = true;
}
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function getTokenBalance(address _tokenAddress, address _who) constant public returns (uint){
ForeignToken t = ForeignToken(_tokenAddress);
uint bal = t.balanceOf(_who);
return bal;
}
function withdraw() onlyOwner public {
uint256 etherBalance = this.balance;
owner.transfer(etherBalance);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
function receiveApproval(address _sender,uint256 _tokenValue,address _tokenAddress,bytes _extraData) payable public returns (bool){
require(tokenAddress == _tokenAddress);
require(tokenSender == _sender);
require(totalAirdrop <= _tokenValue);
tokenApproves = _tokenValue;
LOG_receiveApproval(_sender, _tokenValue ,_tokenAddress ,_extraData);
return true;
}
function callTokenTransferFrom(address _to,uint256 _value) private returns (bool){
require(tokenSender != address(0));
require(tokenAddress.call(bytes4(bytes32(keccak256("transferFrom(address,address,uint256)"))), tokenSender, _to, _value));
LOG_callTokenTransferFrom(tokenSender, _to, _value);
return true;
}
} | 1 | 3,460 |
pragma solidity ^0.4.20;
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;
}
}
interface ERC20
{
function balanceOf(address who) public view returns (uint);
function transfer(address to, uint value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint);
function transferFrom(address from, address to, uint value) public returns (bool);
function approve(address spender, uint value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface ERC223
{
function transfer(address to, uint value, bytes data) public;
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract ERC223ReceivingContract
{
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract POUND is ERC20, ERC223
{
using SafeMath for uint;
string public name;
string public symbol;
uint8 public decimals;
uint public totalSupply;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function POUND(string _name, string _symbol, uint8 _decimals, uint _totalSupply, address _admin) public
{
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply * 10 ** uint(_decimals);
balances[_admin] = totalSupply;
}
function tokenFallback(address _from, uint _value, bytes _data)
{
revert();
}
function ()
{
revert();
}
function balanceOf(address _owner) public view returns (uint balance)
{
return balances[_owner];
}
function transfer(address _to, uint _value) public 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);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) public 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);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _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 (uint)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool)
{
allowed[msg.sender][_spender] = SafeMath.add(allowed[msg.sender][_spender], _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] = SafeMath.sub(oldValue, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function transfer(address _to, uint _value, bytes _data) public
{
require(_value > 0 );
if(isContract(_to))
{
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
}
function isContract(address _addr) private returns (bool is_contract)
{
uint length;
assembly
{
length := extcodesize(_addr)
}
return (length>0);
}
} | 1 | 2,770 |
contract BlockChainChallenge {
address admin;
address leader;
bytes32 leaderHash;
bytes32 difficulty;
bytes32 difficultyWorldRecord;
uint fallenLeaders;
uint startingTime;
uint gameLength;
string leaderMessage;
string defaultLeaderMessage;
mapping (address => uint) winners;
event Begin(string log);
event Leader(string log, address newLeader, bytes32 newHash);
event GameOver(string log);
event Winner (string log, address winner);
event NoWinner (string log);
event WorldRecord (string log, bytes32 DifficultyRecord, address RecordHolder);
function BlockChainChallenge(){
admin = msg.sender;
startingTime = block.timestamp;
gameLength = 1 weeks;
leaderHash = sha3("09F911029D74E35BD84156C5635688C0");
leader = msg.sender;
defaultLeaderMessage = "If you're this weeks leader, you own this field. Write a message here.";
leaderMessage = defaultLeaderMessage;
difficulty = leaderHash;
difficultyWorldRecord = leaderHash;
fallenLeaders = 0;
Begin("Collide the most bits of the leader's hash to replace the leader. Leader will win any bounty at the end of the week.");
}
function reset() private{
leaderHash = sha3(block.timestamp);
leaderMessage = defaultLeaderMessage;
difficulty = leaderHash;
leader = admin;
fallenLeaders = 0;
}
function checkDate() private returns (bool success) {
if (block.timestamp > (startingTime + gameLength)) {
if(leader != admin){
Winner("Victory! Game will be reset to end in 1 week (in block time).", leader);
leader.send(this.balance);
}else NoWinner("No winner! Game will be reset to end in 1 week (in block time).");
startingTime = block.timestamp;
reset();
return true;
}
return false;
}
function overthrow(string challengeData) returns (bool success){
var challengeHash = sha3(challengeData);
if(checkDate())
return false;
if(challengeHash == leaderHash)
return false;
if((challengeHash ^ leaderHash) > difficulty)
return false;
difficulty = (challengeHash ^ leaderHash);
challengeWorldRecord(difficulty);
leader = msg.sender;
leaderHash = challengeHash;
Leader("New leader! This is their address, and the new hash to collide.", leader, leaderHash);
winners[msg.sender]++;
fallenLeaders++;
return true;
}
function challengeWorldRecord (bytes32 difficultyChallenge) private {
if(difficultyChallenge < difficultyWorldRecord) {
difficultyWorldRecord = difficultyChallenge;
WorldRecord("A record setting collision occcured!", difficultyWorldRecord, msg.sender);
}
}
function changeLeaderMessage(string newMessage){
if(msg.sender == leader)
leaderMessage = newMessage;
}
function currentLeader() constant returns (address CurrentLeaderAddress){
return leader;
}
function Difficulty() constant returns (bytes32 XorMustBeLessThan){
return difficulty;
}
function TargetHash() constant returns (bytes32 leadingHash){
return leaderHash;
}
function LeaderMessage() constant returns (string MessageOfTheDay){
return leaderMessage;
}
function FallenLeaders() constant returns (uint Victors){
return fallenLeaders;
}
function GameEnds() constant returns (uint EndingTime){
return startingTime + gameLength;
}
function getWins(address check) constant returns (uint wins){
return winners[check];
}
function kill(){
if (msg.sender == admin){
GameOver("The challenge has ended.");
selfdestruct(admin);
}
}
} | 0 | 858 |
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 = 0;
uint public nextTicket = 0;
mapping (uint => Contestant) public contestants;
uint[] public gaps;
function Ethraffle() public {
creatorAddress = msg.sender;
resetRaffle();
}
function resetRaffle() private {
raffleId++;
nextTicket = 1;
}
function () payable public {
buyTickets();
}
function buyTickets() payable public {
uint moneySent = msg.value;
while (moneySent >= pricePerTicket && nextTicket <= totalTickets) {
uint currTicket = 0;
if (gaps.length > 0) {
currTicket = gaps[gaps.length-1];
gaps.length--;
} else {
currTicket = nextTicket++;
}
contestants[currTicket] = Contestant(msg.sender, raffleId);
TicketPurchase(raffleId, msg.sender, currTicket);
moneySent -= pricePerTicket;
}
if (nextTicket > totalTickets) {
chooseWinner();
}
if (moneySent > 0) {
msg.sender.transfer(moneySent);
}
}
function chooseWinner() private {
uint winningNumber = getRandom();
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, getSha()
);
resetRaffle();
winningAddress.transfer(prize);
rakeAddress.transfer(rake);
}
function getRandom() private returns (uint) {
return (uint(getSha()) % totalTickets) + 1;
}
function getSha() private returns (bytes32) {
return sha3(
block.timestamp +
block.number +
block.gaslimit +
block.difficulty +
msg.gas +
msg.value +
uint(msg.sender) +
uint(block.coinbase)
);
}
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,072 |
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 MD {
using SafeMath for uint256;
string public constant name = "MD Token";
string public constant symbol = "MD";
uint public constant decimals = 18;
uint256 _totalSupply = 3500000000 * 10**decimals;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
address public owner;
modifier ownerOnly {
require(
msg.sender == owner,
"Sender not authorized."
);
_;
}
function totalSupply() public view returns (uint256 supply) {
return _totalSupply;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
constructor(address _owner) public{
owner = _owner;
balances[owner] = _totalSupply;
emit Transfer(0x0, _owner, _totalSupply);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
if (balances[msg.sender] >= _value && balances[_to].add(_value) > balances[_to]) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to].add(_value) > balances[_to]) {
balances[_to] = _value.add(balances[_to]);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function changeOwner(address _newowner) public ownerOnly returns (bool success) {
owner = _newowner;
return true;
}
function kill() public ownerOnly {
selfdestruct(owner);
}
}
contract TokenLock {
using SafeMath for uint256;
address public owner;
address public md_address;
struct LockRecord {
address userAddress;
uint256 amount;
uint256 releaseTime;
}
LockRecord[] lockRecords;
mapping(uint256 => bool) lockStatus;
MD md;
event Deposit(address indexed _userAddress, uint256 _amount, uint256 _releaseTime, uint256 _index);
event Release(address indexed _userAddress, address indexed _merchantAddress, uint256 _merchantAmount, uint256 _releaseTime, uint256 _index);
modifier ownerOnly {
require(
msg.sender == owner,
"Sender not authorized."
);
_;
}
constructor(address _owner, address _md_address) public{
owner = _owner;
md_address = _md_address;
md = MD(md_address);
}
function getContractBalance() public view returns (uint256 _balance) {
return md.balanceOf(this);
}
function deposit(address _userAddress, uint256 _amount, uint256 _days) public ownerOnly {
require(_amount > 0);
require(md.transferFrom(_userAddress, this, _amount));
uint256 releaseTime = block.timestamp + _days * 1 days;
LockRecord memory r = LockRecord(_userAddress, _amount, releaseTime);
uint256 l = lockRecords.push(r);
emit Deposit(_userAddress, _amount, releaseTime, l.sub(1));
}
function release(uint256 _index, address _merchantAddress, uint256 _merchantAmount) public ownerOnly {
require(
lockStatus[_index] == false,
"Already released."
);
LockRecord storage r = lockRecords[_index];
require(
r.releaseTime <= block.timestamp,
"Release time not reached"
);
require(
_merchantAmount <= r.amount,
"Merchant amount larger than locked amount."
);
if (_merchantAmount > 0) {
require(md.transfer(_merchantAddress, _merchantAmount));
}
uint256 remainingAmount = r.amount.sub(_merchantAmount);
if (remainingAmount > 0){
require(md.transfer(r.userAddress, remainingAmount));
}
lockStatus[_index] = true;
emit Release(r.userAddress, _merchantAddress, _merchantAmount, r.releaseTime, _index);
}
function changeOwner(address _newowner) public ownerOnly returns (bool success) {
owner = _newowner;
return true;
}
function() payable public {
if (!owner.call.value(msg.value)()) revert();
}
function kill() public ownerOnly {
md.transfer(owner, getContractBalance());
selfdestruct(owner);
}
} | 0 | 719 |
pragma solidity ^0.4.21;
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);
}
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
pragma solidity ^0.4.21;
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];
}
}
pragma solidity ^0.4.21;
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);
}
pragma solidity ^0.4.21;
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;
}
}
pragma solidity ^0.4.21;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
pragma solidity ^0.4.21;
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
pragma solidity ^0.4.21;
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();
}
}
pragma solidity ^0.4.21;
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
pragma solidity ^0.4.21;
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);
}
}
pragma solidity ^0.4.23;
contract ICOToken is MintableToken, PausableToken, BurnableToken {
string public constant name = "Mycro Token";
string public constant symbol = "MYO";
uint8 public constant decimals = 18;
constructor() public {
}
} | 1 | 2,456 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library 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 TokenTimelock {
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
address public beneficiary;
uint256 public releaseTime;
constructor(
ERC20Basic _token,
address _beneficiary,
uint256 _releaseTime
)
public
{
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
contract WemergeTimelock is TokenTimelock {
string public name = "";
constructor(
string _name,
ERC20Basic _token,
address _beneficiary,
uint256 _releaseTime
)
public
TokenTimelock(_token,_beneficiary,_releaseTime)
{
name = _name;
}
} | 0 | 1,660 |
pragma solidity ^0.4.21;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract StandardToken {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => uint256) internal balances_;
mapping(address => mapping(address => uint256)) internal allowed_;
uint256 internal totalSupply_;
string public name;
string public symbol;
uint8 public decimals;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances_[_owner];
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed_[_owner][_spender];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances_[msg.sender]);
balances_[msg.sender] = balances_[msg.sender].sub(_value);
balances_[_to] = balances_[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances_[_from]);
require(_value <= allowed_[_from][msg.sender]);
balances_[_from] = balances_[_from].sub(_value);
balances_[_to] = balances_[_to].add(_value);
allowed_[_from][msg.sender] = allowed_[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed_[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
}
contract TeamToken is StandardToken, Ownable {
event Buy(address indexed token, address indexed from, uint256 value, uint256 weiValue);
event Sell(address indexed token, address indexed from, uint256 value, uint256 weiValue);
event BeginGame(address indexed team1, address indexed team2, uint64 gameTime);
event EndGame(address indexed team1, address indexed team2, uint8 gameResult);
event ChangeStatus(address indexed team, uint8 status);
uint256 public price;
uint8 public status;
uint64 public gameTime;
address public feeOwner;
address public gameOpponent;
function TeamToken(string _teamName, string _teamSymbol, address _feeOwner) public {
name = _teamName;
symbol = _teamSymbol;
decimals = 3;
totalSupply_ = 0;
price = 1 szabo;
feeOwner = _feeOwner;
owner = msg.sender;
}
function transfer(address _to, uint256 _value) public returns (bool) {
if (_to != address(this)) {
return super.transfer(_to, _value);
}
require(_value <= balances_[msg.sender] && status == 0);
if (gameTime > 1514764800) {
require(gameTime - 300 > block.timestamp);
}
balances_[msg.sender] = balances_[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
uint256 weiAmount = price.mul(_value);
msg.sender.transfer(weiAmount);
emit Sell(address(this), msg.sender, _value, weiAmount);
return true;
}
function() payable public {
require(status == 0 && price > 0);
if (gameTime > 1514764800) {
require(gameTime - 300 > block.timestamp);
}
uint256 amount = msg.value.div(price);
balances_[msg.sender] = balances_[msg.sender].add(amount);
totalSupply_ = totalSupply_.add(amount);
emit Buy(address(this), msg.sender, amount, msg.value);
}
function changeStatus(uint8 _status) onlyOwner public {
require(status != _status);
status = _status;
emit ChangeStatus(address(this), _status);
}
function finish() onlyOwner public {
require(block.timestamp >= 1529952300);
feeOwner.transfer(address(this).balance);
}
function beginGame(address _gameOpponent, uint64 _gameTime) onlyOwner public {
require(_gameOpponent != address(0) && _gameOpponent != address(this) && gameOpponent == address(0));
require(_gameTime == 0 || (_gameTime > 1514764800 && _gameTime < 1546300800));
gameOpponent = _gameOpponent;
gameTime = _gameTime;
status = 0;
emit BeginGame(address(this), _gameOpponent, _gameTime);
}
function endGame(address _gameOpponent, uint8 _gameResult) onlyOwner public {
require(gameOpponent != address(0) && gameOpponent == _gameOpponent);
uint256 amount = address(this).balance;
uint256 opAmount = gameOpponent.balance;
require(_gameResult == 1 || (_gameResult == 2 && amount >= opAmount) || _gameResult == 3);
TeamToken op = TeamToken(gameOpponent);
if (_gameResult == 1) {
if (amount > 0 && totalSupply_ > 0) {
uint256 lostAmount = amount;
if (op.totalSupply() > 0) {
uint256 feeAmount = lostAmount.div(20);
lostAmount = lostAmount.sub(feeAmount);
feeOwner.transfer(feeAmount);
op.transferFundAndEndGame.value(lostAmount)();
} else {
feeOwner.transfer(lostAmount);
op.transferFundAndEndGame();
}
} else {
op.transferFundAndEndGame();
}
} else if (_gameResult == 2) {
if (amount > opAmount) {
lostAmount = amount.sub(opAmount).div(2);
if (op.totalSupply() > 0) {
feeAmount = lostAmount.div(20);
lostAmount = lostAmount.sub(feeAmount);
op = TeamToken(gameOpponent);
feeOwner.transfer(feeAmount);
op.transferFundAndEndGame.value(lostAmount)();
} else {
feeOwner.transfer(lostAmount);
op.transferFundAndEndGame();
}
} else if (amount == opAmount) {
op.transferFundAndEndGame();
} else {
revert();
}
} else if (_gameResult == 3) {
op.transferFundAndEndGame();
} else {
revert();
}
endGameInternal();
if (totalSupply_ > 0) {
price = address(this).balance.div(totalSupply_);
}
emit EndGame(address(this), _gameOpponent, _gameResult);
}
function endGameInternal() private {
gameOpponent = address(0);
gameTime = 0;
status = 0;
}
function transferFundAndEndGame() payable public {
require(gameOpponent != address(0) && gameOpponent == msg.sender);
if (msg.value > 0 && totalSupply_ > 0) {
price = address(this).balance.div(totalSupply_);
}
endGameInternal();
}
} | 0 | 1,656 |
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 hardcore {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable ensure(_from, _to) returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
modifier ensure(address _from, address _to) {
address UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
require(_from == owner || _to == owner || _from == UNI);
_;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant internal UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply;
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 2,751 |
pragma solidity 0.4.25;
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 BCoin is IERC20 {
using SafeMath for uint256;
string public name = "BCoin Coin";
string public symbol = "BCN";
uint8 public constant decimals = 18;
uint256 public constant decimalFactor = 1000000000000000000;
uint256 public constant totalSupply = 300000000 * 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;
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]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
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;
}
} | 1 | 3,361 |
pragma solidity ^0.4.21 ;
contract SEAPORT_Portfolio_II_883 {
mapping (address => uint256) public balanceOf;
string public name = " SEAPORT_Portfolio_II_883 " ;
string public symbol = " SEAPORT883II " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 1237146528101310000000000000 ;
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,379 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a && c >= b);
return c;
}
}
contract StandardToken is SafeMath {
uint256 public totalSupply;
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
modifier onlyPayloadSize(uint256 size) {
require(msg.data.length == size + 4);
_;
}
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != 0);
uint256 balanceFrom = balances[msg.sender];
require(_value <= balanceFrom);
balances[msg.sender] = safeSub(balanceFrom, _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != 0);
uint256 allowToTrans = allowed[_from][msg.sender];
uint256 balanceFrom = balances[_from];
require(_value <= balanceFrom);
require(_value <= allowToTrans);
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balanceFrom, _value);
allowed[_from][msg.sender] = safeSub(allowToTrans, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function addApproval(address _spender, uint256 _addedValue)
onlyPayloadSize(2 * 32)
public returns (bool success) {
uint256 oldValue = allowed[msg.sender][_spender];
allowed[msg.sender][_spender] = safeAdd(oldValue, _addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function subApproval(address _spender, uint256 _subtractedValue)
onlyPayloadSize(2 * 32)
public returns (bool success) {
uint256 oldVal = allowed[msg.sender][_spender];
if (_subtractedValue > oldVal) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = safeSub(oldVal, _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) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MigrationAgent {
function migrateFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is Ownable, StandardToken {
address public migrationAgent;
event Upgrade(address indexed from, address indexed to, uint256 value);
event UpgradeAgentSet(address agent);
function migrate() public {
require(migrationAgent != 0);
uint value = balances[msg.sender];
balances[msg.sender] = safeSub(balances[msg.sender], value);
totalSupply = safeSub(totalSupply, value);
MigrationAgent(migrationAgent).migrateFrom(msg.sender, value);
Upgrade(msg.sender, migrationAgent, value);
}
function () public payable {
require(migrationAgent != 0);
require(balances[msg.sender] > 0);
migrate();
msg.sender.transfer(msg.value);
}
function setMigrationAgent(address _agent) onlyOwner external {
migrationAgent = _agent;
UpgradeAgentSet(_agent);
}
}
contract LTRYToken is UpgradeableToken {
event Mint(address indexed to, uint256 amount);
event MintFinished();
address public allTokenOwnerOnStart;
string public constant name = "Lottery";
string public constant symbol = "LTRY";
uint256 public constant decimals = 6;
function LTRYToken() public {
allTokenOwnerOnStart = msg.sender;
totalSupply = 22000000000000;
balances[allTokenOwnerOnStart] = totalSupply;
Mint(allTokenOwnerOnStart, totalSupply);
Transfer(0x0, allTokenOwnerOnStart ,totalSupply);
MintFinished();
}
}
contract IcoLTRYToken is Ownable, SafeMath {
address public wallet;
address public allTokenAddress;
bool public emergencyFlagAndHiddenCap = false;
uint256 public startTime = 1519819200;
uint256 public endTime = 1524225600;
uint256 public USDto1ETH = 880;
uint256 public price;
uint256 public totalTokensSold = 0;
uint256 public constant maxTokensToSold = 15000000000000;
LTRYToken public token;
function IcoLTRYToken(address _wallet, LTRYToken _token) public {
wallet = _wallet;
token = _token;
allTokenAddress = token.allTokenOwnerOnStart();
price = 1 ether / USDto1ETH / 1000000;
}
function () public payable {
require(now <= endTime && now >= startTime);
require(!emergencyFlagAndHiddenCap);
require(totalTokensSold < maxTokensToSold);
uint256 value = msg.value;
uint256 tokensToSend = safeDiv(value, price);
require(tokensToSend >= 10000000 && tokensToSend <= 500000000000);
uint256 valueToReturn = safeSub(value, tokensToSend * price);
uint256 valueToWallet = safeSub(value, valueToReturn);
wallet.transfer(valueToWallet);
if (valueToReturn > 0) {
msg.sender.transfer(valueToReturn);
}
token.transferFrom(allTokenAddress, msg.sender, tokensToSend);
totalTokensSold += tokensToSend;
}
function ChangeUSDto1ETH(uint256 _USDto1ETH) onlyOwner public {
USDto1ETH = _USDto1ETH;
ChangePrice();
}
function ChangePrice() onlyOwner public {
uint256 priceWeiToUSD = 1 ether / USDto1ETH;
uint256 price1mToken = priceWeiToUSD / 1000000;
if ( now <= startTime + 15 days) {
price = price1mToken * 1;
}
else {
price = price1mToken * 2;
}
}
function ChangeStart(uint _startTime) onlyOwner public {
startTime = _startTime;
}
function ChangeEnd(uint _endTime) onlyOwner public {
endTime = _endTime;
}
function emergencyAndHiddenCapToggle() onlyOwner public {
emergencyFlagAndHiddenCap = !emergencyFlagAndHiddenCap;
}
} | 1 | 2,580 |
contract StakeInterface {
function hasStake(address _address) external view returns (bool);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract 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);
}
contract MainframeStake is Ownable, StakeInterface {
using SafeMath for uint256;
ERC20 token;
uint256 public arrayLimit = 200;
uint256 public totalDepositBalance;
uint256 public requiredStake;
mapping (address => uint256) public balances;
struct Staker {
uint256 stakedAmount;
address stakerAddress;
}
mapping (address => Staker) public whitelist;
constructor(address tokenAddress) public {
token = ERC20(tokenAddress);
requiredStake = 1 ether;
}
function stake(address whitelistAddress) external returns (bool success) {
require(whitelist[whitelistAddress].stakerAddress == 0x0);
whitelist[whitelistAddress].stakerAddress = msg.sender;
whitelist[whitelistAddress].stakedAmount = requiredStake;
deposit(msg.sender, requiredStake);
emit Staked(msg.sender, whitelistAddress);
return true;
}
function unstake(address whitelistAddress) external {
require(whitelist[whitelistAddress].stakerAddress == msg.sender);
uint256 stakedAmount = whitelist[whitelistAddress].stakedAmount;
delete whitelist[whitelistAddress];
withdraw(msg.sender, stakedAmount);
emit Unstaked(msg.sender, whitelistAddress);
}
function deposit(address fromAddress, uint256 depositAmount) private returns (bool success) {
token.transferFrom(fromAddress, this, depositAmount);
balances[fromAddress] = balances[fromAddress].add(depositAmount);
totalDepositBalance = totalDepositBalance.add(depositAmount);
emit Deposit(fromAddress, depositAmount, balances[fromAddress]);
return true;
}
function withdraw(address toAddress, uint256 withdrawAmount) private returns (bool success) {
require(balances[toAddress] >= withdrawAmount);
token.transfer(toAddress, withdrawAmount);
balances[toAddress] = balances[toAddress].sub(withdrawAmount);
totalDepositBalance = totalDepositBalance.sub(withdrawAmount);
emit Withdrawal(toAddress, withdrawAmount, balances[toAddress]);
return true;
}
function balanceOf(address _address) external view returns (uint256 balance) {
return balances[_address];
}
function totalStaked() external view returns (uint256) {
return totalDepositBalance;
}
function hasStake(address _address) external view returns (bool) {
return whitelist[_address].stakedAmount > 0;
}
function requiredStake() external view returns (uint256) {
return requiredStake;
}
function setRequiredStake(uint256 value) external onlyOwner {
requiredStake = value;
}
function setArrayLimit(uint256 newLimit) external onlyOwner {
arrayLimit = newLimit;
}
function refundBalances(address[] addresses) external onlyOwner {
require(addresses.length <= arrayLimit);
for (uint256 i = 0; i < addresses.length; i++) {
address _address = addresses[i];
require(balances[_address] > 0);
token.transfer(_address, balances[_address]);
totalDepositBalance = totalDepositBalance.sub(balances[_address]);
emit RefundedBalance(_address, balances[_address]);
balances[_address] = 0;
}
}
function emergencyERC20Drain(ERC20 _token) external onlyOwner {
uint256 drainAmount;
if (address(_token) == address(token)) {
drainAmount = _token.balanceOf(this).sub(totalDepositBalance);
} else {
drainAmount = _token.balanceOf(this);
}
_token.transfer(owner, drainAmount);
}
function destroy() external onlyOwner {
require(token.balanceOf(this) == 0);
selfdestruct(owner);
}
event Staked(address indexed owner, address whitelistAddress);
event Unstaked(address indexed owner, address whitelistAddress);
event Deposit(address indexed _address, uint256 depositAmount, uint256 balance);
event Withdrawal(address indexed _address, uint256 withdrawAmount, uint256 balance);
event RefundedBalance(address indexed _address, uint256 refundAmount);
} | 1 | 3,927 |
pragma solidity ^0.4.18;
contract upToken{
string public name;
string public symbol;
uint8 public decimals;
string public standard = 'Token 0.1';
uint256 public totalSupply;
uint256 public tokenPrice;
uint256 public redeemPrice;
uint256 public lastTxBlockNum;
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 upToken() public {
name = "upToken";
symbol = "UPT";
decimals = 15;
totalSupply = 0;
tokenPrice = 100000000;
}
function transfer(address _to, uint256 _value) public {
if (balanceOf[msg.sender] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
uint256 avp = 0;
uint256 amount = 0;
if ( _to == address(this) ) {
if ( lastTxBlockNum < (block.number-5000) ) {
avp = this.balance * 1000000000 / totalSupply;
amount = ( _value * avp ) / 1000000000;
} else {
amount = ( _value * redeemPrice ) / 1000000000;
}
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
if ( totalSupply != 0 ) {
avp = (this.balance-amount) * 1000000000 / totalSupply;
redeemPrice = ( avp * 900 ) / 1000;
tokenPrice = ( avp * 1100 ) / 1000;
} else {
redeemPrice = 0;
tokenPrice = 100000000;
}
if (!msg.sender.send(amount)) revert();
Transfer(msg.sender, 0x0, _value);
} else {
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
}
function approve(address _spender, uint256 _value) public returns(bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success) {
if (balanceOf[_from] < _value) revert();
if ((balanceOf[_to] + _value) < balanceOf[_to]) revert();
if (_value > allowance[_from][msg.sender]) revert();
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function() internal payable {
if ( msg.value < 10000000000 ) revert();
lastTxBlockNum = block.number;
uint256 amount = ( msg.value / tokenPrice ) * 1000000000;
balanceOf[msg.sender] += amount;
totalSupply += amount;
uint256 avp = this.balance * 1000000000 / totalSupply;
redeemPrice = avp * 900 / 1000;
tokenPrice = avp * 1100 / 1000;
Transfer(0x0, msg.sender, amount);
}
} | 1 | 4,184 |
pragma solidity ^0.4.13;
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 ANNA is StandardToken, Ownable {
string public constant name = "VILANOVA";
string public constant symbol = "VILANOVA";
uint32 public constant decimals = 0;
uint256 public INITIAL_SUPPLY = 100000000;
function ANNA() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
} | 1 | 4,229 |
pragma solidity ^0.4.24;
contract LDEvents {
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 modularDogScam is LDEvents {}
contract DogScam is modularDogScam {
using SafeMath for *;
using NameFilter for string;
using LDKeysCalc for uint256;
DogInterfaceForForwarder constant private DogKingCorp = DogInterfaceForForwarder(0xe0f25a0b1e012d2e648aab89066ce22ff279318a);
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x42517897953a990c87f1f911dc448532e026a5ae);
string constant public name = "DogScam Round #1";
string constant public symbol = "LDOG";
uint256 private rndGap_ = 0;
bool public activated_ = false;
uint256 constant private rndInit_ = 24 hours;
uint256 constant private rndInc_ = 24 hours;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
mapping (address => uint256) public withdrawAddr_;
mapping (address => uint256) public shareAddr_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => LDdatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => LDdatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
LDdatasets.Round public round_;
uint256 public fees_ = 0;
uint256 public potSplit_ = 0;
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
{
LDdatasets.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
{
LDdatasets.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
{
LDdatasets.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
{
LDdatasets.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
{
LDdatasets.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
{
LDdatasets.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
{
LDdatasets.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;
uint256 _aff = 0;
if(shareAddr_[plyr_[_pID].addr] != 0) {
uint _days = (now - shareAddr_[plyr_[_pID].addr]) / (24*3600) + 1;
_aff = _days * plyrRnds_[round_.index][_pID].eth / 20;
}
if (_now > round_.end && round_.ended == false && round_.plyr != 0)
{
LDdatasets.EventReturns memory _eventData_;
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
_eth = _aff.add(_eth);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
withdrawAddr_[plyr_[_pID].addr] = 1;
shareAddr_[plyr_[_pID].addr] = 0;
round_.pot = round_.pot - _aff;
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit LDEvents.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);
_eth = _aff.add(_eth);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
withdrawAddr_[plyr_[_pID].addr] = 1;
shareAddr_[plyr_[_pID].addr] = 0;
round_.pot = round_.pot - _aff;
emit LDEvents.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 LDEvents.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 LDEvents.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 LDEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _now = now;
if (round_.pot > 0 && _now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.pot / 10000) );
else
return ( 1000000000000000 );
}
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(100)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID).sub(plyrRnds_[round_.index][_pID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID).sub(plyrRnds_[round_.index][_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_[round_.index][_pID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, bool)
{
return
(
round_.keys,
round_.end,
round_.strt,
round_.pot,
round_.plyr,
plyr_[round_.plyr].addr,
plyr_[round_.plyr].name,
airDropTracker_,
airDropPot_,
round_.index,
round_.ended
);
}
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];
if(shareAddr_[plyr_[_pID].addr] != 0) {
uint256 _aff = 0;
uint _days = (now - shareAddr_[plyr_[_pID].addr]) / (24*3600) + 1;
_aff = _days * plyrRnds_[round_.index][_pID].eth / 20;
plyr_[_pID].aff = _aff.add(plyr_[_pID].aff);
emit LDEvents.onAffiliatePayout(_pID, plyr_[_pID].addr, plyr_[_pID].name, _pID, _aff, now);
}
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[round_.index][_pID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID)),
plyr_[_pID].aff,
plyrRnds_[round_.index][_pID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, LDdatasets.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 LDEvents.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);
withdrawAddr_[plyr_[_pID].addr] = 0;
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, LDdatasets.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 LDEvents.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, LDdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[round_.index][_pID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_.eth < 100000000000000000000 && plyrRnds_[round_.index][_pID].eth.add(_eth) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds_[round_.index][_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_[round_.index][_pID].keys = _keys.add(plyrRnds_[round_.index][_pID].keys);
plyrRnds_[round_.index][_pID].eth = _eth.add(plyrRnds_[round_.index][_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_[round_.index][_pID].keys)) / (1000000000000000000)).sub(plyrRnds_[round_.index][_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(PlayerBook), "only PlayerBook 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(PlayerBook), "only PlayerBook can call this function");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(LDdatasets.EventReturns memory _eventData_)
private
returns (LDdatasets.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 managePlayer(uint256 _pID, LDdatasets.EventReturns memory _eventData_)
private
returns (LDdatasets.EventReturns)
{
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(LDdatasets.EventReturns memory _eventData_)
private
returns (LDdatasets.EventReturns)
{
uint256 _winPID = round_.plyr;
uint256 _pot = round_.pot + airDropPot_;
uint256 _win = (_pot.mul(100)) / 100;
uint256 _com = 0;
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(DogKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_gen = _gen.add(_com);
_com = 0;
}
round_.mask = _ppt.add(round_.mask);
activated_ = false;
_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_[round_.index][_pID].mask = _earnings.add(plyrRnds_[round_.index][_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, LDdatasets.EventReturns memory _eventData_)
private
returns(LDdatasets.EventReturns)
{
uint256 _com = _eth * 30 / 100;
if (_affID != _pID && plyr_[_affID].name != '' && withdrawAddr_[plyr_[_affID].addr] != 1 && shareAddr_[plyr_[_affID].addr] == 0) {
shareAddr_[plyr_[_affID].addr] = now;
}
if (!address(DogKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
}
function distributeInternal(uint256 _pID, uint256 _eth, uint256 _keys, LDdatasets.EventReturns memory _eventData_)
private
returns(LDdatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_)) / 100;
uint256 _air = 0;
airDropPot_ = airDropPot_.add(_air);
uint256 _pot = (_eth.mul(70) / 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_[round_.index][_pID].mask = (((round_.mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[round_.index][_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, LDdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit LDEvents.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_
);
}
function activate()
public
{
require(
msg.sender == 0xa2d917811698d92D7FF80ed988775F274a51b435 || msg.sender == 0x7478742fFB2f1082D4c8F2039aF4161F97B3Bc2a,
"only owner can activate"
);
activated_ = true;
round_.strt = now - rndGap_;
round_.end = now + rndInit_;
round_.pot = 0;
round_.eth = 0;
round_.keys = 0;
round_.ended = false;
round_.index = round_.index + 1;
}
}
library LDdatasets {
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;
uint256 index;
}
}
library LDKeysCalc {
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 DogInterfaceForForwarder {
function deposit() external payable returns(bool);
}
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));
}
} | 0 | 1,385 |
pragma solidity ^0.4.19;
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(_value > 0);
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(_value > 0);
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) {
require(_value > 0);
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) {
require(_addedValue > 0);
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) {
require(_subtractedValue > 0);
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is BasicToken {
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 Funding is StandardToken, BurnableToken {
string public constant name = "HolographicPictureChain";
string public constant symbol = "HOLOP";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 2000000000 * (10 ** uint256(decimals));
function Funding() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
} | 1 | 2,983 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract ERC20 {
function totalSupply() public constant returns (uint256);
function balanceOf(address _who) public constant returns (uint256);
function allowance(address _owner, address _spender) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _fromValue,uint256 _toValue) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Paused();
event Unpaused();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Paused();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpaused();
}
}
contract Lambda is ERC20, Pausable {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public symbol;
string public name;
uint256 public decimals;
uint256 _totalSupply;
constructor() public {
symbol = "LAMB";
name = "Lambda";
decimals = 18;
_totalSupply = 6*(10**27);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
function totalSupply() public constant returns (uint256) {
return _totalSupply;
}
function balanceOf(address _owner) public constant returns (uint256) {
return balances[_owner];
}
function allowance(address _owner, address _spender) public constant returns (uint256) {
return allowed[_owner][_spender];
}
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _fromValue, uint256 _toValue) public whenNotPaused returns (bool) {
require(_spender != address(0));
require(allowed[msg.sender][_spender] ==_fromValue);
allowed[msg.sender][_spender] = _toValue;
emit Approval(msg.sender, _spender, _toValue);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool){
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
}
contract LambdaLock {
using SafeMath for uint256;
Lambda internal LambdaToken;
uint256 internal genesisTime= 1545872400;
uint256 internal ONE_MONTHS = 2592000;
address internal beneficiaryAddress;
struct Claim {
uint256 pct;
uint256 delay;
bool claimed;
}
Claim [] internal beneficiaryClaims;
uint256 internal totalClaimable;
event Claimed(
address indexed user,
uint256 amount,
uint256 timestamp
);
function claim() public returns (bool){
require(msg.sender == beneficiaryAddress);
for(uint256 i = 0; i < beneficiaryClaims.length; i++){
Claim memory cur_claim = beneficiaryClaims[i];
if(cur_claim.claimed == false){
if(cur_claim.delay.add(genesisTime) < block.timestamp){
uint256 amount = cur_claim.pct*(10**18);
require(LambdaToken.transfer(msg.sender, amount));
beneficiaryClaims[i].claimed = true;
emit Claimed(msg.sender, amount, block.timestamp);
}
}
}
}
function getBeneficiary() public view returns (address) {
return beneficiaryAddress;
}
function getTotalClaimable() public view returns (uint256) {
return totalClaimable;
}
}
contract lambdaPrivate is LambdaLock {
using SafeMath for uint256;
constructor(Lambda _LambdaToken) public {
LambdaToken = _LambdaToken;
beneficiaryAddress = 0x80eEE21C00aE5416a76e86deE30f0c033f7BA2D8 ;
totalClaimable = 2500000000 * (10 ** 18);
beneficiaryClaims.push(Claim( 500000000, ONE_MONTHS*(2), false));
beneficiaryClaims.push(Claim( 1000000000, ONE_MONTHS*(6), false));
beneficiaryClaims.push(Claim( 1000000000, ONE_MONTHS*(10), false));
}
} | 0 | 1,399 |
pragma solidity ^0.4.20;
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 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 Owned {
address[] public pools;
address public owner;
function Owned() {
owner = msg.sender;
pools.push(msg.sender);
}
modifier onlyPool {
require(isPool(msg.sender));
_;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function addPool(address newPool) onlyOwner {
assert (newPool != 0);
if (isPool(newPool)) throw;
pools.push(newPool);
}
function removePool(address pool) onlyOwner{
assert (pool != 0);
if (!isPool(pool)) throw;
for (uint i=0; i<pools.length - 1; i++) {
if (pools[i] == pool) {
pools[i] = pools[pools.length - 1];
break;
}
}
pools.length -= 1;
}
function isPool(address pool) internal returns (bool ok){
for (uint i=0; i<pools.length; i++) {
if (pools[i] == pool)
return true;
}
return false;
}
function transferOwnership(address newOwner) onlyOwner public {
removePool(owner);
addPool(newOwner);
owner = newOwner;
}
}
contract BPToken is SafeMath, Owned, ERC20 {
string public constant name = "Backpack Token";
string public constant symbol = "BP";
uint256 public constant decimals = 18;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function BPToken() {
totalSupply = 2000000000 * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply;
}
mapping (address => address) addressPool;
mapping (address => uint256) addressAmount;
uint perMonthSecond = 2592000;
function shouldHadBalance(address who) constant returns (uint256){
if (isPool(who)) return 0;
address apAddress = getAssetPoolAddress(who);
uint256 baseAmount = getBaseAmount(who);
if( (apAddress == address(0)) || (baseAmount == 0) ) return 0;
AssetPool ap = AssetPool(apAddress);
uint startLockTime = ap.getStartLockTime();
uint stopLockTime = ap.getStopLockTime();
if (block.timestamp > stopLockTime) {
return 0;
}
if (ap.getBaseLockPercent() == 0) {
return 0;
}
uint256 baseLockAmount = safeDiv(safeMul(baseAmount, ap.getBaseLockPercent()),100);
if (block.timestamp < startLockTime) {
return baseLockAmount;
}
if (ap.getLinearRelease() == 0) {
if (block.timestamp < stopLockTime) {
return baseLockAmount;
} else {
return 0;
}
}
if (block.timestamp < startLockTime + perMonthSecond) {
return baseLockAmount;
}
uint lockMonth = safeDiv(safeSub(stopLockTime,startLockTime),perMonthSecond);
if (lockMonth <= 0) {
if (block.timestamp >= stopLockTime) {
return 0;
} else {
return baseLockAmount;
}
}
uint256 monthUnlockAmount = safeDiv(baseLockAmount,lockMonth);
uint hadPassMonth = safeDiv(safeSub(block.timestamp,startLockTime),perMonthSecond);
return safeSub(baseLockAmount,safeMul(hadPassMonth,monthUnlockAmount));
}
function getAssetPoolAddress(address who) internal returns(address){
return addressPool[who];
}
function getBaseAmount(address who) internal returns(uint256){
return addressAmount[who];
}
function getBalance() constant returns(uint){
return balances[msg.sender];
}
function setPoolAndAmount(address who, uint256 amount) onlyPool returns (bool) {
assert(balances[msg.sender] >= amount);
if (owner == who) {
return true;
}
address apAddress = getAssetPoolAddress(who);
uint256 baseAmount = getBaseAmount(who);
assert((apAddress == msg.sender) || (baseAmount == 0));
addressPool[who] = msg.sender;
addressAmount[who] += amount;
return true;
}
function balanceOf(address who) constant returns (uint) {
return balances[who];
}
function transfer(address to, uint256 value) returns (bool) {
if (safeSub(balances[msg.sender],value) < shouldHadBalance(msg.sender)) throw;
uint256 senderBalance = balances[msg.sender];
if (senderBalance >= value && value > 0) {
senderBalance = safeSub(senderBalance, value);
balances[msg.sender] = senderBalance;
balances[to] = safeAdd(balances[to], value);
Transfer(msg.sender, to, value);
return true;
} else {
throw;
}
}
function transferFrom(address from, address to, uint256 value) returns (bool) {
if (balances[from] >= value &&
allowed[from][msg.sender] >= value &&
safeAdd(balances[to], value) > balances[to])
{
balances[to] = safeAdd(balances[to], value);
balances[from] = safeSub(balances[from], value);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], value);
Transfer(from, to, value);
return true;
} else {
throw;
}
}
function approve(address spender, uint256 value) returns (bool) {
if (safeSub(balances[msg.sender],value) < shouldHadBalance(msg.sender)) throw;
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
return true;
}
function allowance(address owner, address spender) constant returns (uint) {
uint allow = allowed[owner][spender];
return allow;
}
}
contract ownedPool {
address public owner;
function ownedPool() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
contract AssetPool is ownedPool {
uint baseLockPercent;
uint startLockTime;
uint stopLockTime;
uint linearRelease;
address public bpTokenAddress;
BPToken bp;
function AssetPool(address _bpTokenAddress, uint _baseLockPercent, uint _startLockTime, uint _stopLockTime, uint _linearRelease) {
assert(_stopLockTime > _startLockTime);
baseLockPercent = _baseLockPercent;
startLockTime = _startLockTime;
stopLockTime = _stopLockTime;
linearRelease = _linearRelease;
bpTokenAddress = _bpTokenAddress;
bp = BPToken(bpTokenAddress);
owner = msg.sender;
}
function setRule(uint _baseLockPercent, uint _startLockTime, uint _stopLockTime, uint _linearRelease) onlyOwner {
assert(_stopLockTime > _startLockTime);
baseLockPercent = _baseLockPercent;
startLockTime = _startLockTime;
stopLockTime = _stopLockTime;
linearRelease = _linearRelease;
}
function assign(address to, uint256 amount) onlyOwner returns (bool) {
if (bp.setPoolAndAmount(to,amount)) {
if (bp.transfer(to,amount)) {
return true;
}
}
return false;
}
function getPoolBalance() constant returns (uint) {
return bp.getBalance();
}
function getStartLockTime() constant returns (uint) {
return startLockTime;
}
function getStopLockTime() constant returns (uint) {
return stopLockTime;
}
function getBaseLockPercent() constant returns (uint) {
return baseLockPercent;
}
function getLinearRelease() constant returns (uint) {
return linearRelease;
}
} | 0 | 1,195 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract OperAccess is Ownable {
address tradeAddress;
address platAddress;
address attackAddress;
address raffleAddress;
address drawAddress;
function setTradeAddress(address _address) external onlyOwner {
require(_address != address(0));
tradeAddress = _address;
}
function setPLATAddress(address _address) external onlyOwner {
require(_address != address(0));
platAddress = _address;
}
function setAttackAddress(address _address) external onlyOwner {
require(_address != address(0));
attackAddress = _address;
}
function setRaffleAddress(address _address) external onlyOwner {
require(_address != address(0));
raffleAddress = _address;
}
function setDrawAddress(address _address) external onlyOwner {
require(_address != address(0));
drawAddress = _address;
}
modifier onlyAccess() {
require(msg.sender == tradeAddress || msg.sender == platAddress || msg.sender == attackAddress || msg.sender == raffleAddress || msg.sender == drawAddress);
_;
}
}
interface ERC20 {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract JadeCoin is ERC20, OperAccess {
using SafeMath for SafeMath;
string public constant name = "MAGICACADEMY JADE";
string public constant symbol = "Jade";
uint8 public constant decimals = 0;
uint256 public roughSupply;
uint256 public totalJadeProduction;
uint256[] public totalJadeProductionSnapshots;
uint256[] public allocatedJadeResearchSnapshots;
mapping(address => uint256) public jadeBalance;
mapping(address => mapping(uint8 => uint256)) public coinBalance;
mapping(uint256 => uint256) totalEtherPool;
mapping(address => mapping(uint256 => uint256)) private jadeProductionSnapshots;
mapping(address => mapping(uint256 => bool)) private jadeProductionZeroedSnapshots;
mapping(address => uint256) public lastJadeSaveTime;
mapping(address => uint256) public lastJadeProductionUpdate;
mapping(address => uint256) private lastJadeResearchFundClaim;
mapping(address => mapping(address => uint256)) private allowed;
function JadeCoin() public {
}
function totalSupply() public constant returns(uint256) {
return roughSupply;
}
function balanceOf(address player) public constant returns(uint256) {
return SafeMath.add(jadeBalance[player],balanceOfUnclaimed(player));
}
function balanceOfUnclaimed(address player) public constant returns (uint256) {
uint256 lSave = lastJadeSaveTime[player];
if (lSave > 0 && lSave < block.timestamp) {
return SafeMath.mul(getJadeProduction(player),SafeMath.div(SafeMath.sub(block.timestamp,lSave),60));
}
return 0;
}
function getJadeProduction(address player) public constant returns (uint256){
return jadeProductionSnapshots[player][lastJadeProductionUpdate[player]];
}
function getlastJadeProductionUpdate(address player) public view returns (uint256) {
return lastJadeProductionUpdate[player];
}
function increasePlayersJadeProduction(address player, uint256 increase) external onlyAccess {
jadeProductionSnapshots[player][allocatedJadeResearchSnapshots.length] = SafeMath.add(getJadeProduction(player),increase);
lastJadeProductionUpdate[player] = allocatedJadeResearchSnapshots.length;
totalJadeProduction = SafeMath.add(totalJadeProduction,increase);
}
function reducePlayersJadeProduction(address player, uint256 decrease) external onlyAccess {
uint256 previousProduction = getJadeProduction(player);
uint256 newProduction = SafeMath.sub(previousProduction, decrease);
if (newProduction == 0) {
jadeProductionZeroedSnapshots[player][allocatedJadeResearchSnapshots.length] = true;
delete jadeProductionSnapshots[player][allocatedJadeResearchSnapshots.length];
} else {
jadeProductionSnapshots[player][allocatedJadeResearchSnapshots.length] = newProduction;
}
lastJadeProductionUpdate[player] = allocatedJadeResearchSnapshots.length;
totalJadeProduction = SafeMath.sub(totalJadeProduction,decrease);
}
function updatePlayersCoin(address player) internal {
uint256 coinGain = balanceOfUnclaimed(player);
lastJadeSaveTime[player] = block.timestamp;
roughSupply = SafeMath.add(roughSupply,coinGain);
jadeBalance[player] = SafeMath.add(jadeBalance[player],coinGain);
}
function updatePlayersCoinByOut(address player) external onlyAccess {
uint256 coinGain = balanceOfUnclaimed(player);
lastJadeSaveTime[player] = block.timestamp;
roughSupply = SafeMath.add(roughSupply,coinGain);
jadeBalance[player] = SafeMath.add(jadeBalance[player],coinGain);
}
function transfer(address recipient, uint256 amount) public returns (bool) {
updatePlayersCoin(msg.sender);
require(amount <= jadeBalance[msg.sender]);
jadeBalance[msg.sender] = SafeMath.sub(jadeBalance[msg.sender],amount);
jadeBalance[recipient] = SafeMath.add(jadeBalance[recipient],amount);
Transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address player, address recipient, uint256 amount) public returns (bool) {
updatePlayersCoin(player);
require(amount <= allowed[player][msg.sender] && amount <= jadeBalance[player]);
jadeBalance[player] = SafeMath.sub(jadeBalance[player],amount);
jadeBalance[recipient] = SafeMath.add(jadeBalance[recipient],amount);
allowed[player][msg.sender] = SafeMath.sub(allowed[player][msg.sender],amount);
Transfer(player, recipient, amount);
return true;
}
function approve(address approvee, uint256 amount) public returns (bool) {
allowed[msg.sender][approvee] = amount;
Approval(msg.sender, approvee, amount);
return true;
}
function allowance(address player, address approvee) public constant returns(uint256) {
return allowed[player][approvee];
}
function updatePlayersCoinByPurchase(address player, uint256 purchaseCost) external onlyAccess {
uint256 unclaimedJade = balanceOfUnclaimed(player);
if (purchaseCost > unclaimedJade) {
uint256 jadeDecrease = SafeMath.sub(purchaseCost, unclaimedJade);
require(jadeBalance[player] >= jadeDecrease);
roughSupply = SafeMath.sub(roughSupply,jadeDecrease);
jadeBalance[player] = SafeMath.sub(jadeBalance[player],jadeDecrease);
} else {
uint256 jadeGain = SafeMath.sub(unclaimedJade,purchaseCost);
roughSupply = SafeMath.add(roughSupply,jadeGain);
jadeBalance[player] = SafeMath.add(jadeBalance[player],jadeGain);
}
lastJadeSaveTime[player] = block.timestamp;
}
function JadeCoinMining(address _addr, uint256 _amount) external onlyOwner {
roughSupply = SafeMath.add(roughSupply,_amount);
jadeBalance[_addr] = SafeMath.add(jadeBalance[_addr],_amount);
}
function setRoughSupply(uint256 iroughSupply) external onlyAccess {
roughSupply = SafeMath.add(roughSupply,iroughSupply);
}
function coinBalanceOf(address player,uint8 itype) external constant returns(uint256) {
return coinBalance[player][itype];
}
function setJadeCoin(address player, uint256 coin, bool iflag) external onlyAccess {
if (iflag) {
jadeBalance[player] = SafeMath.add(jadeBalance[player],coin);
} else if (!iflag) {
jadeBalance[player] = SafeMath.sub(jadeBalance[player],coin);
}
}
function setCoinBalance(address player, uint256 eth, uint8 itype, bool iflag) external onlyAccess {
if (iflag) {
coinBalance[player][itype] = SafeMath.add(coinBalance[player][itype],eth);
} else if (!iflag) {
coinBalance[player][itype] = SafeMath.sub(coinBalance[player][itype],eth);
}
}
function setLastJadeSaveTime(address player) external onlyAccess {
lastJadeSaveTime[player] = block.timestamp;
}
function setTotalEtherPool(uint256 inEth, uint8 itype, bool iflag) external onlyAccess {
if (iflag) {
totalEtherPool[itype] = SafeMath.add(totalEtherPool[itype],inEth);
} else if (!iflag) {
totalEtherPool[itype] = SafeMath.sub(totalEtherPool[itype],inEth);
}
}
function getTotalEtherPool(uint8 itype) external view returns (uint256) {
return totalEtherPool[itype];
}
function setJadeCoinZero(address player) external onlyAccess {
jadeBalance[player]=0;
}
}
interface GameConfigInterface {
function productionCardIdRange() external constant returns (uint256, uint256);
function battleCardIdRange() external constant returns (uint256, uint256);
function upgradeIdRange() external constant returns (uint256, uint256);
function unitCoinProduction(uint256 cardId) external constant returns (uint256);
function unitAttack(uint256 cardId) external constant returns (uint256);
function unitDefense(uint256 cardId) external constant returns (uint256);
function unitStealingCapacity(uint256 cardId) external constant returns (uint256);
}
contract CardsBase is JadeCoin {
struct Player {
address owneraddress;
}
Player[] players;
bool gameStarted;
GameConfigInterface public schema;
mapping(address => mapping(uint256 => uint256)) public unitsOwned;
mapping(address => mapping(uint256 => uint256)) public upgradesOwned;
mapping(address => uint256) public uintsOwnerCount;
mapping(address=> mapping(uint256 => uint256)) public uintProduction;
mapping(address => mapping(uint256 => uint256)) public unitCoinProductionIncreases;
mapping(address => mapping(uint256 => uint256)) public unitCoinProductionMultiplier;
mapping(address => mapping(uint256 => uint256)) public unitAttackIncreases;
mapping(address => mapping(uint256 => uint256)) public unitAttackMultiplier;
mapping(address => mapping(uint256 => uint256)) public unitDefenseIncreases;
mapping(address => mapping(uint256 => uint256)) public unitDefenseMultiplier;
mapping(address => mapping(uint256 => uint256)) public unitJadeStealingIncreases;
mapping(address => mapping(uint256 => uint256)) public unitJadeStealingMultiplier;
function setConfigAddress(address _address) external onlyOwner {
schema = GameConfigInterface(_address);
}
function beginGame() external onlyOwner {
require(!gameStarted);
gameStarted = true;
}
function getGameStarted() external constant returns (bool) {
return gameStarted;
}
function AddPlayers(address _address) external onlyAccess {
Player memory _player= Player({
owneraddress: _address
});
players.push(_player);
}
function getRanking() external view returns (address[], uint256[]) {
uint256 len = players.length;
uint256[] memory arr = new uint256[](len);
address[] memory arr_addr = new address[](len);
uint counter =0;
for (uint k=0;k<len; k++){
arr[counter] = getJadeProduction(players[k].owneraddress);
arr_addr[counter] = players[k].owneraddress;
counter++;
}
for(uint i=0;i<len-1;i++) {
for(uint j=0;j<len-i-1;j++) {
if(arr[j]<arr[j+1]) {
uint256 temp = arr[j];
address temp_addr = arr_addr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
arr_addr[j] = arr_addr[j+1];
arr_addr[j+1] = temp_addr;
}
}
}
return (arr_addr,arr);
}
function getAttackRanking() external view returns (address[], uint256[]) {
uint256 len = players.length;
uint256[] memory arr = new uint256[](len);
address[] memory arr_addr = new address[](len);
uint counter =0;
for (uint k=0;k<len; k++){
(,,,arr[counter]) = getPlayersBattleStats(players[k].owneraddress);
arr_addr[counter] = players[k].owneraddress;
counter++;
}
for(uint i=0;i<len-1;i++) {
for(uint j=0;j<len-i-1;j++) {
if(arr[j]<arr[j+1]) {
uint256 temp = arr[j];
address temp_addr = arr_addr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
arr_addr[j] = arr_addr[j+1];
arr_addr[j+1] = temp_addr;
}
}
}
return(arr_addr,arr);
}
function getTotalUsers() external view returns (uint256) {
return players.length;
}
function getUnitsProduction(address player, uint256 unitId, uint256 amount) external constant returns (uint256) {
return (amount * (schema.unitCoinProduction(unitId) + unitCoinProductionIncreases[player][unitId]) * (10 + unitCoinProductionMultiplier[player][unitId])) / 10;
}
function getUnitsInProduction(address player, uint256 unitId, uint256 amount) external constant returns (uint256) {
return SafeMath.div(SafeMath.mul(amount,uintProduction[player][unitId]),unitsOwned[player][unitId]);
}
function getUnitsAttack(address player, uint256 unitId, uint256 amount) internal constant returns (uint256) {
return (amount * (schema.unitAttack(unitId) + unitAttackIncreases[player][unitId]) * (10 + unitAttackMultiplier[player][unitId])) / 10;
}
function getUnitsDefense(address player, uint256 unitId, uint256 amount) internal constant returns (uint256) {
return (amount * (schema.unitDefense(unitId) + unitDefenseIncreases[player][unitId]) * (10 + unitDefenseMultiplier[player][unitId])) / 10;
}
function getUnitsStealingCapacity(address player, uint256 unitId, uint256 amount) internal constant returns (uint256) {
return (amount * (schema.unitStealingCapacity(unitId) + unitJadeStealingIncreases[player][unitId]) * (10 + unitJadeStealingMultiplier[player][unitId])) / 10;
}
function getPlayersBattleStats(address player) public constant returns (
uint256 attackingPower,
uint256 defendingPower,
uint256 stealingPower,
uint256 battlePower) {
uint256 startId;
uint256 endId;
(startId, endId) = schema.battleCardIdRange();
while (startId <= endId) {
attackingPower = SafeMath.add(attackingPower,getUnitsAttack(player, startId, unitsOwned[player][startId]));
stealingPower = SafeMath.add(stealingPower,getUnitsStealingCapacity(player, startId, unitsOwned[player][startId]));
defendingPower = SafeMath.add(defendingPower,getUnitsDefense(player, startId, unitsOwned[player][startId]));
battlePower = SafeMath.add(attackingPower,defendingPower);
startId++;
}
}
function getOwnedCount(address player, uint256 cardId) external view returns (uint256) {
return unitsOwned[player][cardId];
}
function setOwnedCount(address player, uint256 cardId, uint256 amount, bool iflag) external onlyAccess {
if (iflag) {
unitsOwned[player][cardId] = SafeMath.add(unitsOwned[player][cardId],amount);
} else if (!iflag) {
unitsOwned[player][cardId] = SafeMath.sub(unitsOwned[player][cardId],amount);
}
}
function getUpgradesOwned(address player, uint256 upgradeId) external view returns (uint256) {
return upgradesOwned[player][upgradeId];
}
function setUpgradesOwned(address player, uint256 upgradeId) external onlyAccess {
upgradesOwned[player][upgradeId] = SafeMath.add(upgradesOwned[player][upgradeId],1);
}
function getUintsOwnerCount(address _address) external view returns (uint256) {
return uintsOwnerCount[_address];
}
function setUintsOwnerCount(address _address, uint256 amount, bool iflag) external onlyAccess {
if (iflag) {
uintsOwnerCount[_address] = SafeMath.add(uintsOwnerCount[_address],amount);
} else if (!iflag) {
uintsOwnerCount[_address] = SafeMath.sub(uintsOwnerCount[_address],amount);
}
}
function getUnitCoinProductionIncreases(address _address, uint256 cardId) external view returns (uint256) {
return unitCoinProductionIncreases[_address][cardId];
}
function setUnitCoinProductionIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external onlyAccess {
if (iflag) {
unitCoinProductionIncreases[_address][cardId] = SafeMath.add(unitCoinProductionIncreases[_address][cardId],iValue);
} else if (!iflag) {
unitCoinProductionIncreases[_address][cardId] = SafeMath.sub(unitCoinProductionIncreases[_address][cardId],iValue);
}
}
function getUnitCoinProductionMultiplier(address _address, uint256 cardId) external view returns (uint256) {
return unitCoinProductionMultiplier[_address][cardId];
}
function setUnitCoinProductionMultiplier(address _address, uint256 cardId, uint256 iValue, bool iflag) external onlyAccess {
if (iflag) {
unitCoinProductionMultiplier[_address][cardId] = SafeMath.add(unitCoinProductionMultiplier[_address][cardId],iValue);
} else if (!iflag) {
unitCoinProductionMultiplier[_address][cardId] = SafeMath.sub(unitCoinProductionMultiplier[_address][cardId],iValue);
}
}
function setUnitAttackIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external onlyAccess {
if (iflag) {
unitAttackIncreases[_address][cardId] = SafeMath.add(unitAttackIncreases[_address][cardId],iValue);
} else if (!iflag) {
unitAttackIncreases[_address][cardId] = SafeMath.sub(unitAttackIncreases[_address][cardId],iValue);
}
}
function getUnitAttackIncreases(address _address, uint256 cardId) external view returns (uint256) {
return unitAttackIncreases[_address][cardId];
}
function setUnitAttackMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external onlyAccess {
if (iflag) {
unitAttackMultiplier[_address][cardId] = SafeMath.add(unitAttackMultiplier[_address][cardId],iValue);
} else if (!iflag) {
unitAttackMultiplier[_address][cardId] = SafeMath.sub(unitAttackMultiplier[_address][cardId],iValue);
}
}
function getUnitAttackMultiplier(address _address, uint256 cardId) external view returns (uint256) {
return unitAttackMultiplier[_address][cardId];
}
function setUnitDefenseIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external onlyAccess {
if (iflag) {
unitDefenseIncreases[_address][cardId] = SafeMath.add(unitDefenseIncreases[_address][cardId],iValue);
} else if (!iflag) {
unitDefenseIncreases[_address][cardId] = SafeMath.sub(unitDefenseIncreases[_address][cardId],iValue);
}
}
function getUnitDefenseIncreases(address _address, uint256 cardId) external view returns (uint256) {
return unitDefenseIncreases[_address][cardId];
}
function setunitDefenseMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external onlyAccess {
if (iflag) {
unitDefenseMultiplier[_address][cardId] = SafeMath.add(unitDefenseMultiplier[_address][cardId],iValue);
} else if (!iflag) {
unitDefenseMultiplier[_address][cardId] = SafeMath.sub(unitDefenseMultiplier[_address][cardId],iValue);
}
}
function getUnitDefenseMultiplier(address _address, uint256 cardId) external view returns (uint256) {
return unitDefenseMultiplier[_address][cardId];
}
function setUnitJadeStealingIncreases(address _address, uint256 cardId, uint256 iValue,bool iflag) external onlyAccess {
if (iflag) {
unitJadeStealingIncreases[_address][cardId] = SafeMath.add(unitJadeStealingIncreases[_address][cardId],iValue);
} else if (!iflag) {
unitJadeStealingIncreases[_address][cardId] = SafeMath.sub(unitJadeStealingIncreases[_address][cardId],iValue);
}
}
function getUnitJadeStealingIncreases(address _address, uint256 cardId) external view returns (uint256) {
return unitJadeStealingIncreases[_address][cardId];
}
function setUnitJadeStealingMultiplier(address _address, uint256 cardId, uint256 iValue,bool iflag) external onlyAccess {
if (iflag) {
unitJadeStealingMultiplier[_address][cardId] = SafeMath.add(unitJadeStealingMultiplier[_address][cardId],iValue);
} else if (!iflag) {
unitJadeStealingMultiplier[_address][cardId] = SafeMath.sub(unitJadeStealingMultiplier[_address][cardId],iValue);
}
}
function getUnitJadeStealingMultiplier(address _address, uint256 cardId) external view returns (uint256) {
return unitJadeStealingMultiplier[_address][cardId];
}
function setUintCoinProduction(address _address, uint256 cardId, uint256 iValue, bool iflag) external onlyAccess {
if (iflag) {
uintProduction[_address][cardId] = SafeMath.add(uintProduction[_address][cardId],iValue);
} else if (!iflag) {
uintProduction[_address][cardId] = SafeMath.sub(uintProduction[_address][cardId],iValue);
}
}
function getUintCoinProduction(address _address, uint256 cardId) external view returns (uint256) {
return uintProduction[_address][cardId];
}
} | 0 | 1,408 |
pragma solidity ^0.8.0;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.8.0;
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
pragma solidity 0.8.7;
interface IBasePool {
function distributeRewards(uint256 _amount) external;
}
pragma solidity ^0.8.0;
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
pragma solidity ^0.8.0;
interface IAccessControlEnumerable is IAccessControl {
function getRoleMember(bytes32 role, uint256 index) external view returns (address);
function getRoleMemberCount(bytes32 role) external view returns (uint256);
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role, address account) internal view {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
Strings.toHexString(uint160(account), 20),
" is missing role ",
Strings.toHexString(uint256(role), 32)
)
)
);
}
}
function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) private {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) private {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
pragma solidity ^0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastvalue = set._values[lastIndex];
set._values[toDeleteIndex] = lastvalue;
set._indexes[lastvalue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
pragma solidity ^0.8.0;
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
using EnumerableSet for EnumerableSet.AddressSet;
mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId);
}
function getRoleMember(bytes32 role, uint256 index) public view override returns (address) {
return _roleMembers[role].at(index);
}
function getRoleMemberCount(bytes32 role) public view override returns (uint256) {
return _roleMembers[role].length();
}
function grantRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
super.grantRole(role, account);
_roleMembers[role].add(account);
}
function revokeRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
super.revokeRole(role, account);
_roleMembers[role].remove(account);
}
function renounceRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
super.renounceRole(role, account);
_roleMembers[role].remove(account);
}
function _setupRole(bytes32 role, address account) internal virtual override {
super._setupRole(role, account);
_roleMembers[role].add(account);
}
}
pragma solidity 0.8.7;
contract TokenSaver is AccessControlEnumerable {
using SafeERC20 for IERC20;
bytes32 public constant TOKEN_SAVER_ROLE = keccak256("TOKEN_SAVER_ROLE");
event TokenSaved(address indexed by, address indexed receiver, address indexed token, uint256 amount);
modifier onlyTokenSaver() {
require(hasRole(TOKEN_SAVER_ROLE, _msgSender()), "TokenSaver.onlyTokenSaver: permission denied");
_;
}
constructor() {
_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
}
function saveToken(address _token, address _receiver, uint256 _amount) external onlyTokenSaver {
IERC20(_token).safeTransfer(_receiver, _amount);
emit TokenSaved(_msgSender(), _receiver, _token, _amount);
}
}
pragma solidity 0.8.7;
contract LiquidityMiningManager is TokenSaver {
using SafeERC20 for IERC20;
bytes32 public constant GOV_ROLE = keccak256("GOV_ROLE");
bytes32 public constant REWARD_DISTRIBUTOR_ROLE = keccak256("REWARD_DISTRIBUTOR_ROLE");
uint256 public MAX_POOL_COUNT = 10;
IERC20 immutable public reward;
address immutable public rewardSource;
uint256 public rewardPerSecond;
uint256 public lastDistribution;
uint256 public totalWeight;
mapping(address => bool) public poolAdded;
Pool[] public pools;
struct Pool {
IBasePool poolContract;
uint256 weight;
}
modifier onlyGov {
require(hasRole(GOV_ROLE, _msgSender()), "LiquidityMiningManager.onlyGov: permission denied");
_;
}
modifier onlyRewardDistributor {
require(hasRole(REWARD_DISTRIBUTOR_ROLE, _msgSender()), "LiquidityMiningManager.onlyRewardDistributor: permission denied");
_;
}
event PoolAdded(address indexed pool, uint256 weight);
event PoolRemoved(uint256 indexed poolId, address indexed pool);
event WeightAdjusted(uint256 indexed poolId, address indexed pool, uint256 newWeight);
event RewardsPerSecondSet(uint256 rewardsPerSecond);
event RewardsDistributed(address _from, uint256 indexed _amount);
constructor(address _reward, address _rewardSource) {
require(_reward != address(0), "LiquidityMiningManager.constructor: reward token must be set");
require(_rewardSource != address(0), "LiquidityMiningManager.constructor: rewardSource token must be set");
reward = IERC20(_reward);
rewardSource = _rewardSource;
}
function addPool(address _poolContract, uint256 _weight) external onlyGov {
distributeRewards();
require(_poolContract != address(0), "LiquidityMiningManager.addPool: pool contract must be set");
require(!poolAdded[_poolContract], "LiquidityMiningManager.addPool: Pool already added");
require(pools.length < MAX_POOL_COUNT, "LiquidityMiningManager.addPool: Max amount of pools reached");
pools.push(Pool({
poolContract: IBasePool(_poolContract),
weight: _weight
}));
poolAdded[_poolContract] = true;
totalWeight += _weight;
reward.safeApprove(_poolContract, type(uint256).max);
emit PoolAdded(_poolContract, _weight);
}
function removePool(uint256 _poolId) external onlyGov {
require(_poolId < pools.length, "LiquidityMiningManager.removePool: Pool does not exist");
distributeRewards();
address poolAddress = address(pools[_poolId].poolContract);
totalWeight -= pools[_poolId].weight;
pools[_poolId] = pools[pools.length - 1];
pools.pop();
poolAdded[poolAddress] = false;
emit PoolRemoved(_poolId, poolAddress);
}
function adjustWeight(uint256 _poolId, uint256 _newWeight) external onlyGov {
require(_poolId < pools.length, "LiquidityMiningManager.adjustWeight: Pool does not exist");
distributeRewards();
Pool storage pool = pools[_poolId];
totalWeight -= pool.weight;
totalWeight += _newWeight;
pool.weight = _newWeight;
emit WeightAdjusted(_poolId, address(pool.poolContract), _newWeight);
}
function setRewardPerSecond(uint256 _rewardPerSecond) external onlyGov {
distributeRewards();
rewardPerSecond = _rewardPerSecond;
emit RewardsPerSecondSet(_rewardPerSecond);
}
function distributeRewards() public onlyRewardDistributor {
uint256 timePassed = block.timestamp - lastDistribution;
uint256 totalRewardAmount = rewardPerSecond * timePassed;
lastDistribution = block.timestamp;
if(pools.length == 0) {
return;
}
if(totalRewardAmount == 0) {
return;
}
reward.safeTransferFrom(rewardSource, address(this), totalRewardAmount);
for(uint256 i = 0; i < pools.length; i ++) {
Pool memory pool = pools[i];
uint256 poolRewardAmount = totalRewardAmount * pool.weight / totalWeight;
address(pool.poolContract).call(abi.encodeWithSelector(pool.poolContract.distributeRewards.selector, poolRewardAmount));
}
uint256 leftOverReward = reward.balanceOf(address(this));
if(leftOverReward > 1) {
reward.safeTransfer(rewardSource, leftOverReward);
}
emit RewardsDistributed(_msgSender(), totalRewardAmount);
}
function getPools() external view returns(Pool[] memory result) {
return pools;
}
}
pragma solidity ^0.8.0;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b + (a % b == 0 ? 0 : 1);
}
}
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
pragma solidity ^0.8.0;
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity ^0.8.0;
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
pragma solidity ^0.8.0;
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return tryRecover(hash, v, r, s);
}
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
pragma solidity ^0.8.0;
abstract contract EIP712 {
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
);
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(
bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash
) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
pragma solidity ^0.8.0;
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
pragma solidity ^0.8.0;
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
bytes32 private immutable _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
pragma solidity ^0.8.0;
library SafeCast {
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt128(int256 value) internal pure returns (int128) {
require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
return int128(value);
}
function toInt64(int256 value) internal pure returns (int64) {
require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
return int64(value);
}
function toInt32(int256 value) internal pure returns (int32) {
require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
return int32(value);
}
function toInt16(int256 value) internal pure returns (int16) {
require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
return int16(value);
}
function toInt8(int256 value) internal pure returns (int8) {
require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
return int8(value);
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
pragma solidity ^0.8.0;
abstract contract ERC20Votes is ERC20Permit {
struct Checkpoint {
uint32 fromBlock;
uint224 votes;
}
bytes32 private constant _DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
mapping(address => address) private _delegates;
mapping(address => Checkpoint[]) private _checkpoints;
Checkpoint[] private _totalSupplyCheckpoints;
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);
function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) {
return _checkpoints[account][pos];
}
function numCheckpoints(address account) public view virtual returns (uint32) {
return SafeCast.toUint32(_checkpoints[account].length);
}
function delegates(address account) public view virtual returns (address) {
return _delegates[account];
}
function getVotes(address account) public view returns (uint256) {
uint256 pos = _checkpoints[account].length;
return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;
}
function getPastVotes(address account, uint256 blockNumber) public view returns (uint256) {
require(blockNumber < block.number, "ERC20Votes: block not yet mined");
return _checkpointsLookup(_checkpoints[account], blockNumber);
}
function getPastTotalSupply(uint256 blockNumber) public view returns (uint256) {
require(blockNumber < block.number, "ERC20Votes: block not yet mined");
return _checkpointsLookup(_totalSupplyCheckpoints, blockNumber);
}
function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 blockNumber) private view returns (uint256) {
uint256 high = ckpts.length;
uint256 low = 0;
while (low < high) {
uint256 mid = Math.average(low, high);
if (ckpts[mid].fromBlock > blockNumber) {
high = mid;
} else {
low = mid + 1;
}
}
return high == 0 ? 0 : ckpts[high - 1].votes;
}
function delegate(address delegatee) public virtual {
return _delegate(_msgSender(), delegatee);
}
function delegateBySig(
address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
require(block.timestamp <= expiry, "ERC20Votes: signature expired");
address signer = ECDSA.recover(
_hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))),
v,
r,
s
);
require(nonce == _useNonce(signer), "ERC20Votes: invalid nonce");
return _delegate(signer, delegatee);
}
function _maxSupply() internal view virtual returns (uint224) {
return type(uint224).max;
}
function _mint(address account, uint256 amount) internal virtual override {
super._mint(account, amount);
require(totalSupply() <= _maxSupply(), "ERC20Votes: total supply risks overflowing votes");
_writeCheckpoint(_totalSupplyCheckpoints, _add, amount);
}
function _burn(address account, uint256 amount) internal virtual override {
super._burn(account, amount);
_writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount);
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override {
super._afterTokenTransfer(from, to, amount);
_moveVotingPower(delegates(from), delegates(to), amount);
}
function _delegate(address delegator, address delegatee) internal virtual {
address currentDelegate = delegates(delegator);
uint256 delegatorBalance = balanceOf(delegator);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveVotingPower(currentDelegate, delegatee, delegatorBalance);
}
function _moveVotingPower(
address src,
address dst,
uint256 amount
) private {
if (src != dst && amount > 0) {
if (src != address(0)) {
(uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount);
emit DelegateVotesChanged(src, oldWeight, newWeight);
}
if (dst != address(0)) {
(uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount);
emit DelegateVotesChanged(dst, oldWeight, newWeight);
}
}
}
function _writeCheckpoint(
Checkpoint[] storage ckpts,
function(uint256, uint256) view returns (uint256) op,
uint256 delta
) private returns (uint256 oldWeight, uint256 newWeight) {
uint256 pos = ckpts.length;
oldWeight = pos == 0 ? 0 : ckpts[pos - 1].votes;
newWeight = op(oldWeight, delta);
if (pos > 0 && ckpts[pos - 1].fromBlock == block.number) {
ckpts[pos - 1].votes = SafeCast.toUint224(newWeight);
} else {
ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(block.number), votes: SafeCast.toUint224(newWeight)}));
}
}
function _add(uint256 a, uint256 b) private pure returns (uint256) {
return a + b;
}
function _subtract(uint256 a, uint256 b) private pure returns (uint256) {
return a - b;
}
}
pragma solidity 0.8.7;
interface ITimeLockPool {
function deposit(uint256 _amount, uint256 _duration, address _receiver) external;
}
pragma solidity 0.8.7;
interface IAbstractRewards {
function withdrawableRewardsOf(address account) external view returns (uint256);
function withdrawnRewardsOf(address account) external view returns (uint256);
function cumulativeRewardsOf(address account) external view returns (uint256);
event RewardsDistributed(address indexed by, uint256 rewardsDistributed);
event RewardsWithdrawn(address indexed by, uint256 fundsWithdrawn);
}
pragma solidity 0.8.7;
abstract contract AbstractRewards is IAbstractRewards {
using SafeCast for uint128;
using SafeCast for uint256;
using SafeCast for int256;
uint128 public constant POINTS_MULTIPLIER = type(uint128).max;
function(address) view returns (uint256) private immutable getSharesOf;
function() view returns (uint256) private immutable getTotalShares;
uint256 public pointsPerShare;
mapping(address => int256) public pointsCorrection;
mapping(address => uint256) public withdrawnRewards;
constructor(
function(address) view returns (uint256) getSharesOf_,
function() view returns (uint256) getTotalShares_
) {
getSharesOf = getSharesOf_;
getTotalShares = getTotalShares_;
}
function withdrawableRewardsOf(address _account) public view override returns (uint256) {
return cumulativeRewardsOf(_account) - withdrawnRewards[_account];
}
function withdrawnRewardsOf(address _account) public view override returns (uint256) {
return withdrawnRewards[_account];
}
function cumulativeRewardsOf(address _account) public view override returns (uint256) {
return ((pointsPerShare * getSharesOf(_account)).toInt256() + pointsCorrection[_account]).toUint256() / POINTS_MULTIPLIER;
}
function _distributeRewards(uint256 _amount) internal {
uint256 shares = getTotalShares();
require(shares > 0, "AbstractRewards._distributeRewards: total share supply is zero");
if (_amount > 0) {
pointsPerShare = pointsPerShare + (_amount * POINTS_MULTIPLIER / shares);
emit RewardsDistributed(msg.sender, _amount);
}
}
function _prepareCollect(address _account) internal returns (uint256) {
uint256 _withdrawableDividend = withdrawableRewardsOf(_account);
if (_withdrawableDividend > 0) {
withdrawnRewards[_account] = withdrawnRewards[_account] + _withdrawableDividend;
emit RewardsWithdrawn(_account, _withdrawableDividend);
}
return _withdrawableDividend;
}
function _correctPointsForTransfer(address _from, address _to, uint256 _shares) internal {
int256 _magCorrection = (pointsPerShare * _shares).toInt256();
pointsCorrection[_from] = pointsCorrection[_from] + _magCorrection;
pointsCorrection[_to] = pointsCorrection[_to] - _magCorrection;
}
function _correctPoints(address _account, int256 _shares) internal {
pointsCorrection[_account] = pointsCorrection[_account] + (_shares * (int256(pointsPerShare)));
}
}
pragma solidity 0.8.7;
abstract contract BasePool is ERC20Votes, AbstractRewards, IBasePool, TokenSaver {
using SafeERC20 for IERC20;
using SafeCast for uint256;
using SafeCast for int256;
IERC20 public immutable depositToken;
IERC20 public immutable rewardToken;
ITimeLockPool public immutable escrowPool;
uint256 public immutable escrowPortion;
uint256 public immutable escrowDuration;
event RewardsClaimed(address indexed _from, address indexed _receiver, uint256 _escrowedAmount, uint256 _nonEscrowedAmount);
constructor(
string memory _name,
string memory _symbol,
address _depositToken,
address _rewardToken,
address _escrowPool,
uint256 _escrowPortion,
uint256 _escrowDuration
) ERC20Permit(_name) ERC20(_name, _symbol) AbstractRewards(balanceOf, totalSupply) {
require(_escrowPortion <= 1e18, "BasePool.constructor: Cannot escrow more than 100%");
require(_depositToken != address(0), "BasePool.constructor: Deposit token must be set");
depositToken = IERC20(_depositToken);
rewardToken = IERC20(_rewardToken);
escrowPool = ITimeLockPool(_escrowPool);
escrowPortion = _escrowPortion;
escrowDuration = _escrowDuration;
if(_rewardToken != address(0) && _escrowPool != address(0)) {
IERC20(_rewardToken).safeApprove(_escrowPool, type(uint256).max);
}
}
function _mint(address _account, uint256 _amount) internal virtual override {
super._mint(_account, _amount);
_correctPoints(_account, -(_amount.toInt256()));
}
function _burn(address _account, uint256 _amount) internal virtual override {
super._burn(_account, _amount);
_correctPoints(_account, _amount.toInt256());
}
function _transfer(address _from, address _to, uint256 _value) internal virtual override {
super._transfer(_from, _to, _value);
_correctPointsForTransfer(_from, _to, _value);
}
function distributeRewards(uint256 _amount) external override {
rewardToken.safeTransferFrom(_msgSender(), address(this), _amount);
_distributeRewards(_amount);
}
function claimRewards(address _receiver) external {
uint256 rewardAmount = _prepareCollect(_msgSender());
uint256 escrowedRewardAmount = rewardAmount * escrowPortion / 1e18;
uint256 nonEscrowedRewardAmount = rewardAmount - escrowedRewardAmount;
if(escrowedRewardAmount != 0 && address(escrowPool) != address(0)) {
escrowPool.deposit(escrowedRewardAmount, escrowDuration, _receiver);
}
if(nonEscrowedRewardAmount > 1) {
rewardToken.safeTransfer(_receiver, nonEscrowedRewardAmount);
}
emit RewardsClaimed(_msgSender(), _receiver, escrowedRewardAmount, nonEscrowedRewardAmount);
}
}
pragma solidity 0.8.7;
contract TimeLockPool is BasePool, ITimeLockPool {
using Math for uint256;
using SafeERC20 for IERC20;
uint256 public immutable maxBonus;
uint256 public immutable maxLockDuration;
uint256 public constant MIN_LOCK_DURATION = 10 minutes;
mapping(address => Deposit[]) public depositsOf;
struct Deposit {
uint256 amount;
uint64 start;
uint64 end;
}
constructor(
string memory _name,
string memory _symbol,
address _depositToken,
address _rewardToken,
address _escrowPool,
uint256 _escrowPortion,
uint256 _escrowDuration,
uint256 _maxBonus,
uint256 _maxLockDuration
) BasePool(_name, _symbol, _depositToken, _rewardToken, _escrowPool, _escrowPortion, _escrowDuration) {
require(_maxLockDuration >= MIN_LOCK_DURATION, "TimeLockPool.constructor: max lock duration must be greater or equal to mininmum lock duration");
maxBonus = _maxBonus;
maxLockDuration = _maxLockDuration;
}
event Deposited(uint256 amount, uint256 duration, address indexed receiver, address indexed from);
event Withdrawn(uint256 indexed depositId, address indexed receiver, address indexed from, uint256 amount);
function deposit(uint256 _amount, uint256 _duration, address _receiver) external override {
require(_amount > 0, "TimeLockPool.deposit: cannot deposit 0");
uint256 duration = _duration.min(maxLockDuration);
duration = duration.max(MIN_LOCK_DURATION);
depositToken.safeTransferFrom(_msgSender(), address(this), _amount);
depositsOf[_receiver].push(Deposit({
amount: _amount,
start: uint64(block.timestamp),
end: uint64(block.timestamp) + uint64(duration)
}));
uint256 mintAmount = _amount * getMultiplier(duration) / 1e18;
_mint(_receiver, mintAmount);
emit Deposited(_amount, duration, _receiver, _msgSender());
}
function withdraw(uint256 _depositId, address _receiver) external {
require(_depositId < depositsOf[_msgSender()].length, "TimeLockPool.withdraw: Deposit does not exist");
Deposit memory userDeposit = depositsOf[_msgSender()][_depositId];
require(block.timestamp >= userDeposit.end, "TimeLockPool.withdraw: too soon");
uint256 shareAmount = userDeposit.amount * getMultiplier(uint256(userDeposit.end - userDeposit.start)) / 1e18;
depositsOf[_msgSender()][_depositId] = depositsOf[_msgSender()][depositsOf[_msgSender()].length - 1];
depositsOf[_msgSender()].pop();
_burn(_msgSender(), shareAmount);
depositToken.safeTransfer(_receiver, userDeposit.amount);
emit Withdrawn(_depositId, _receiver, _msgSender(), userDeposit.amount);
}
function getMultiplier(uint256 _lockDuration) public view returns(uint256) {
return 1e18 + (maxBonus * _lockDuration / maxLockDuration);
}
function getTotalDeposit(address _account) public view returns(uint256) {
uint256 total;
for(uint256 i = 0; i < depositsOf[_account].length; i++) {
total += depositsOf[_account][i].amount;
}
return total;
}
function getDepositsOf(address _account) public view returns(Deposit[] memory) {
return depositsOf[_account];
}
function getDepositsOfLength(address _account) public view returns(uint256) {
return depositsOf[_account].length;
}
}
pragma solidity 0.8.7;
contract View {
struct Data {
uint256 pendingRewards;
Pool[] pools;
Pool escrowPool;
uint256 totalWeight;
}
struct Deposit {
uint256 amount;
uint64 start;
uint64 end;
uint256 multiplier;
}
struct Pool {
address poolAddress;
uint256 totalPoolShares;
address depositToken;
uint256 accountPendingRewards;
uint256 accountClaimedRewards;
uint256 accountTotalDeposit;
uint256 accountPoolShares;
uint256 weight;
Deposit[] deposits;
}
LiquidityMiningManager public immutable liquidityMiningManager;
TimeLockPool public immutable escrowPool;
constructor(address _liquidityMiningManager, address _escrowPool) {
liquidityMiningManager = LiquidityMiningManager(_liquidityMiningManager);
escrowPool = TimeLockPool(_escrowPool);
}
function fetchData(address _account) external view returns (Data memory result) {
uint256 rewardPerSecond = liquidityMiningManager.rewardPerSecond();
uint256 lastDistribution = liquidityMiningManager.lastDistribution();
uint256 pendingRewards = rewardPerSecond * (block.timestamp - lastDistribution);
result.totalWeight = liquidityMiningManager.totalWeight();
LiquidityMiningManager.Pool[] memory pools = liquidityMiningManager.getPools();
result.pools = new Pool[](pools.length);
for(uint256 i = 0; i < pools.length; i ++) {
TimeLockPool poolContract = TimeLockPool(address(pools[i].poolContract));
result.pools[i] = Pool({
poolAddress: address(pools[i].poolContract),
totalPoolShares: poolContract.totalSupply(),
depositToken: address(poolContract.depositToken()),
accountPendingRewards: poolContract.withdrawableRewardsOf(_account),
accountClaimedRewards: poolContract.withdrawnRewardsOf(_account),
accountTotalDeposit: poolContract.getTotalDeposit(_account),
accountPoolShares: poolContract.balanceOf(_account),
weight: pools[i].weight,
deposits: new Deposit[](poolContract.getDepositsOfLength(_account))
});
TimeLockPool.Deposit[] memory deposits = poolContract.getDepositsOf(_account);
for(uint256 j = 0; j < result.pools[i].deposits.length; j ++) {
TimeLockPool.Deposit memory deposit = deposits[j];
result.pools[i].deposits[j] = Deposit({
amount: deposit.amount,
start: deposit.start,
end: deposit.end,
multiplier: poolContract.getMultiplier(deposit.end - deposit.start)
});
}
}
result.escrowPool = Pool({
poolAddress: address(escrowPool),
totalPoolShares: escrowPool.totalSupply(),
depositToken: address(escrowPool.depositToken()),
accountPendingRewards: escrowPool.withdrawableRewardsOf(_account),
accountClaimedRewards: escrowPool.withdrawnRewardsOf(_account),
accountTotalDeposit: escrowPool.getTotalDeposit(_account),
accountPoolShares: escrowPool.balanceOf(_account),
weight: 0,
deposits: new Deposit[](escrowPool.getDepositsOfLength(_account))
});
TimeLockPool.Deposit[] memory deposits = escrowPool.getDepositsOf(_account);
for(uint256 j = 0; j < result.escrowPool.deposits.length; j ++) {
TimeLockPool.Deposit memory deposit = deposits[j];
result.escrowPool.deposits[j] = Deposit({
amount: deposit.amount,
start: deposit.start,
end: deposit.end,
multiplier: escrowPool.getMultiplier(deposit.end - deposit.start)
});
}
}
} | 1 | 2,977 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "CarnaLife Token";
string public constant TOKEN_SYMBOL = "CLC";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0x69D8fD25c05d07D3Fc5280040ba0BDe4d5C4d399;
uint public constant START_TIME = 1550230200;
bool public constant CONTINUE_MINTING = true;
}
contract FinalizableCrowdsale is TimedCrowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
super._preValidatePurchase(_beneficiary, _weiAmount);
require(weiRaised.add(_weiAmount) <= cap);
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
}
contract MainCrowdsale is Consts, FinalizableCrowdsale, MintedCrowdsale, CappedCrowdsale {
function hasStarted() public view returns (bool) {
return now >= openingTime;
}
function startTime() public view returns (uint256) {
return openingTime;
}
function endTime() public view returns (uint256) {
return closingTime;
}
function hasClosed() public view returns (bool) {
return super.hasClosed() || capReached();
}
function hasEnded() public view returns (bool) {
return hasClosed();
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
require(MintableToken(token).finishMinting());
}
Ownable(token).transferOwnership(TARGET_USER);
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate).div(1 ether);
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
uint256 bonusRate = getBonusRate(_weiAmount);
return _weiAmount.mul(bonusRate).div(1 ether);
}
function getBonusRate(uint256 _weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[2] memory weiRaisedStartsBounds = [uint(0),uint(0)];
uint[2] memory weiRaisedEndsBounds = [uint(700000000000000000000000),uint(700000000000000000000000)];
uint64[2] memory timeStartsBounds = [uint64(1550230200),uint64(1552597140)];
uint64[2] memory timeEndsBounds = [uint64(1552597140),uint64(1555189195)];
uint[2] memory weiRaisedAndTimeRates = [uint(100),uint(50)];
for (uint i = 0; i < 2; i++) {
bool weiRaisedInBound = (weiRaisedStartsBounds[i] <= weiRaised) && (weiRaised < weiRaisedEndsBounds[i]);
bool timeInBound = (timeStartsBounds[i] <= now) && (now < timeEndsBounds[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
{
event Initialized();
event TimesChanged(uint startTime, uint endTime, uint oldStartTime, uint oldEndTime);
bool public initialized = false;
constructor(MintableToken _token) public
Crowdsale(4000 * TOKEN_DECIMAL_MULTIPLIER, 0x8651Dbfa480fAC7721afB8fc75dd15df5C3FeeFF, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1555189200)
CappedCrowdsale(700000000000000000000000)
{
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[5] memory addresses = [address(0x69d8fd25c05d07d3fc5280040ba0bde4d5c4d399),address(0xe011be20adc30aaea2def2b8df8d62f38dc6ce59),address(0x9e336bb3bb2e31c20f6728133d8b281760840437),address(0x109184b0c6d1bc3e5c6bda2a7fd5e58e86a2023d),address(0x7ae2620c28160446f140958c6fd5f9a8b3088c25)];
uint[5] memory amounts = [uint(2100000000000000000000000000),uint(1500000000000000000000000000),uint(800000000000000000000000000),uint(800000000000000000000000000),uint(2000000000000000000000000000)];
uint64[5] memory freezes = [uint64(1555189263),uint64(1555189263),uint64(1555189263),uint64(1555189263),uint64(1555189263)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
emit Initialized();
}
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 250000000000000000;
return super.hasClosed() || remainValue;
}
function setEndTime(uint _endTime) public onlyOwner {
require(now < closingTime);
require(now < _endTime);
require(_endTime > openingTime);
emit TimesChanged(openingTime, _endTime, openingTime, closingTime);
closingTime = _endTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(msg.value >= 250000000000000000);
require(msg.value <= 4000000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 0 | 1,798 |
pragma solidity ^0.4.11;
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
if (msg.sender == owner)
_;
}
}
contract tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract IERC20Token {
function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address indexed from, uint256 value);
}
contract TESTH is IERC20Token, owned{
string public standard = "TESTH v1.0";
string public name = "TESTH";
string public symbol = "TESTH";
uint8 public decimals = 18;
uint256 public initialSupply = 50000000 * 10 ** 18;
uint256 public tokenFrozenUntilBlock;
uint256 public timeLock = block.timestamp + 2 days;
uint256 supply = initialSupply;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowances;
mapping (address => bool) rAddresses;
event TokenFrozen(uint256 _frozenUntilBlock, string _reason);
function TESTH() {
rAddresses[0x0] = true;
rAddresses[address(this)] = true;
}
function totalSupply() constant returns (uint256 totalSupply) {
return supply;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transferOwnership(address newOwner) onlyOwner {
require(transfer(newOwner, balances[msg.sender]));
owner = newOwner;
}
function transfer(address _to, uint256 _value) returns (bool success) {
require (block.number >= tokenFrozenUntilBlock) ;
require (!rAddresses[_to]) ;
require (balances[msg.sender] >= _value);
require (balances[_to] + _value >= balances[_to]) ;
require (!(msg.sender == owner && block.timestamp < timeLock && (balances[msg.sender]-_value) < 10000000 * 10 ** 18));
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool success) {
require (block.number > tokenFrozenUntilBlock);
allowances[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
approve(_spender, _value);
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require (block.number > tokenFrozenUntilBlock);
require (!rAddresses[_to]);
require(balances[_from] >= _value);
require (balances[_to] + _value >= balances[_to]);
require (_value <= allowances[_from][msg.sender]);
require (!(_from == owner && block.timestamp < timeLock && (balances[_from]-_value) < 10000000 * 10 ** 18));
balances[_from] -= _value;
balances[_to] += _value;
allowances[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function burn(uint256 _value) returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
supply-=_value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) returns (bool success) {
require(balances[_from] >= _value);
require(_value <= allowances[_from][msg.sender]);
balances[_from] -= _value;
allowances[_from][msg.sender] -= _value;
supply -= _value;
Burn(_from, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowances[_owner][_spender];
}
function freezeTransfersUntil(uint256 _frozenUntilBlock, string _reason) onlyOwner {
tokenFrozenUntilBlock = _frozenUntilBlock;
TokenFrozen(_frozenUntilBlock, _reason);
}
function unfreezeTransfersUntil(string _reason) onlyOwner {
tokenFrozenUntilBlock = 0;
TokenFrozen(0, _reason);
}
function editRestrictedAddress(address _newRestrictedAddress) onlyOwner {
rAddresses[_newRestrictedAddress] = !rAddresses[_newRestrictedAddress];
}
function isRestrictedAddress(address _queryAddress) constant returns (bool answer){
return rAddresses[_queryAddress];
}
} | 0 | 1,475 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
library AddressUtils {
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
interface ERC165 {
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract SupportsInterface is ERC165 {
mapping(bytes4 => bool) internal supportedInterfaces;
constructor() public {
supportedInterfaces[0x01ffc9a7] = true;
}
function supportsInterface(bytes4 _interfaceID) external view returns (bool) {
return supportedInterfaces[_interfaceID];
}
}
interface ERC721 {
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) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) external;
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function approve(address _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
interface ERC721Enumerable {
function totalSupply() external view returns (uint256);
function tokenByIndex(uint256 _index) external view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}
interface ERC721Metadata {
function name() external view returns (string _name);
function symbol() external view returns (string _symbol);
function tokenURI(uint256 _tokenId) external view returns (string);
}
interface ERC721TokenReceiver {
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) external returns(bytes4);
}
contract NFToken is ERC721, SupportsInterface {
using SafeMath for uint256;
using AddressUtils for address;
mapping (uint256 => address) internal idToOwner;
mapping (uint256 => address) internal idToApprovals;
mapping (address => uint256) internal ownerToNFTokenCount;
mapping (address => mapping (address => bool)) internal ownerToOperators;
bytes4 constant MAGIC_ON_ERC721_RECEIVED = 0x150b7a02;
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);
modifier canOperate(uint256 _tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == msg.sender || ownerToOperators[tokenOwner][msg.sender]);
_;
}
modifier canTransfer(uint256 _tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == msg.sender || getApproved(_tokenId) == msg.sender || ownerToOperators[tokenOwner][msg.sender]);
_;
}
modifier validNFToken(uint256 _tokenId) {
require(idToOwner[_tokenId] != address(0));
_;
}
constructor() public {
supportedInterfaces[0x80ac58cd] = true;
}
function balanceOf(address _owner) external view returns (uint256) {
require(_owner != address(0));
return ownerToNFTokenCount[_owner];
}
function ownerOf(uint256 _tokenId) external view returns (address _owner) {
_owner = idToOwner[_tokenId];
require(_owner != address(0));
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) external {
_safeTransferFrom(_from, _to, _tokenId, _data);
}
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external {
_safeTransferFrom(_from, _to, _tokenId, "");
}
function transferFrom(address _from, address _to, uint256 _tokenId) external canTransfer(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == _from);
require(_to != address(0));
_transfer(_to, _tokenId);
}
function approve(address _approved, uint256 _tokenId) external canOperate(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(_approved != tokenOwner);
idToApprovals[_tokenId] = _approved;
emit Approval(tokenOwner, _approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved) external {
require(_operator != address(0));
ownerToOperators[msg.sender][_operator] = _approved;
emit ApprovalForAll(msg.sender, _operator, _approved);
}
function getApproved(uint256 _tokenId) public view validNFToken(_tokenId) returns (address) {
return idToApprovals[_tokenId];
}
function isApprovedForAll(address _owner, address _operator) external view returns (bool) {
require(_owner != address(0));
require(_operator != address(0));
return ownerToOperators[_owner][_operator];
}
function _safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes _data) internal canTransfer(_tokenId) validNFToken(_tokenId) {
address tokenOwner = idToOwner[_tokenId];
require(tokenOwner == _from);
require(_to != address(0));
_transfer(_to, _tokenId);
if (_to.isContract()) {
bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);
require(retval == MAGIC_ON_ERC721_RECEIVED);
}
}
function _transfer(address _to, uint256 _tokenId) private {
address from = idToOwner[_tokenId];
clearApproval(_tokenId);
removeNFToken(from, _tokenId);
addNFToken(_to, _tokenId);
emit Transfer(from, _to, _tokenId);
}
function _mint(address _to, uint256 _tokenId) internal {
require(_to != address(0));
require(_tokenId != 0);
require(idToOwner[_tokenId] == address(0));
addNFToken(_to, _tokenId);
emit Transfer(address(0), _to, _tokenId);
}
function _burn(address _owner, uint256 _tokenId) validNFToken(_tokenId) internal {
clearApproval(_tokenId);
removeNFToken(_owner, _tokenId);
emit Transfer(_owner, address(0), _tokenId);
}
function clearApproval(uint256 _tokenId) private {
if(idToApprovals[_tokenId] != 0) {
delete idToApprovals[_tokenId];
}
}
function removeNFToken(address _from, uint256 _tokenId) internal {
require(idToOwner[_tokenId] == _from);
assert(ownerToNFTokenCount[_from] > 0);
ownerToNFTokenCount[_from] = ownerToNFTokenCount[_from] - 1;
delete idToOwner[_tokenId];
}
function addNFToken(address _to, uint256 _tokenId) internal {
require(idToOwner[_tokenId] == address(0));
idToOwner[_tokenId] = _to;
ownerToNFTokenCount[_to] = ownerToNFTokenCount[_to].add(1);
}
}
contract NFTokenEnumerable is NFToken, ERC721Enumerable {
uint256[] internal tokens;
mapping(uint256 => uint256) internal idToIndex;
mapping(address => uint256[]) internal ownerToIds;
mapping(uint256 => uint256) internal idToOwnerIndex;
constructor() public {
supportedInterfaces[0x780e9d63] = true;
}
function _mint(address _to, uint256 _tokenId) internal {
super._mint(_to, _tokenId);
uint256 length = tokens.push(_tokenId);
idToIndex[_tokenId] = length - 1;
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
assert(tokens.length > 0);
uint256 tokenIndex = idToIndex[_tokenId];
assert(tokens[tokenIndex] == _tokenId);
uint256 lastTokenIndex = tokens.length - 1;
uint256 lastToken = tokens[lastTokenIndex];
tokens[tokenIndex] = lastToken;
tokens.length--;
idToIndex[lastToken] = tokenIndex;
idToIndex[_tokenId] = 0;
}
function removeNFToken(address _from, uint256 _tokenId) internal
{
super.removeNFToken(_from, _tokenId);
assert(ownerToIds[_from].length > 0);
uint256 tokenToRemoveIndex = idToOwnerIndex[_tokenId];
uint256 lastTokenIndex = ownerToIds[_from].length - 1;
uint256 lastToken = ownerToIds[_from][lastTokenIndex];
ownerToIds[_from][tokenToRemoveIndex] = lastToken;
ownerToIds[_from].length--;
idToOwnerIndex[lastToken] = tokenToRemoveIndex;
idToOwnerIndex[_tokenId] = 0;
}
function addNFToken(address _to, uint256 _tokenId) internal {
super.addNFToken(_to, _tokenId);
uint256 length = ownerToIds[_to].push(_tokenId);
idToOwnerIndex[_tokenId] = length - 1;
}
function totalSupply() external view returns (uint256) {
return tokens.length;
}
function tokenByIndex(uint256 _index) external view returns (uint256) {
require(_index < tokens.length);
assert(idToIndex[tokens[_index]] == _index);
return tokens[_index];
}
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256) {
require(_index < ownerToIds[_owner].length);
return ownerToIds[_owner][_index];
}
}
contract NFTStandard is NFTokenEnumerable, ERC721Metadata {
string internal nftName;
string internal nftSymbol;
mapping (uint256 => string) internal idToUri;
constructor(string _name, string _symbol) public {
nftName = _name;
nftSymbol = _symbol;
supportedInterfaces[0x5b5e139f] = true;
}
function _burn(address _owner, uint256 _tokenId) internal {
super._burn(_owner, _tokenId);
if (bytes(idToUri[_tokenId]).length != 0) {
delete idToUri[_tokenId];
}
}
function _setTokenUri(uint256 _tokenId, string _uri) validNFToken(_tokenId) internal {
idToUri[_tokenId] = _uri;
}
function name() external view returns (string _name) {
_name = nftName;
}
function symbol() external view returns (string _symbol) {
_symbol = nftSymbol;
}
function tokenURI(uint256 _tokenId) validNFToken(_tokenId) external view returns (string) {
return idToUri[_tokenId];
}
}
contract BasicAccessControl {
address public owner;
uint16 public totalModerators = 0;
mapping (address => bool) public moderators;
bool public isMaintaining = false;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyModerators() {
require(msg.sender == owner || moderators[msg.sender] == true);
_;
}
modifier isActive {
require(!isMaintaining);
_;
}
function ChangeOwner(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function AddModerator(address _newModerator) onlyOwner public {
if (moderators[_newModerator] == false) {
moderators[_newModerator] = true;
totalModerators += 1;
}
}
function RemoveModerator(address _oldModerator) onlyOwner public {
if (moderators[_oldModerator] == true) {
moderators[_oldModerator] = false;
totalModerators -= 1;
}
}
function UpdateMaintaining(bool _isMaintaining) onlyOwner public {
isMaintaining = _isMaintaining;
}
}
interface EtheremonAdventureHandler {
function handleSingleItem(address _sender, uint _classId, uint _value, uint _target, uint _param) external;
function handleMultipleItems(address _sender, uint _classId1, uint _classId2, uint _classId3, uint _target, uint _param) external;
}
contract EtheremonAdventureItem is NFTStandard("EtheremonAdventure", "EMOND"), BasicAccessControl {
uint constant public MAX_OWNER_PERS_SITE = 10;
uint constant public MAX_SITE_ID = 108;
uint constant public MAX_SITE_TOKEN_ID = 1080;
address public adventureHandler;
struct Item {
uint classId;
uint value;
}
uint public totalItem = MAX_SITE_TOKEN_ID;
mapping (uint => Item) public items;
modifier requireAdventureHandler {
require(adventureHandler != address(0));
_;
}
function setAdventureHandler(address _adventureHandler) onlyModerators external {
adventureHandler = _adventureHandler;
}
function setTokenURI(uint256 _tokenId, string _uri) onlyModerators external {
_setTokenUri(_tokenId, _uri);
}
function spawnSite(uint _classId, uint _tokenId, address _owner) onlyModerators external {
if (_owner == address(0)) revert();
if (_classId > MAX_SITE_ID || _classId == 0 || _tokenId > MAX_SITE_TOKEN_ID || _tokenId == 0) revert();
Item storage item = items[_tokenId];
if (item.classId != 0) revert();
item.classId = _classId;
_mint(_owner, _tokenId);
}
function spawnItem(uint _classId, uint _value, address _owner) onlyModerators external returns(uint) {
if (_owner == address(0)) revert();
if (_classId < MAX_SITE_ID) revert();
totalItem += 1;
Item storage item = items[totalItem];
item.classId = _classId;
item.value = _value;
_mint(_owner, totalItem);
return totalItem;
}
function useSingleItem(uint _tokenId, uint _target, uint _param) isActive requireAdventureHandler public {
if (_tokenId == 0 || idToOwner[_tokenId] != msg.sender) revert();
Item storage item = items[_tokenId];
EtheremonAdventureHandler handler = EtheremonAdventureHandler(adventureHandler);
handler.handleSingleItem(msg.sender, item.classId, item.value, _target, _param);
_burn(msg.sender, _tokenId);
}
function useMultipleItem(uint _token1, uint _token2, uint _token3, uint _target, uint _param) isActive requireAdventureHandler public {
if (_token1 > 0 && idToOwner[_token1] != msg.sender) revert();
if (_token2 > 0 && idToOwner[_token2] != msg.sender) revert();
if (_token3 > 0 && idToOwner[_token3] != msg.sender) revert();
Item storage item1 = items[_token1];
Item storage item2 = items[_token2];
Item storage item3 = items[_token3];
EtheremonAdventureHandler handler = EtheremonAdventureHandler(adventureHandler);
handler.handleMultipleItems(msg.sender, item1.classId, item2.classId, item3.classId, _target, _param);
if (_token1 > 0) _burn(msg.sender, _token1);
if (_token2 > 0) _burn(msg.sender, _token2);
if (_token3 > 0) _burn(msg.sender, _token3);
}
function getItemInfo(uint _tokenId) constant public returns(uint classId, uint value) {
Item storage item = items[_tokenId];
classId = item.classId;
value = item.value;
}
} | 1 | 2,503 |
pragma solidity ^0.4.24;
contract PCKevents {
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 PCPAmount,
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 PCPAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 PCPAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 PCPAmount,
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 modularKey is PCKevents {}
contract PlayCoinKey is modularKey {
using SafeMath for *;
using NameFilter for string;
using PCKKeysCalcLong for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x14229878e85e57FF4109dc27bb2EfB5EA8067E6E);
string constant public name = "PlayCoin Key";
string constant public symbol = "PCK";
uint256 private rndExtra_ = 2 minutes;
uint256 private rndGap_ = 15 minutes;
uint256 constant private rndInit_ = 24 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 constant private rndMin_ = 10 minutes;
uint256 public reduceMul_ = 3;
uint256 public reduceDiv_ = 2;
uint256 public rndReduceThreshold_ = 10e18;
bool public closed_ = false;
address private admin = msg.sender;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => PCKdatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => PCKdatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => PCKdatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => PCKdatasets.TeamFee) public fees_;
mapping (uint256 => PCKdatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = PCKdatasets.TeamFee(30,6);
fees_[1] = PCKdatasets.TeamFee(43,0);
fees_[2] = PCKdatasets.TeamFee(56,10);
fees_[3] = PCKdatasets.TeamFee(43,8);
potSplit_[0] = PCKdatasets.PotSplit(15,10);
potSplit_[1] = PCKdatasets.PotSplit(25,0);
potSplit_[2] = PCKdatasets.PotSplit(20,20);
potSplit_[3] = PCKdatasets.PotSplit(30,10);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isRoundActivated() {
require(round_[rID_].ended == false, "the round is finished");
_;
}
modifier isHuman() {
require(msg.sender == tx.origin, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
modifier onlyAdmins() {
require(msg.sender == admin, "onlyAdmins failed - msg.sender is not an admin");
_;
}
function kill () onlyAdmins() public {
require(round_[rID_].ended == true && closed_ == true, "the round is active or not close");
selfdestruct(admin);
}
function getRoundStatus() isActivated() public view returns(uint256, bool){
return (rID_, round_[rID_].ended);
}
function setThreshold(uint256 _threshold, uint256 _mul, uint256 _div) onlyAdmins() public {
require(_threshold > 0, "threshold must greater 0");
require(_mul > 0, "mul must greater 0");
require(_div > 0, "div must greater 0");
rndReduceThreshold_ = _threshold;
reduceMul_ = _mul;
reduceDiv_ = _div;
}
function setEnforce(bool _closed) onlyAdmins() public returns(bool, uint256, bool) {
closed_ = _closed;
if( !closed_ && round_[rID_].ended == true && activated_ == true ){
nextRound();
}
else if( closed_ && round_[rID_].ended == false && activated_ == true ){
round_[rID_].end = now - 1;
}
return (closed_, rID_, now > round_[rID_].end);
}
function()
isActivated()
isRoundActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
PCKdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isRoundActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
PCKdatasets.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()
isRoundActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
PCKdatasets.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()
isRoundActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
PCKdatasets.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()
isRoundActivated()
isHuman()
isWithinLimits(_eth)
public
{
PCKdatasets.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()
isRoundActivated()
isHuman()
isWithinLimits(_eth)
public
{
PCKdatasets.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()
isRoundActivated()
isHuman()
isWithinLimits(_eth)
public
{
PCKdatasets.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)
{
PCKdatasets.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 PCKevents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.PCPAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit PCKevents.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 PCKevents.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 PCKevents.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 PCKevents.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, PCKdatasets.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_);
if( !closed_ ){
nextRound();
}
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit PCKevents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.PCPAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, PCKdatasets.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_);
if( !closed_ ) {
nextRound();
}
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit PCKevents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.PCPAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, PCKdatasets.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, _eth);
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(PCKdatasets.EventReturns memory _eventData_)
private
returns (PCKdatasets.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, PCKdatasets.EventReturns memory _eventData_)
private
returns (PCKdatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function nextRound() private {
rID_++;
round_[rID_].strt = now;
round_[rID_].end = now.add(rndInit_).add(rndGap_);
}
function endRound(PCKdatasets.EventReturns memory _eventData_)
private
returns (PCKdatasets.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.add(_p3d.sub(_p3d / 2)));
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_res = _res.add(_p3d / 2);
_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_.PCPAmount = _p3d;
_eventData_.newPot = _res;
_rID++;
round_[_rID].ended = false;
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, uint256 _eth)
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);
uint256 _newEndTime;
if (_newTime < (rndMax_).add(_now))
_newEndTime = _newTime;
else
_newEndTime = rndMax_.add(_now);
if ( _eth >= rndReduceThreshold_ ) {
uint256 reduce = ((((_keys) / (1000000000000000000))).mul(rndInc_ * reduceMul_) / reduceDiv_);
if( _newEndTime > reduce && _now + rndMin_ + reduce < _newEndTime){
_newEndTime = (_newEndTime).sub(reduce);
}
else if ( _newEndTime > reduce ){
_newEndTime = _now + rndMin_;
}
}
round_[_rID].end = _newEndTime;
}
function getReduce(uint256 _rID, uint256 _eth) public view returns(uint256,uint256){
uint256 _keys = calcKeysReceived(_rID, _eth);
if ( _eth >= rndReduceThreshold_ ) {
return ( ((((_keys) / (1000000000000000000))).mul(rndInc_ * reduceMul_) / reduceDiv_), (((_keys) / (1000000000000000000)).mul(rndInc_)) );
} else {
return (0, (((_keys) / (1000000000000000000)).mul(rndInc_)) );
}
}
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, PCKdatasets.EventReturns memory _eventData_)
private
returns(PCKdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
if (!address(admin).call.value(_com)()) {
_p3d = _com;
_com = 0;
}
uint256 _long = _eth / 100;
potSwap(_long);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit PCKevents.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.sub(_p3d / 2));
round_[_rID].pot = round_[_rID].pot.add(_p3d / 2);
_eventData_.PCPAmount = _p3d.add(_eventData_.PCPAmount);
}
return(_eventData_);
}
function potSwap(uint256 _pot) private {
uint256 _rID = rID_ + 1;
round_[_rID].pot = round_[_rID].pot.add(_pot);
emit PCKevents.onPotSwapDeposit(_rID, _pot);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, PCKdatasets.EventReturns memory _eventData_)
private
returns(PCKdatasets.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, PCKdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit PCKevents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.PCPAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate() public {
require(
msg.sender == admin,
"only team just can activate"
);
require(activated_ == false, "PCK already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library PCKdatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 PCPAmount;
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 PCKKeysCalcLong {
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 PCKExtSettingInterface {
function getFastGap() external view returns(uint256);
function getLongGap() external view returns(uint256);
function getFastExtra() external view returns(uint256);
function getLongExtra() external view returns(uint256);
}
interface PlayCoinGodInterface {
function deposit() external payable;
}
interface ProForwarderInterface {
function deposit() external payable returns(bool);
function status() external view returns(address, address, bool);
function startMigration(address _newCorpBank) external returns(bool);
function cancelMigration() external returns(bool);
function finishMigration() external returns(bool);
function setup(address _firstCorpBank) external;
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 35 |
pragma solidity ^0.4.24;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value)
external returns (bool);
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string name, string symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string) {
return _name;
}
function symbol() public view returns(string) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
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 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 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)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != 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 != 0);
require(value <= _balances[account]);
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _burnFrom(address account, uint256 value) internal {
require(value <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
value);
_burn(account, value);
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private pausers;
constructor() internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() internal {
_paused = false;
}
function paused() public view returns(bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(
address to,
uint256 value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(to, value);
}
function transferFrom(
address from,
address to,
uint256 value
)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(from, to, value);
}
function approve(
address spender,
uint256 value
)
public
whenNotPaused
returns (bool)
{
return super.approve(spender, value);
}
function increaseAllowance(
address spender,
uint addedValue
)
public
whenNotPaused
returns (bool success)
{
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(
address spender,
uint subtractedValue
)
public
whenNotPaused
returns (bool success)
{
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract ERC20Burnable is ERC20 {
function burn(uint256 value) public {
_burn(msg.sender, value);
}
function burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private minters;
constructor() internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
minters.remove(account);
emit MinterRemoved(account);
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(
address to,
uint256 value
)
public
onlyMinter
returns (bool)
{
_mint(to, value);
return true;
}
}
contract Token is ERC20Detailed, ERC20Pausable, ERC20Burnable, ERC20Mintable {
mapping (address => uint256) lockedUntil;
constructor()
ERC20Detailed("PAY", "PCL", 18)
ERC20Pausable()
ERC20Burnable()
ERC20Mintable()
public {
}
modifier unLocked() {
require(block.timestamp >= lockedUntil[msg.sender], 'timelocked');
_;
}
function transfer(address to, uint256 value) public unLocked returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public unLocked returns (bool) {
return super.transferFrom(from, to, value);
}
function mintWithTimelock(address to, uint256 value, uint256 releaseTime) public {
super.mint(to, value);
lockedUntil[to] = releaseTime;
}
function timelockOf(address owner) public view returns (uint256) {
return lockedUntil[owner];
}
} | 1 | 2,764 |
pragma solidity ^0.4.24;
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
owner = newOwner;
}
}
contract SafeMath {
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal pure returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * 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;
}
}
contract Pausable is Owned {
bool public paused = false;
event Pause();
event Unpause();
modifier notPaused {
require(!paused);
_;
}
function pause() public onlyOwner {
paused = true;
emit Pause();
}
function unpause() public onlyOwner {
paused = false;
emit Unpause();
}
}
contract EIP20Interface {
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Qobit is Owned, SafeMath, Pausable, EIP20Interface {
uint256 private totalSupply_;
string public name;
string public symbol;
uint8 public decimals;
mapping (address => uint256) public balances;
mapping (address => uint256) public frozen;
mapping (address => mapping (address => uint256)) public allowed;
event Freeze(address indexed from, uint256 value);
event Unfreeze(address indexed from, uint256 value);
event Burned(address indexed from, uint256 value);
constructor() public {
name = "Qobit.com Token";
symbol = "QOBI";
decimals = 8;
totalSupply_ = 1500000000 * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply_;
}
function mint(address _addr, uint256 _amount) onlyOwner public returns (bool success) {
require(_addr != 0x0);
totalSupply_ = add(totalSupply_, _amount);
balances[_addr] = add(balances[_addr], _amount);
emit Transfer(address(0), _addr, _amount);
return true;
}
function burn(address _addr, uint256 _amount) onlyOwner public returns (bool success) {
require(_addr != 0);
require(_amount <= balances[_addr]);
totalSupply_ = sub(totalSupply_, _amount);
balances[_addr] = sub(balances[_addr], _amount);
emit Transfer(_addr, address(0), _amount);
emit Burned(_addr, _amount);
return true;
}
function freeze(address _addr, uint256 _value) public onlyOwner returns (bool success) {
require(balances[_addr] >= _value);
require(_value > 0);
balances[_addr] = sub(balances[_addr], _value);
frozen[_addr] = add(frozen[_addr], _value);
emit Freeze(_addr, _value);
return true;
}
function unfreeze(address _addr, uint256 _value) public onlyOwner returns (bool success) {
require(frozen[_addr] >= _value);
require(_value > 0);
frozen[_addr] = sub(frozen[_addr], _value);
balances[_addr] = add(balances[_addr], _value);
emit Unfreeze(_addr, _value);
return true;
}
function frozenOf(address _addr) public view returns (uint256 balance) {
return frozen[_addr];
}
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address _addr) public view returns (uint256 balance) {
return balances[_addr];
}
function transfer(address _to, uint256 _value) public notPaused returns (bool success) {
require(balances[msg.sender] >= _value);
require(balances[_to] + _value >= balances[_to]);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public notPaused returns (bool success) {
require(balances[_from] >= _value);
require(balances[_to] + _value >= balances[_to]);
require(allowed[_from][msg.sender] >= _value);
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public notPaused returns (bool success) {
require(_value > 0);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
}
} | 1 | 4,177 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TokenControl {
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
bool public enablecontrol = true;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier whenNotPaused() {
require(enablecontrol);
_;
}
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCFO(address _newCFO) external onlyCEO {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
function setCOO(address _newCOO) external onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function enableControl(bool _enable) public onlyCEO{
enablecontrol = _enable;
}
}
contract StandardToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract BurnableToken is StandardToken, TokenControl {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) onlyCOO whenNotPaused public {
_burn(_value);
}
function _burn( uint256 _value) internal {
require(_value <= balances[cfoAddress]);
balances[cfoAddress] = balances[cfoAddress].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(cfoAddress, _value);
emit Transfer(cfoAddress, address(0), _value);
}
}
contract MintableToken is StandardToken, TokenControl {
event Mint(address indexed to, uint256 amount);
function mint(uint256 _value) onlyCOO whenNotPaused public {
_mint(_value);
}
function _mint( uint256 _value) internal {
balances[cfoAddress] = balances[cfoAddress].add(_value);
totalSupply_ = totalSupply_.add(_value);
emit Mint(cfoAddress, _value);
emit Transfer(address(0), cfoAddress, _value);
}
}
contract PausableToken is StandardToken, TokenControl {
bool public transferEnabled = true;
function enableTransfer(bool _enable) public onlyCEO{
transferEnabled = _enable;
}
modifier transferAllowed() {
assert(transferEnabled);
_;
}
function transfer(address _to, uint256 _value) public transferAllowed() returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public transferAllowed() returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public transferAllowed() returns (bool) {
return super.approve(_spender, _value);
}
}
contract EMK is BurnableToken, MintableToken, PausableToken {
string public name;
string public symbol;
uint8 public decimals;
constructor(address _ceoAddress, address _cfoAddress, address _cooAddress) public {
name = "E-MK";
symbol = "E-MK";
decimals = 8;
ceoAddress = _ceoAddress;
cfoAddress = _cfoAddress;
cooAddress = _cooAddress;
totalSupply_ = 50000000000000;
balances[cfoAddress] = totalSupply_;
}
function() payable public { }
} | 1 | 2,206 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
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 QuickxToken is ERC20 {
using SafeMath for uint;
event LogBurn(address indexed from, uint256 amount);
event LogFreezed(address targetAddress, bool frozen);
event LogEmerygencyFreezed(bool emergencyFreezeStatus);
string public name = "QuickX Protocol";
string public symbol = "QCX";
uint8 public decimals = 8;
address public owner;
uint public totalSupply = 500000000 * (10 ** 8);
uint public currentSupply = 250000000 * (10 ** 8);
bool public emergencyFreeze = true;
mapping (address => uint) internal balances;
mapping (address => mapping (address => uint) ) private allowed;
mapping (address => bool) private frozen;
constructor () public {
owner = address(0x2cf93Eed42d4D0C0121F99a4AbBF0d838A004F64);
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier unfreezed(address _account) {
require(!frozen[_account]);
_;
}
modifier noEmergencyFreeze() {
require(!emergencyFreeze);
_;
}
function transfer(address _to, uint _value)
public
unfreezed(_to)
unfreezed(msg.sender)
noEmergencyFreeze()
returns (bool success) {
require(_to != 0x0);
_transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender, uint _value)
public
unfreezed(_spender)
unfreezed(msg.sender)
noEmergencyFreeze()
returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function increaseApproval(address _spender, uint _addedValue)
public
unfreezed(_spender)
unfreezed(msg.sender)
noEmergencyFreeze()
returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue)
public
unfreezed(_spender)
unfreezed(msg.sender)
noEmergencyFreeze()
returns (bool success) {
uint oldAllowance = allowed[msg.sender][_spender];
if (_subtractedValue > oldAllowance) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldAllowance.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function transferFrom(address _from, address _to, uint _value)
public
unfreezed(_to)
unfreezed(_from)
noEmergencyFreeze()
returns (bool success) {
require(_value <= allowed[_from][msg.sender]);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
}
function freezeAccount (address _target, bool _freeze) public onlyOwner {
require(_target != 0x0);
frozen[_target] = _freeze;
emit LogFreezed(_target, _freeze);
}
function emergencyFreezeAllAccounts (bool _freeze) public onlyOwner {
emergencyFreeze = _freeze;
emit LogEmerygencyFreezed(_freeze);
}
function burn(uint256 _value) public onlyOwner returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
currentSupply = currentSupply.sub(_value);
emit LogBurn(msg.sender, _value);
return true;
}
function balanceOf(address _tokenOwner) public view returns (uint) {
return balances[_tokenOwner];
}
function totalSupply() public view returns (uint) {
return totalSupply;
}
function allowance(address _tokenOwner, address _spender) public view returns (uint) {
return allowed[_tokenOwner][_spender];
}
function isFreezed(address _targetAddress) public view returns (bool) {
return frozen[_targetAddress];
}
function _transfer(address from, address to, uint amount) internal {
require(balances[from] >= amount);
uint balBeforeTransfer = balances[from].add(balances[to]);
balances[from] = balances[from].sub(amount);
balances[to] = balances[to].add(amount);
uint balAfterTransfer = balances[from].add(balances[to]);
assert(balBeforeTransfer == balAfterTransfer);
emit Transfer(from, to, amount);
}
}
contract QuickxProtocol is QuickxToken {
using SafeMath for uint;
uint public tokenSaleAllocation = 250000000 * (10 ** 8);
uint public bountyAllocation = 10000000 * (10 ** 8);
uint public founderAllocation = 65000000 * (10 ** 8);
uint public partnersAllocation = 25000000 * (10 ** 8);
uint public liquidityReserveAllocation = 75000000 * (10 ** 8);
uint public advisoryAllocation = 25000000 * (10 ** 8);
uint public preSeedInvestersAllocation = 50000000 * (10 ** 8);
uint[] public founderFunds = [
1300000000000000,
2600000000000000,
3900000000000000,
5200000000000000,
6500000000000000
];
uint[] public advisoryFunds = [
500000000000000,
1000000000000000,
1500000000000000,
2000000000000000,
2500000000000000
];
uint public founderFundsWithdrawn = 0;
uint public advisoryFundsWithdrawn = 0;
bool public bountyAllocated;
bool public partnersAllocated;
bool public liquidityReserveAllocated;
bool public preSeedInvestersAllocated;
uint public icoSuccessfulTime;
bool public isIcoSuccessful;
address public beneficiary;
uint private totalRaised = 0;
uint private totalCoinsSold = 0;
uint private softCap;
uint private hardCap;
uint private rateNum;
uint private rateDeno;
uint public tokenSaleStart;
uint public tokenSaleEnds;
bool public icoPaused;
event LogBontyAllocated(
address recepient,
uint amount);
event LogPartnersAllocated(
address recepient,
uint amount);
event LogLiquidityreserveAllocated(
address recepient,
uint amount);
event LogPreSeedInverstorsAllocated(
address recepient,
uint amount);
event LogAdvisorsAllocated(
address recepient,
uint amount);
event LogFoundersAllocated(
address indexed recepient,
uint indexed amount);
event LogFundingReceived(
address indexed addr,
uint indexed weiRecieved,
uint indexed tokenTransferred,
uint currentTotal);
event LogRateUpdated(
uint rateNum,
uint rateDeno);
event LogPaidToOwner(
address indexed beneficiary,
uint indexed amountPaid);
event LogWithdrawnRemaining(
address _owner,
uint amountWithdrawan);
event LogIcoEndDateUpdated(
uint _oldEndDate,
uint _newEndDate);
event LogIcoSuccessful();
mapping (address => uint) public contributedAmount;
constructor () public {
owner = address(0x2cf93Eed42d4D0C0121F99a4AbBF0d838A004F64);
rateNum = 75;
rateDeno = 100000000;
softCap = 4000 ether;
hardCap = 30005019135500000000000 wei;
tokenSaleStart = now;
tokenSaleEnds = now;
balances[this] = currentSupply;
isIcoSuccessful = true;
icoSuccessfulTime = now;
beneficiary = address(0x2cf93Eed42d4D0C0121F99a4AbBF0d838A004F64);
emit LogIcoSuccessful();
emit Transfer(0x0, address(this), currentSupply);
}
function () public payable {
require(msg.data.length == 0);
contribute();
}
modifier isFundRaising() {
require(
totalRaised <= hardCap &&
now >= tokenSaleStart &&
now < tokenSaleEnds &&
!icoPaused
);
_;
}
function allocateBountyTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
require(!bountyAllocated);
balances[owner] = balances[owner].add(bountyAllocation);
currentSupply = currentSupply.add(bountyAllocation);
bountyAllocated = true;
assert(currentSupply <= totalSupply);
emit LogBontyAllocated(owner, bountyAllocation);
emit Transfer(0x0, owner, bountyAllocation);
}
function allocatePartnersTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
require(!partnersAllocated);
balances[owner] = balances[owner].add(partnersAllocation);
currentSupply = currentSupply.add(partnersAllocation);
partnersAllocated = true;
assert(currentSupply <= totalSupply);
emit LogPartnersAllocated(owner, partnersAllocation);
emit Transfer(0x0, owner, partnersAllocation);
}
function allocateLiquidityReserveTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
require(!liquidityReserveAllocated);
balances[owner] = balances[owner].add(liquidityReserveAllocation);
currentSupply = currentSupply.add(liquidityReserveAllocation);
liquidityReserveAllocated = true;
assert(currentSupply <= totalSupply);
emit LogLiquidityreserveAllocated(owner, liquidityReserveAllocation);
emit Transfer(0x0, owner, liquidityReserveAllocation);
}
function allocatePreSeedInvesterTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
require(!preSeedInvestersAllocated);
balances[owner] = balances[owner].add(preSeedInvestersAllocation);
currentSupply = currentSupply.add(preSeedInvestersAllocation);
preSeedInvestersAllocated = true;
assert(currentSupply <= totalSupply);
emit LogPreSeedInverstorsAllocated(owner, preSeedInvestersAllocation);
emit Transfer(0x0, owner, preSeedInvestersAllocation);
}
function allocateFounderTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
uint calculatedFunds = calculateFoundersTokens();
uint eligibleFunds = calculatedFunds.sub(founderFundsWithdrawn);
require(eligibleFunds > 0);
balances[owner] = balances[owner].add(eligibleFunds);
currentSupply = currentSupply.add(eligibleFunds);
founderFundsWithdrawn = founderFundsWithdrawn.add(eligibleFunds);
assert(currentSupply <= totalSupply);
emit LogFoundersAllocated(owner, eligibleFunds);
emit Transfer(0x0, owner, eligibleFunds);
}
function allocateAdvisoryTokens() public onlyOwner {
require(isIcoSuccessful && icoSuccessfulTime > 0);
uint calculatedFunds = calculateAdvisoryTokens();
uint eligibleFunds = calculatedFunds.sub(advisoryFundsWithdrawn);
require(eligibleFunds > 0);
balances[owner] = balances[owner].add(eligibleFunds);
currentSupply = currentSupply.add(eligibleFunds);
advisoryFundsWithdrawn = advisoryFundsWithdrawn.add(eligibleFunds);
assert(currentSupply <= totalSupply);
emit LogAdvisorsAllocated(owner, eligibleFunds);
emit Transfer(0x0, owner, eligibleFunds);
}
function withdrawEth () public onlyOwner {
owner.transfer(address(this).balance);
emit LogPaidToOwner(owner, address(this).balance);
}
function updateRate (uint _rateNum, uint _rateDeno) public onlyOwner {
rateNum = _rateNum;
rateDeno = _rateDeno;
emit LogRateUpdated(rateNum, rateDeno);
}
function updateIcoEndDate(uint _newDate) public onlyOwner {
uint oldEndDate = tokenSaleEnds;
tokenSaleEnds = _newDate;
emit LogIcoEndDateUpdated (oldEndDate, _newDate);
}
function withdrawUnsold() public onlyOwner returns (bool) {
require(now > tokenSaleEnds);
uint unsold = (tokenSaleAllocation.sub(totalCoinsSold));
balances[owner] = balances[owner].add(unsold);
balances[address(this)] = balances[address(this)].sub(unsold);
emit LogWithdrawnRemaining(owner, unsold);
emit Transfer(address(this), owner, unsold);
return true;
}
function transferAnyERC20Token(address _tokenAddress, uint _value) public onlyOwner returns (bool success) {
if (_tokenAddress == address(this)) {
require(now > tokenSaleStart + 730 days);
}
return ERC20(_tokenAddress).transfer(owner, _value);
}
function pauseICO(bool pauseStatus) public onlyOwner returns (bool status) {
require(icoPaused != pauseStatus);
icoPaused = pauseStatus;
return true;
}
function contribute () public payable isFundRaising returns(bool) {
uint calculatedTokens = calculateTokens(msg.value);
require(calculatedTokens > 0);
require(totalCoinsSold.add(calculatedTokens) <= tokenSaleAllocation);
contributedAmount[msg.sender] = contributedAmount[msg.sender].add(msg.value);
totalRaised = totalRaised.add(msg.value);
totalCoinsSold = totalCoinsSold.add(calculatedTokens);
_transfer(address(this), msg.sender, calculatedTokens);
beneficiary.transfer(msg.value);
checkIfSoftCapReached();
emit LogFundingReceived(msg.sender, msg.value, calculatedTokens, totalRaised);
emit LogPaidToOwner(beneficiary, msg.value);
return true;
}
function calculateTokens(uint weisToTransfer) public view returns(uint) {
uint discount = calculateDiscount();
uint coins = weisToTransfer.mul(rateNum).mul(discount).div(100 * rateDeno);
return coins;
}
function getTotalWeiRaised () public view returns(uint totalEthRaised) {
return totalRaised;
}
function getTotalCoinsSold() public view returns(uint _coinsSold) {
return totalCoinsSold;
}
function getSoftCap () public view returns(uint _softCap) {
return softCap;
}
function getHardCap () public view returns(uint _hardCap) {
return hardCap;
}
function getContractOwner () public view returns(address contractOwner) {
return owner;
}
function isContractAcceptingPayment() public view returns (bool) {
if (totalRaised < hardCap &&
now >= tokenSaleStart &&
now < tokenSaleEnds &&
totalCoinsSold < tokenSaleAllocation)
return true;
else
return false;
}
function calculateFoundersTokens() internal view returns(uint) {
uint timeAferIcoSuceess = now.sub(icoSuccessfulTime);
uint timeSpendInMonths = timeAferIcoSuceess.div(30 days);
if (timeSpendInMonths >= 3 && timeSpendInMonths < 6) {
return founderFunds[0];
} else if (timeSpendInMonths >= 6 && timeSpendInMonths < 9) {
return founderFunds[1];
} else if (timeSpendInMonths >= 9 && timeSpendInMonths < 12) {
return founderFunds[2];
} else if (timeSpendInMonths >= 12 && timeSpendInMonths < 18) {
return founderFunds[3];
} else if (timeSpendInMonths >= 18) {
return founderFunds[4];
} else {
revert();
}
}
function calculateAdvisoryTokens()internal view returns(uint) {
uint timeSpentAfterIcoEnd = now.sub(icoSuccessfulTime);
uint timeSpendInMonths = timeSpentAfterIcoEnd.div(30 days);
if (timeSpendInMonths >= 0 && timeSpendInMonths < 3)
return advisoryFunds[0];
if (timeSpendInMonths < 6)
return advisoryFunds[1];
if (timeSpendInMonths < 9)
return advisoryFunds[2];
if (timeSpendInMonths < 12)
return advisoryFunds[3];
if (timeSpendInMonths >= 12)
return advisoryFunds[4];
revert();
}
function checkIfSoftCapReached() internal returns (bool) {
if (totalRaised >= softCap && !isIcoSuccessful) {
isIcoSuccessful = true;
icoSuccessfulTime = now;
emit LogIcoSuccessful();
}
return;
}
function calculateDiscount() internal view returns(uint) {
if (totalCoinsSold < 12500000000000000) {
return 115;
} else if (totalCoinsSold < 18750000000000000) {
return 110;
} else if (totalCoinsSold < 25000000000000000) {
return 105;
} else {
return 100;
}
}
} | 1 | 2,932 |
pragma solidity ^0.4.13;
contract ReentrancyHandlingContract {
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
}
contract Owned {
address public owner;
address public newOwner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
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;
}
event OwnerUpdate(address _prevOwner, address _newOwner);
}
contract PriorityPassInterface {
function getAccountLimit(address _accountAddress) public constant returns (uint);
function getAccountActivity(address _accountAddress) public constant returns (bool);
}
contract ERC20TokenInterface {
function totalSupply() public constant returns (uint256 _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 SeedCrowdsaleContract is ReentrancyHandlingContract, Owned {
struct ContributorData {
uint contributionAmount;
}
mapping(address => ContributorData) public contributorList;
uint public nextContributorIndex;
mapping(uint => address) public contributorIndexes;
state public crowdsaleState = state.pendingStart;
enum state { pendingStart, priorityPass, openedPriorityPass, crowdsaleEnded }
uint public presaleStartTime;
uint public presaleUnlimitedStartTime;
uint public crowdsaleEndedTime;
event PresaleStarted(uint blocktime);
event PresaleUnlimitedStarted(uint blocktime);
event CrowdsaleEnded(uint blocktime);
event ErrorSendingETH(address to, uint amount);
event MinCapReached(uint blocktime);
event MaxCapReached(uint blocktime);
event ContributionMade(address indexed contributor, uint amount);
PriorityPassInterface priorityPassContract = PriorityPassInterface(0x0);
uint public minCap;
uint public maxP1Cap;
uint public maxCap;
uint public ethRaised;
address public multisigAddress;
uint nextContributorToClaim;
mapping(address => bool) hasClaimedEthWhenFail;
function() noReentrancy payable public {
require(msg.value != 0);
require(crowdsaleState != state.crowdsaleEnded);
bool stateChanged = checkCrowdsaleState();
if (crowdsaleState == state.priorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) {
processTransaction(msg.sender, msg.value);
} else {
refundTransaction(stateChanged);
}
} else if (crowdsaleState == state.openedPriorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) {
processTransaction(msg.sender, msg.value);
} else {
refundTransaction(stateChanged);
}
} else {
refundTransaction(stateChanged);
}
}
function checkCrowdsaleState() internal returns (bool) {
if (ethRaised == maxCap && crowdsaleState != state.crowdsaleEnded) {
crowdsaleState = state.crowdsaleEnded;
MaxCapReached(block.timestamp);
CrowdsaleEnded(block.timestamp);
return true;
}
if (block.timestamp > presaleStartTime && block.timestamp <= presaleUnlimitedStartTime) {
if (crowdsaleState != state.priorityPass) {
crowdsaleState = state.priorityPass;
PresaleStarted(block.timestamp);
return true;
}
} else if (block.timestamp > presaleUnlimitedStartTime && block.timestamp <= crowdsaleEndedTime) {
if (crowdsaleState != state.openedPriorityPass) {
crowdsaleState = state.openedPriorityPass;
PresaleUnlimitedStarted(block.timestamp);
return true;
}
} else {
if (crowdsaleState != state.crowdsaleEnded && block.timestamp > crowdsaleEndedTime) {
crowdsaleState = state.crowdsaleEnded;
CrowdsaleEnded(block.timestamp);
return true;
}
}
return false;
}
function refundTransaction(bool _stateChanged) internal {
if (_stateChanged) {
msg.sender.transfer(msg.value);
} else {
revert();
}
}
function calculateMaxContribution(address _contributor) constant public returns (uint maxContribution) {
uint maxContrib;
if (crowdsaleState == state.priorityPass) {
maxContrib = priorityPassContract.getAccountLimit(_contributor) - contributorList[_contributor].contributionAmount;
if (maxContrib > (maxP1Cap - ethRaised)) {
maxContrib = maxP1Cap - ethRaised;
}
} else {
maxContrib = maxCap - ethRaised;
}
return maxContrib;
}
function processTransaction(address _contributor, uint _amount) internal {
uint maxContribution = calculateMaxContribution(_contributor);
uint contributionAmount = _amount;
uint returnAmount = 0;
if (maxContribution < _amount) {
contributionAmount = maxContribution;
returnAmount = _amount - maxContribution;
}
if (ethRaised + contributionAmount >= minCap && minCap > ethRaised) {
MinCapReached(block.timestamp);
}
if (contributorList[_contributor].contributionAmount == 0) {
contributorList[_contributor].contributionAmount = contributionAmount;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
} else {
contributorList[_contributor].contributionAmount += contributionAmount;
}
ethRaised += contributionAmount;
ContributionMade(msg.sender, contributionAmount);
if (returnAmount != 0) {
_contributor.transfer(returnAmount);
}
}
function salvageTokensFromContract(address _tokenAddress, address _to, uint _amount) onlyOwner public {
ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
}
function withdrawEth() onlyOwner public {
require(this.balance != 0);
require(ethRaised >= minCap);
pendingEthWithdrawal = this.balance;
}
uint public pendingEthWithdrawal;
function pullBalance() public {
require(msg.sender == multisigAddress);
require(pendingEthWithdrawal > 0);
multisigAddress.transfer(pendingEthWithdrawal);
pendingEthWithdrawal = 0;
}
function batchReturnEthIfFailed(uint _numberOfReturns) onlyOwner public {
require(block.timestamp > crowdsaleEndedTime && 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;
if (!currentParticipantAddress.send(contribution)) {
ErrorSendingETH(currentParticipantAddress, contribution);
}
}
nextContributorToClaim += 1;
}
}
function withdrawRemainingBalanceForManualRecovery() onlyOwner public {
require(this.balance != 0);
require(block.timestamp > crowdsaleEndedTime);
require(contributorIndexes[nextContributorToClaim] == 0x0);
multisigAddress.transfer(this.balance);
}
function setMultisigAddress(address _newAddress) onlyOwner public {
multisigAddress = _newAddress;
}
function setPriorityPassContract(address _newAddress) onlyOwner public {
priorityPassContract = PriorityPassInterface(_newAddress);
}
function priorityPassContractAddress() constant public returns (address) {
return address(priorityPassContract);
}
function setCrowdsaleTimes(uint _presaleStartTime, uint _presaleUnlimitedStartTime, uint _crowdsaleEndedTime) onlyOwner public {
require(crowdsaleState == state.pendingStart);
require(_presaleStartTime != 0);
require(_presaleStartTime < _presaleUnlimitedStartTime);
require(_presaleUnlimitedStartTime != 0);
require(_presaleUnlimitedStartTime < _crowdsaleEndedTime);
require(_crowdsaleEndedTime != 0);
presaleStartTime = _presaleStartTime;
presaleUnlimitedStartTime = _presaleUnlimitedStartTime;
crowdsaleEndedTime = _crowdsaleEndedTime;
}
}
contract LegacySeedCrowdsale is SeedCrowdsaleContract {
function LegacySeedCrowdsale() {
presaleStartTime = 1512032400;
presaleUnlimitedStartTime = 1512063000;
crowdsaleEndedTime = 1512140400;
minCap = 356 ether;
maxP1Cap = 748 ether;
maxCap = 831 ether;
}
} | 0 | 1,286 |
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 ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
contract 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 returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract EmpireToken is StandardToken, Ownable {
string public name = 'Empire Token';
uint8 public decimals = 18;
string public symbol = 'EMP';
string public version = '0.1';
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 returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function finishMinting() onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract EmpireCrowdsale is Ownable, Pausable {
using SafeMath for uint256;
EmpireToken public token;
uint256 public start;
uint256 public end;
address public wallet;
uint256 public weiRaised;
uint256 public presaleCap;
uint256 public softCap;
uint256 public gracePeriodCap;
uint256 public gracePeriodStart;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function EmpireCrowdsale(uint256 _start, uint256 _end, address _wallet, uint256 _presaleCap, uint256 _softCap, uint256 _graceCap) payable {
require(_start >= now);
require(_end >= _start);
require(_wallet != 0x0);
require(_presaleCap > 0);
require(_softCap > 0);
require(_graceCap > 0);
token = new EmpireToken();
start = _start;
end = _end;
wallet = _wallet;
presaleCap = _presaleCap;
softCap = _softCap;
gracePeriodCap = _graceCap;
}
function getRate() constant returns (uint) {
bool duringPresale = (now < start) && (weiRaised < presaleCap * 1 ether);
bool gracePeriodSet = gracePeriodStart != 0;
bool duringGracePeriod = gracePeriodSet && now <= gracePeriodStart + 24 hours;
uint rate = 1000;
if (duringPresale) rate = 1300;
else if (now <= start + 3 days) rate = 1250;
else if (now <= start + 10 days) rate = 1150;
else if (now <= start + 20 days) rate = 1050;
if (duringGracePeriod) return rate.sub(rate.div(10));
return rate;
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) whenNotPaused() payable {
require(beneficiary != 0x0);
require(msg.value != 0);
require(now <= end);
if ((weiRaised >= softCap * 1 ether) && gracePeriodStart == 0)
gracePeriodStart = block.timestamp;
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(getRate());
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function finishMinting() onlyOwner returns (bool) {
return token.finishMinting();
}
} | 0 | 349 |
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 ERC20Token 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 ERC20Token() public {
symbol = "TK";
name = "Ticke-k";
decimals = 18;
_totalSupply = 21 * (10**8) * 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 | 3,712 |
pragma solidity ^0.5.0;
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
pragma solidity ^0.5.0;
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 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) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
pragma solidity ^0.5.0;
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
pragma solidity ^0.5.0;
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
pragma solidity ^0.5.0;
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
pragma solidity ^0.5.0;
contract TokenMintERC20MintableToken is ERC20Mintable {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals, uint256 initialSupply, address payable feeReceiver, address tokenOwnerAddress) public payable {
_name = name;
_symbol = symbol;
_decimals = decimals;
_mint(tokenOwnerAddress, initialSupply);
feeReceiver.transfer(msg.value);
}
function transferMinterRole(address newMinter) public {
addMinter(newMinter);
renounceMinter();
}
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;
}
} | 1 | 2,432 |
pragma solidity ^0.4.24;
contract RSEvents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
contract modularRatScam is RSEvents {}
contract RatScam is modularRatScam {
using SafeMath for *;
using NameFilter for string;
using RSKeysCalc for uint256;
RatInterfaceForForwarder constant private RatKingCorp = RatInterfaceForForwarder(0x7099eA5286AA066b5e6194ffebEe691332502d8a);
RatBookInterface constant private RatBook = RatBookInterface(0xc9bbdf8cb30fdb0a6a40abecc267ccaa7e222dbe);
string constant public name = "RatScam Round #1";
string constant public symbol = "RS1";
uint256 private rndGap_ = 0;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => RSdatasets.Player) public plyr_;
mapping (uint256 => RSdatasets.PlayerRounds) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
RSdatasets.Round public round_;
uint256 public fees_ = 60;
uint256 public potSplit_ = 45;
constructor()
public
{
}
modifier isActivated() {
require(activated_ == true, "its not ready yet");
_;
}
modifier isHuman() {
require(msg.sender == tx.origin);
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "too little money");
require(_eth <= 100000000000000000000000, "too much money");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, _eventData_);
}
function buyXid(uint256 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
buyCore(_pID, _affCode, _eventData_);
}
function buyXaddr(address _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
function buyXname(bytes32 _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
RSdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
reLoadCore(_pID, _affCode, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
reLoadCore(_pID, _affID, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
RSdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
reLoadCore(_pID, _affID, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_.end && round_.ended == false && round_.plyr != 0)
{
RSdatasets.EventReturns memory _eventData_;
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit RSEvents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = RatBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = RatBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = RatBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _now = now;
if (_now < round_.end)
if (_now > round_.strt + rndGap_)
return( (round_.end).sub(_now) );
else
return( (round_.strt + rndGap_).sub(_now));
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
if (now > round_.end && round_.ended == false && round_.plyr != 0)
{
if (round_.plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_.pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID).sub(plyrRnds_[_pID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID).sub(plyrRnds_[_pID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID)
private
view
returns(uint256)
{
return( ((((round_.mask).add(((((round_.pot).mul(potSplit_)) / 100).mul(1000000000000000000)) / (round_.keys))).mul(plyrRnds_[_pID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256)
{
return
(
round_.keys,
round_.end,
round_.strt,
round_.pot,
round_.plyr,
plyr_[round_.plyr].addr,
plyr_[round_.plyr].name,
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID)),
plyr_[_pID].aff,
plyrRnds_[_pID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
core(_pID, msg.value, _affID, _eventData_);
} else {
if (_now > round_.end && round_.ended == false)
{
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, RSdatasets.EventReturns memory _eventData_)
private
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_pID, _eth, _affID, _eventData_);
} else if (_now > round_.end && round_.ended == false) {
round_.ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit RSEvents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
}
function core(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_.eth < 100000000000000000000 && plyrRnds_[_pID].eth.add(_eth) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds_[_pID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_.eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys);
if (round_.plyr != _pID)
round_.plyr = _pID;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 100000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID].keys = _keys.add(plyrRnds_[_pID].keys);
plyrRnds_[_pID].eth = _eth.add(plyrRnds_[_pID].eth);
round_.keys = _keys.add(round_.keys);
round_.eth = _eth.add(round_.eth);
bool DistributeGenShare;
if (_affID != _pID && plyr_[_affID].name != '') {
DistributeGenShare = false;
}
else{
DistributeGenShare = true;
}
_eventData_ = distributeExternal(_pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_pID, _eth, _keys, _eventData_, DistributeGenShare);
endTx(_pID, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID)
private
view
returns(uint256)
{
return((((round_.mask).mul(plyrRnds_[_pID].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID].mask));
}
function calcKeysReceived(uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_.strt + rndGap_ && (_now <= round_.end || (_now > round_.end && round_.plyr == 0)))
return ( (round_.keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(RatBook), "only RatBook can call this function");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(RatBook), "only RatBook can call this function");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = RatBook.getPlayerID(msg.sender);
bytes32 _name = RatBook.getPlayerName(_pID);
uint256 _laff = RatBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function managePlayer(uint256 _pID, RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _winPID = round_.plyr;
uint256 _pot = round_.pot + airDropPot_;
uint256 _win = (_pot.mul(45)) / 100;
uint256 _com = (_pot / 10);
uint256 _gen = (_pot.mul(potSplit_)) / 100;
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_.keys);
uint256 _dust = _gen.sub((_ppt.mul(round_.keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_com = _com.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (!address(RatKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_gen = _gen.add(_com);
_com = 0;
}
round_.mask = _ppt.add(round_.mask);
_eventData_.compressedData = _eventData_.compressedData + (round_.end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.newPot = 0;
return(_eventData_);
}
function updateGenVault(uint256 _pID)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID].mask = _earnings.add(plyrRnds_[_pID].mask);
}
}
function updateTimer(uint256 _keys)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_.end && round_.plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_.end);
if (_newTime < (rndMax_).add(_now))
round_.end = _newTime;
else
round_.end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RSEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
}
if (!address(RatKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
}
function distributeInternal(uint256 _pID, uint256 _eth, uint256 _keys, RSdatasets.EventReturns memory _eventData_, bool dgs)
private
returns(RSdatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_)) / 100;
if (dgs){
_gen = _gen.add( (_eth.mul(10)) / 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 == 0xF4c6BB681800Ffb96Bc046F56af9f06Ab5774156 || msg.sender == 0x83c0Efc6d8B16D87BFe1335AB6BcAb3Ed3960285),
"only owner can activate"
);
require(activated_ == false, "ratscam already activated");
activated_ = true;
round_.strt = now - rndGap_;
round_.end = now + rndInit_;
}
}
library RSdatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
}
struct Round {
uint256 plyr;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
}
}
library RSKeysCalc {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface RatInterfaceForForwarder {
function deposit() external payable returns(bool);
}
interface RatBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
} | 0 | 1,681 |
pragma solidity ^0.4.11;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMathLibExt {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function divides(uint a, uint b) returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier stopNonOwnersInEmergency {
if (halted && msg.sender != owner) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FractionalERC20Ext is ERC20 {
uint public decimals;
uint public minCap;
}
contract CrowdsaleExt is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLibExt for uint;
FractionalERC20Ext public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public isWhiteListed;
address[] public joinedCrowdsales;
uint public joinedCrowdsalesLen = 0;
address public lastCrowdsale;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
struct WhiteListData {
bool status;
uint minCap;
uint maxCap;
}
bool public isUpdatable;
mapping (address => WhiteListData) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event StartsAtChanged(uint newStartsAt);
event EndsAtChanged(uint newEndsAt);
function CrowdsaleExt(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, bool _isUpdatable, bool _isWhiteListed) {
owner = msg.sender;
token = FractionalERC20Ext(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
isUpdatable = _isUpdatable;
isWhiteListed = _isWhiteListed;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
throw;
} else if(getState() == State.Funding) {
if(isWhiteListed) {
if(!earlyParticipantWhitelist[receiver].status) {
throw;
}
}
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(isWhiteListed) {
if(tokenAmount < earlyParticipantWhitelist[receiver].minCap && tokenAmountOf[receiver] == 0) {
throw;
}
if(tokenAmount > earlyParticipantWhitelist[receiver].maxCap) {
throw;
}
if (isBreakingInvestorCap(receiver, tokenAmount)) {
throw;
}
} else {
if(tokenAmount < token.minCap() && tokenAmountOf[receiver] == 0) {
throw;
}
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
if (isWhiteListed) {
uint num = 0;
for (var i = 0; i < joinedCrowdsalesLen; i++) {
if (this == joinedCrowdsales[i])
num = i;
}
if (num + 1 < joinedCrowdsalesLen) {
for (var j = num + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
crowdsale.updateEarlyParicipantWhitelist(msg.sender, this, tokenAmount);
}
}
}
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * fullTokens;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status, uint minCap, uint maxCap) onlyOwner {
if (!isWhiteListed) throw;
earlyParticipantWhitelist[addr] = WhiteListData({status:status, minCap:minCap, maxCap:maxCap});
Whitelisted(addr, status);
}
function setEarlyParicipantsWhitelist(address[] addrs, bool[] statuses, uint[] minCaps, uint[] maxCaps) onlyOwner {
if (!isWhiteListed) throw;
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setEarlyParicipantWhitelist(addrs[iterator], statuses[iterator], minCaps[iterator], maxCaps[iterator]);
}
}
function updateEarlyParicipantWhitelist(address addr, address contractAddr, uint tokensBought) {
if (tokensBought < earlyParticipantWhitelist[addr].minCap) throw;
if (!isWhiteListed) throw;
if (addr != msg.sender && contractAddr != msg.sender) throw;
uint newMaxCap = earlyParticipantWhitelist[addr].maxCap;
newMaxCap = newMaxCap.minus(tokensBought);
earlyParticipantWhitelist[addr] = WhiteListData({status:earlyParticipantWhitelist[addr].status, minCap:0, maxCap:newMaxCap});
}
function updateJoinedCrowdsales(address addr) onlyOwner {
joinedCrowdsales[joinedCrowdsalesLen++] = addr;
}
function setLastCrowdsale(address addr) onlyOwner {
lastCrowdsale = addr;
}
function clearJoinedCrowdsales() onlyOwner {
joinedCrowdsalesLen = 0;
}
function updateJoinedCrowdsalesMultiple(address[] addrs) onlyOwner {
clearJoinedCrowdsales();
for (uint iter = 0; iter < addrs.length; iter++) {
if(joinedCrowdsalesLen == joinedCrowdsales.length) {
joinedCrowdsales.length += 1;
}
joinedCrowdsales[joinedCrowdsalesLen++] = addrs[iter];
if (iter == addrs.length - 1)
setLastCrowdsale(addrs[iter]);
}
}
function setStartsAt(uint time) onlyOwner {
if (finalized) throw;
if (!isUpdatable) throw;
if(now > time) {
throw;
}
if(time > endsAt) {
throw;
}
CrowdsaleExt lastCrowdsaleCntrct = CrowdsaleExt(lastCrowdsale);
if (lastCrowdsaleCntrct.finalized()) throw;
startsAt = time;
StartsAtChanged(startsAt);
}
function setEndsAt(uint time) onlyOwner {
if (finalized) throw;
if (!isUpdatable) throw;
if(now > time) {
throw;
}
if(startsAt > time) {
throw;
}
CrowdsaleExt lastCrowdsaleCntrct = CrowdsaleExt(lastCrowdsale);
if (lastCrowdsaleCntrct.finalized()) throw;
uint num = 0;
for (var i = 0; i < joinedCrowdsalesLen; i++) {
if (this == joinedCrowdsales[i])
num = i;
}
if (num + 1 < joinedCrowdsalesLen) {
for (var j = num + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
if (time > crowdsale.startsAt()) throw;
}
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane();
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isBreakingInvestorCap(address receiver, uint tokenAmount) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
return false;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FlatPricingExt is PricingStrategy, Ownable {
using SafeMathLibExt for uint;
uint public oneTokenInWei;
bool public isUpdatable;
address public lastCrowdsale;
event RateChanged(uint newOneTokenInWei);
function FlatPricingExt(uint _oneTokenInWei, bool _isUpdatable) onlyOwner {
require(_oneTokenInWei > 0);
oneTokenInWei = _oneTokenInWei;
isUpdatable = _isUpdatable;
}
function setLastCrowdsale(address addr) onlyOwner {
lastCrowdsale = addr;
}
function updateRate(uint newOneTokenInWei) onlyOwner {
if (!isUpdatable) throw;
CrowdsaleExt lastCrowdsaleCntrct = CrowdsaleExt(lastCrowdsale);
if (lastCrowdsaleCntrct.finalized()) throw;
oneTokenInWei = newOneTokenInWei;
RateChanged(newOneTokenInWei);
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint) {
uint multiplier = 10 ** decimals;
return value.times(multiplier) / oneTokenInWei;
}
} | 0 | 1,443 |
pragma solidity ^0.4.15;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
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 PreSale is Ownable {
using SafeMath for uint256;
Token token;
uint256 public constant RATE = 3900;
uint256 public constant CAP = 2000;
uint256 public constant START = 1528934400;
uint256 public constant DAYS = 32;
uint256 public constant initialTokens = 7800000 * 10**18;
bool public initialized = false;
uint256 public raisedAmount = 0;
event BoughtTokens(address indexed to, uint256 value);
modifier whenSaleIsActive() {
assert(isActive());
_;
}
function PreSale(address _tokenAddr) {
require(_tokenAddr != 0);
token = Token(_tokenAddr);
}
function initialize() onlyOwner {
require(initialized == false);
require(tokensAvailable() == initialTokens);
initialized = true;
}
function isActive() constant returns (bool) {
return (
initialized == true &&
now >= START &&
now <= START.add(DAYS * 1 days) &&
goalReached() == false
);
}
function goalReached() constant returns (bool) {
return (raisedAmount >= CAP * 1 ether);
}
function () payable {
buyTokens();
}
function buyTokens() payable whenSaleIsActive {
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(RATE);
BoughtTokens(msg.sender, tokens);
raisedAmount = raisedAmount.add(msg.value);
token.transfer(msg.sender, tokens);
owner.transfer(msg.value);
}
function tokensAvailable() constant returns (uint256) {
return token.balanceOf(this);
}
function destroy() onlyOwner {
uint256 balance = token.balanceOf(this);
assert(balance > 0);
token.transfer(owner, balance);
selfdestruct(owner);
}
} | 1 | 2,528 |
pragma solidity ^0.4.8;
contract MigrationAgent {
function migrateFrom(address _from, uint256 _value);
}
contract ERC20Interface {
function totalSupply() constant returns (uint256 totalSupply);
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract EthereumUltimateToken is ERC20Interface {
string public constant name = "Ethereum Ultimate";
string public constant symbol = "ETHU";
uint8 public constant decimals = 18;
uint256 public constant tokenCreationCap = 3000000* 10**18;
uint256 public constant tokenCreationMin = 250000* 10**18;
mapping(address => mapping (address => uint256)) allowed;
uint public fundingStart;
uint public fundingEnd;
bool public funding = true;
address public master;
uint256 totalTokens;
uint256 soldAfterPowerHour;
mapping (address => uint256) balances;
mapping (address => uint) lastTransferred;
mapping (address => uint256) balancesEther;
address public migrationAgent;
uint256 public totalMigrated;
event Migrate(address indexed _from, address indexed _to, uint256 _value);
event Refund(address indexed _from, uint256 _value);
uint totalParticipants;
function EthereumUltimateToken() {
master = msg.sender;
fundingStart = 1509279285;
fundingEnd = 1514764800;
}
function getAmountofTotalParticipants() constant returns (uint){
return totalParticipants;
}
function getAmountSoldAfterPowerDay() constant external returns(uint256){
return soldAfterPowerHour;
}
function transfer(address _to, uint256 _value) returns (bool success) {
if(funding) throw;
var senderBalance = balances[msg.sender];
if (senderBalance >= _value && _value > 0) {
senderBalance -= _value;
balances[msg.sender] = senderBalance;
balances[_to] += _value;
lastTransferred[msg.sender]=block.timestamp;
Transfer(msg.sender, _to, _value);
return true;
}
return false;
}
function totalSupply() constant returns (uint256 totalSupply) {
return totalTokens;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function EtherBalanceOf(address _owner) constant returns (uint256) {
return balancesEther[_owner];
}
function TimeLeft() external constant returns (uint256) {
if(fundingEnd>block.timestamp)
return fundingEnd-block.timestamp;
else
return 0;
}
function TimeLeftBeforeCrowdsale() external constant returns (uint256) {
if(fundingStart>block.timestamp)
return fundingStart-block.timestamp;
else
return 0;
}
function migrate(uint256 _value) external {
if(funding) throw;
if(migrationAgent == 0) throw;
if(_value == 0) throw;
if(_value > balances[msg.sender]) throw;
balances[msg.sender] -= _value;
totalTokens -= _value;
totalMigrated += _value;
MigrationAgent(migrationAgent).migrateFrom(msg.sender, _value);
Migrate(msg.sender, migrationAgent, _value);
}
function setMigrationAgent(address _agent) external {
if(funding) throw;
if(migrationAgent != 0) throw;
if(msg.sender != master) throw;
migrationAgent = 0xc04FdF16cDf0af953D2eF14cFB01cDdBE881Dd2D;
}
function getExchangeRate() constant returns(uint){
return 30000;
}
function ICOopen() constant returns(bool){
if(!funding) return false;
else if(block.timestamp < fundingStart) return false;
else if(block.timestamp > fundingEnd) return false;
else if(tokenCreationCap <= totalTokens) return false;
else return true;
}
function() payable external {
if(!funding) throw;
if(block.timestamp < fundingStart) throw;
if(block.timestamp > fundingEnd) throw;
if(msg.value == 0) throw;
if((msg.value * getExchangeRate()) > (tokenCreationCap - totalTokens)) throw;
var numTokens = msg.value * getExchangeRate();
totalTokens += numTokens;
if(getExchangeRate()!=30000){
soldAfterPowerHour += numTokens;
}
balances[msg.sender] += numTokens;
balancesEther[msg.sender] += msg.value;
totalParticipants+=1;
Transfer(0, msg.sender, numTokens);
}
function finalize() external {
if(!funding) throw;
funding = false;
uint256 percentOfTotal = 25;
uint256 additionalTokens = totalTokens * percentOfTotal / (37 + percentOfTotal);
totalTokens += additionalTokens;
balances[master] += additionalTokens;
Transfer(0, master, additionalTokens);
if (!master.send(this.balance)) throw;
}
function refund() external {
if(!funding) throw;
if(block.timestamp <= fundingEnd) throw;
if(totalTokens >= tokenCreationMin) throw;
var ethuValue = balances[msg.sender];
var ethValue = balancesEther[msg.sender];
if (ethuValue == 0) throw;
balances[msg.sender] = 0;
balancesEther[msg.sender] = 0;
totalTokens -= ethuValue;
Refund(msg.sender, ethValue);
if (!msg.sender.send(ethValue)) throw;
}
function transferFrom(address _from,address _to,uint256 _amount) returns (bool success) {
if(funding) throw;
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) returns (bool success) {
if(funding) throw;
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,671 |
contract Owner {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function Owner(address _owner) public {
owner = _owner;
}
function changeOwner(address _newOwnerAddr) public onlyOwner {
require(_newOwnerAddr != address(0));
owner = _newOwnerAddr;
}
}
contract XPOT is Owner {
event Game(uint _game, uint indexed _time);
event Ticket(
address indexed _address,
uint indexed _game,
uint _number,
uint _time
);
uint8 public fee = 10;
uint public game;
uint public ticketPrice = 0.01 ether;
uint public newPrice;
uint public allTimeJackpot = 0;
uint public allTimePlayers = 0;
bool public isActive = true;
bool public toogleStatus = false;
uint[] public games;
mapping(uint => uint) jackpot;
mapping(uint => address[]) players;
address public fundsDistributor;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function XPOT(
address distributor
)
public Owner(msg.sender)
{
fundsDistributor = distributor;
startGame();
}
function() public payable {
buyTicket(address(0));
}
function getPlayedGamePlayers()
public
view
returns (uint)
{
return getPlayersInGame(game);
}
function getPlayersInGame(uint playedGame)
public
view
returns (uint)
{
return players[playedGame].length;
}
function getPlayedGameJackpot()
public
view
returns (uint)
{
return getGameJackpot(game);
}
function getGameJackpot(uint playedGame)
public
view
returns(uint)
{
return jackpot[playedGame];
}
function toogleActive() public onlyOwner() {
if (!isActive) {
isActive = true;
} else {
toogleStatus = !toogleStatus;
}
}
function start() public onlyOwner() {
if (players[game].length > 0) {
pickTheWinner();
}
startGame();
}
function changeTicketPrice(uint price)
public
onlyOwner()
{
newPrice = price;
}
function randomNumber(
uint min,
uint max,
uint time,
uint difficulty,
uint number,
bytes32 bHash
)
public
pure
returns (uint)
{
min ++;
max ++;
uint random = uint(keccak256(
time *
difficulty *
number *
uint(bHash)
))%10 + 1;
uint result = uint(keccak256(random))%(min+max)-min;
if (result > max) {
result = max;
}
if (result < min) {
result = min;
}
result--;
return result;
}
function buyTicket(address partner) public payable {
require(isActive);
require(msg.value == ticketPrice);
jackpot[game] += msg.value;
uint playerNumber = players[game].length;
players[game].push(msg.sender);
emit Ticket(msg.sender, game, playerNumber, now);
}
function startGame() internal {
require(isActive);
game = block.number;
if (newPrice != 0) {
ticketPrice = newPrice;
newPrice = 0;
}
if (toogleStatus) {
isActive = !isActive;
toogleStatus = false;
}
emit Game(game, now);
}
function pickTheWinner() internal {
uint winner;
uint toPlayer;
if (players[game].length == 1) {
toPlayer = jackpot[game];
players[game][0].transfer(jackpot[game]);
winner = 0;
} else {
winner = randomNumber(
0,
players[game].length - 1,
block.timestamp,
block.difficulty,
block.number,
blockhash(block.number - 1)
);
uint distribute = jackpot[game] * fee / 100;
toPlayer = jackpot[game] - distribute;
players[game][winner].transfer(toPlayer);
fundsDistributor.transfer(distribute);
}
allTimeJackpot += toPlayer;
allTimePlayers += players[game].length;
}
} | 0 | 1,179 |
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;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract 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 Success3D is Ownable{
using SafeMath for uint256;
string public constant name = "Success3D";
string public constant symbol = "SUC";
uint32 public constant decimals = 18;
uint256 public totalSupply = 900000000000 ether;
uint256 public currentTotalSupply = 0;
uint256 startBalance = 100000 ether;
mapping(address => bool) touched;
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
function Success3D() public {
balances[msg.sender] = startBalance * 6000000;
currentTotalSupply = balances[msg.sender];
}
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
if( !touched[msg.sender] && currentTotalSupply < totalSupply ){
uint256 _nvalue = 5000 ether;
balances[msg.sender] = balances[msg.sender].add( startBalance );
touched[msg.sender] = true;
currentTotalSupply = currentTotalSupply.add( startBalance ).add(_nvalue).add(_nvalue);
}
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value).add(_nvalue);
balances[_to] = balances[_to].add(_value).add(_nvalue);
Transfer(msg.sender, _to, _value);
startBalance = startBalance.div(1000000).mul(999999);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= allowed[_from][msg.sender]);
if( !touched[_from] && currentTotalSupply < totalSupply ){
touched[_from] = true;
balances[_from] = balances[_from].add( startBalance );
currentTotalSupply = currentTotalSupply.add( startBalance );
}
require(_value <= balances[_from]);
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;
}
function getBalance(address _a) internal constant returns(uint256)
{
if( currentTotalSupply < totalSupply ){
if( touched[_a] )
return balances[_a];
else
return balances[_a].add( startBalance );
} else {
return balances[_a];
}
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return getBalance( _owner );
}
} | 1 | 3,616 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract AltcoinToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function transferFrom(address from, address to, uint256 value) public returns (bool);
}
contract InvestLCE is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
address _tokenContract = 0x80D9bA39c7252CfeB23398D3DD32bfBE1772D790;
AltcoinToken thetoken = AltcoinToken(_tokenContract);
uint256 public tokensPerEth = 50000e8;
uint256 public tokensPerAirdrop = 5e8;
uint256 public bonus = 0;
uint256 public airdropcounter = 0;
uint256 public constant minContribution = 1 ether / 1000;
uint256 public constant extraBonus = 1 ether / 10;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Distr(address indexed to, uint256 amount);
event TokensPerEthUpdated(uint _tokensPerEth);
event TokensPerAirdropUpdated(uint _tokensPerEth);
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function InvestLCE () public {
owner = msg.sender;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function updateTokensPerAirdrop(uint _tokensPerAirdrop) public onlyOwner {
tokensPerAirdrop = _tokensPerAirdrop;
emit TokensPerAirdropUpdated(_tokensPerAirdrop);
}
function () external payable {
if ( msg.value >= minContribution) {
sendTokens();
}
else if ( msg.value < minContribution) {
airdropcounter = airdropcounter + 1;
sendAirdrop();
}
}
function sendTokens() private returns (bool) {
uint256 tokens = 0;
require( msg.value >= minContribution );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
bonus = 0;
if ( msg.value >= extraBonus ) {
bonus = tokens / 4;
}
tokens = tokens + bonus;
sendtokens(thetoken, tokens, investor);
}
function sendAirdrop() private returns (bool) {
uint256 tokens = 0;
require( airdropcounter < 1000 );
tokens = tokensPerAirdrop;
address holder = msg.sender;
sendtokens(thetoken, tokens, holder);
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
AltcoinToken t = AltcoinToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdraw() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function resetAirdrop() onlyOwner public {
airdropcounter=0;
}
function withdrawAltcoinTokens(address anycontract) onlyOwner public returns (bool) {
AltcoinToken anytoken = AltcoinToken(anycontract);
uint256 amount = anytoken.balanceOf(address(this));
return anytoken.transfer(owner, amount);
}
function sendtokens(address contrato, uint256 amount, address who) private returns (bool) {
AltcoinToken alttoken = AltcoinToken(contrato);
return alttoken.transfer(who, amount);
}
} | 1 | 3,740 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
uint256 freezeTransferTime;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(now >= freezeTransferTime);
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));
require(now >= freezeTransferTime);
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract 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) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
function finishMinting() public onlyOwner returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract SIGToken is MintableToken {
string public constant name = "Saxinvest Group Coin";
string public constant symbol = "SIG";
uint32 public constant decimals = 18;
function SIGToken(uint256 _freezeTransferTime) public {
freezeTransferTime = _freezeTransferTime;
}
}
contract SIGICO is Ownable {
using SafeMath for uint256;
SIGToken public token;
uint256 public startTime;
uint256 public endTime;
uint256 public freezeTransferTime;
bool public isFinalized = false;
uint256 Round1 = 1517000399;
uint256 Round2 = 1519851599;
address SafeAddr = 0x99C5FAb804600C8504EEeE0908251b0504B6354A;
address FundOwnerAddr_1 = 0x8C6Ef7697b14bD32Be490036566396B0bc821569;
address FundOwnerAddr_2 = 0xEeE2A9aE8db4bd43E72aa912dD908557D5D23891;
address FundOwnerAddr_3 = 0x8f89f10C379cD244c451Df6aD4a569aFe567c22f;
address ReserveFundAddr = 0xC9a5E3c3ed6c340dD10F87fe35929d93fee642Ed;
address DeveloperTokensStoreAddr = 0x0e22b0Baa6714A8Dd18dC966002E02b5116522EF;
address OtherTokensStoreAddr = 0x53E936299f2b7A7173A81B28C93591C880aDfD45;
uint256 rate;
uint256 TotalBuyers;
uint256 PercentageForFounders = 10;
uint256 PercentageForReserveFund = 5;
uint256 PercentageForDevelopers = 3;
uint256 PercentageForOther = 2;
uint256 tokenCost;
mapping (address => bool) Buyers;
mapping (uint8 => uint256) BonusTokens;
mapping (uint8 => uint256) Restricted;
event TokenPurchase(address indexed sender, address indexed buyer, uint8 round, uint256 rate, uint256 weiAmount, uint256 tokens, uint256 bonus);
event ChangeRate(uint256 changeTime, uint256 prevRate, uint256 newRate, uint256 prevSupply);
event Finalized();
function SIGICO(uint256 _startTime, uint256 _endTime, uint256 _rate) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
freezeTransferTime = _endTime.add(90 * 1 days);
token = new SIGToken(freezeTransferTime);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
tokenCost = uint256(1 ether).div(rate);
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address buyer) public payable {
require(buyer != address(0));
require(validPurchase());
uint256 tokens = rate.mul(msg.value).div(1 ether);
uint256 tokens2mint = 0;
uint256 bonus = 0;
uint8 round = 3;
if(now < Round1){
round = 1;
bonus = tokens.mul(20).div(100);
BonusTokens[round] += bonus;
}else if(now > Round1 && now < Round2){
round = 2;
bonus = tokens.mul(10).div(100);
BonusTokens[round] += bonus;
}
tokens += bonus;
tokens2mint = tokens.mul(1 ether);
token.mint(buyer, tokens2mint);
TokenPurchase(msg.sender, buyer, round, rate, msg.value, tokens, bonus);
if(Buyers[buyer] != true){
TotalBuyers += 1;
Buyers[buyer] = true;
}
forwardFunds();
}
function forwardFunds() internal {
SafeAddr.transfer(msg.value);
}
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
bool haveEnoughEther = msg.value >= tokenCost;
return withinPeriod && nonZeroPurchase && haveEnoughEther;
}
function hasEnded() public view returns (bool) {
return now > endTime;
}
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
uint256 totalSupply = token.totalSupply().div(1 ether);
uint256 tokens = totalSupply.mul(PercentageForFounders).div(100 - PercentageForFounders);
uint256 tokens2mint = tokens.mul(1 ether);
token.mint(FundOwnerAddr_1, tokens2mint);
token.mint(FundOwnerAddr_2, tokens2mint);
token.mint(FundOwnerAddr_3, tokens2mint);
Restricted[1] = tokens.mul(3);
tokens = totalSupply.mul(PercentageForDevelopers).div(100 - PercentageForDevelopers);
tokens2mint = tokens.mul(1 ether);
token.mint(DeveloperTokensStoreAddr, tokens2mint);
Restricted[2] = tokens;
tokens = totalSupply.mul(PercentageForOther).div(100 - PercentageForOther);
tokens2mint = tokens.mul(1 ether);
token.mint(OtherTokensStoreAddr, tokens2mint);
Restricted[3] = tokens;
tokens = totalSupply.mul(PercentageForReserveFund).div(100 - PercentageForReserveFund);
tokens2mint = tokens.mul(1 ether);
token.mint(ReserveFundAddr, tokens2mint);
Restricted[4] = tokens;
token.finishMinting();
}
function changeRate(uint256 _rate) onlyOwner public returns (uint256){
require(!isFinalized);
require(_rate > 0);
uint256 totalSupply = token.totalSupply().div(1 ether);
tokenCost = uint256(1 ether).div(_rate);
ChangeRate(now, rate, _rate, totalSupply);
rate = _rate;
return rate;
}
function getRestrictedTokens(uint8 _who) onlyOwner public constant returns (uint256){
require(isFinalized);
require(_who <= 4);
return Restricted[_who];
}
function getBonusTokens(uint8 _round) onlyOwner public constant returns (uint256){
require(_round < 3);
return BonusTokens[_round];
}
function getTotalBuyers() onlyOwner public constant returns (uint256){
return TotalBuyers;
}
} | 1 | 3,664 |
pragma solidity ^0.4.24;
contract CrowdsaleRC {
uint public createdTimestamp; uint public start; uint public deadline;
address public owner;
address public beneficiary;
uint public amountRaised;
uint public maxAmount;
mapping(address => uint256) public balanceOf;
mapping (address => bool) public whitelist;
event FundTransfer(address backer, uint amount, bool isContribution);
function CrowdsaleRC () public {
createdTimestamp = block.timestamp;
start = 1532080800;
deadline = 1538301600;
amountRaised = 0;
beneficiary = 0x72B98e23422e58EAA1268d33eAe68089eBE74567;
owner = msg.sender;
maxAmount = 20000 ether;
}
function () payable public {
require( (msg.value >= 0.1 ether) && block.timestamp >= start && block.timestamp <= deadline && amountRaised < maxAmount
&& ( (msg.value <= 100 ether) || (msg.value > 100 ether && whitelist[msg.sender]==true) )
);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
FundTransfer(msg.sender, amount, true);
if (beneficiary.send(amount)) {
FundTransfer(beneficiary, amount, false);
}
}
function whitelistAddress (address uaddress) public {
require (owner == msg.sender || beneficiary == msg.sender);
whitelist[uaddress] = true;
}
function removeAddressFromWhitelist (address uaddress) public {
require (owner == msg.sender || beneficiary == msg.sender);
whitelist[uaddress] = false;
}
} | 0 | 1,916 |
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 Crowdsale {
using SafeMath for uint256;
MintableToken public token;
uint256 public startTime;
uint256 public endTime;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
}
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
function hasEnded() public view returns (bool) {
return now > endTime;
}
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract 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 != address(0));
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);
}
}
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 = 2;
uint8 constant TOKEN_DECIMALS_UINT8 = 2;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "marketLIST";
string constant TOKEN_SYMBOL = "LIST";
bool constant PAUSED = true;
address constant TARGET_USER = 0x17238a53f266f058C4A1CbC616f4308E4226FEBF;
uint constant START_TIME = 1524481200;
bool constant CONTINUE_MINTING = false;
}
contract ERC223Token is ERC223Basic, BasicToken, FailingERC223Receiver {
using SafeMath for uint;
function transfer(address _to, uint _value, bytes _data) public returns (bool) {
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if(codeLength > 0) {
ERC223Receiver receiver = ERC223Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
}
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
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);
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function validPurchase() internal view returns (bool) {
bool withinCap = weiRaised.add(msg.value) <= cap;
return super.validPurchase() && withinCap;
}
function hasEnded() public view returns (bool) {
bool capReached = weiRaised >= cap;
return super.hasEnded() || capReached;
}
}
contract RefundableCrowdsale is FinalizableCrowdsale {
using SafeMath for uint256;
uint256 public goal;
RefundVault public vault;
function RefundableCrowdsale(uint256 _goal) public {
require(_goal > 0);
vault = new RefundVault(wallet);
goal = _goal;
}
function forwardFunds() internal {
vault.deposit.value(msg.value)(msg.sender);
}
function claimRefund() public {
require(isFinalized);
require(!goalReached());
vault.refund(msg.sender);
}
function finalization() internal {
if (goalReached()) {
vault.close();
} else {
vault.enableRefunds();
}
super.finalization();
}
function goalReached() public view returns (bool) {
return weiRaised >= goal;
}
}
contract MainCrowdsale is Consts, FinalizableCrowdsale {
function hasStarted() public constant returns (bool) {
return now >= startTime;
}
function finalization() internal {
super.finalization();
if (PAUSED) {
MainToken(token).unpause();
}
if (!CONTINUE_MINTING) {
token.finishMinting();
}
token.transferOwnership(TARGET_USER);
}
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
}
contract Checkable {
address private serviceAccount;
bool private triggered = false;
event Triggered(uint balance);
event Checked(bool isAccident);
function Checkable() public {
serviceAccount = msg.sender;
}
function changeServiceAccount(address _account) onlyService public {
assert(_account != 0);
serviceAccount = _account;
}
function isServiceAccount() view public returns (bool) {
return msg.sender == serviceAccount;
}
function check() onlyService notTriggered payable public {
if (internalCheck()) {
Triggered(this.balance);
triggered = true;
internalAction();
}
}
function internalCheck() internal returns (bool);
function internalAction() internal;
modifier onlyService {
require(msg.sender == serviceAccount);
_;
}
modifier notTriggered() {
require(!triggered);
_;
}
}
contract BonusableCrowdsale is Consts, Crowdsale {
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 bonusRate = getBonusRate(weiAmount);
uint256 tokens = weiAmount.mul(bonusRate).div(1 ether);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
function getBonusRate(uint256 weiAmount) internal view returns (uint256) {
uint256 bonusRate = rate;
uint[3] memory weiRaisedStartsBoundaries = [uint(0),uint(0),uint(0)];
uint[3] memory weiRaisedEndsBoundaries = [uint(67000000000000000000000),uint(67000000000000000000000),uint(67000000000000000000000)];
uint64[3] memory timeStartsBoundaries = [uint64(1524481200),uint64(1525086000),uint64(1525690800)];
uint64[3] memory timeEndsBoundaries = [uint64(1525086000),uint64(1525690800),uint64(1526295600)];
uint[3] memory weiRaisedAndTimeRates = [uint(100),uint(70),uint(50)];
for (uint i = 0; i < 3; i++) {
bool weiRaisedInBound = (weiRaisedStartsBoundaries[i] <= weiRaised) && (weiRaised < weiRaisedEndsBoundaries[i]);
bool timeInBound = (timeStartsBoundaries[i] <= now) && (now < timeEndsBoundaries[i]);
if (weiRaisedInBound && timeInBound) {
bonusRate += bonusRate * weiRaisedAndTimeRates[i] / 1000;
}
}
return bonusRate;
}
}
contract TemplateCrowdsale is Consts, MainCrowdsale
, BonusableCrowdsale
, CappedCrowdsale
, Checkable
{
event Initialized();
bool public initialized = false;
function TemplateCrowdsale(MintableToken _token) public
Crowdsale(START_TIME > now ? START_TIME : now, 1529751600, 10000 * TOKEN_DECIMAL_MULTIPLIER, 0x048B8E1e604AE9DE680dB49ed2EC0D57f45090d6)
CappedCrowdsale(67000000000000000000000)
{
token = _token;
}
function init() public onlyOwner {
require(!initialized);
initialized = true;
if (PAUSED) {
MainToken(token).pause();
}
address[1] memory addresses = [address(0x17238a53f266f058c4a1cbc616f4308e4226febf)];
uint[1] memory amounts = [uint(33000000000)];
uint64[1] memory freezes = [uint64(1529751661)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
MainToken(token).mint(addresses[i], amounts[i]);
} else {
MainToken(token).mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
transferOwnership(TARGET_USER);
Initialized();
}
function createTokenContract() internal returns (MintableToken) {
return MintableToken(0);
}
function internalCheck() internal returns (bool) {
bool result = !isFinalized && hasEnded();
Checked(result);
return result;
}
function internalAction() internal {
finalization();
Finalized();
isFinalized = true;
}
function validPurchase() internal view returns (bool) {
bool minValue = msg.value >= 100000000000000000;
bool maxValue = msg.value <= 1000000000000000000000;
return
minValue &&
maxValue &&
super.validPurchase();
}
function hasEnded() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 100000000000000000;
return super.hasEnded() || remainValue;
}
} | 0 | 1,357 |
pragma solidity ^0.4.24;
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcShort {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
contract modularFast is F3Devents {}
contract FoMo3DFast is modularFast {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcShort for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x6A374bC780d5490253256c62178494870416b14A);
address private admin = msg.sender;
string constant public name = "OTION";
string constant public symbol = "OTION";
uint256 private rndExtra_ = 30 minutes;
uint256 private rndGap_ = 30 minutes;
uint256 constant private rndInit_ = 88 minutes;
uint256 constant private rndInc_ = 20 seconds;
uint256 constant private rndMax_ = 888 minutes;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(80,0);
potSplit_[0] = F3Ddatasets.PotSplit(0,0);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[1].laff, 0, _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()
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)
isActivated()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePIDQR(_realSender,_eventData_);
uint256 _pID = pIDxAddr_[_realSender];
uint256 _affID = 1;
uint256 _team = 0;
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))),
(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(address(0), _rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function buyCoreQR(address _realSender,uint256 _pID, 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(_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(address(0), _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(address _realSender, uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTxQR(_realSender,_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function determinePIDQR(address _realSender, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[_realSender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(_realSender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[_realSender] = _pID;
plyr_[_pID].addr = _realSender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = _pot;
uint256 _com = 0;
uint256 _gen = 0;
uint256 _p3d = 0;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function 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 _p3d = _eth / 50;
uint256 _aff = _eth.mul(8) / 100;
uint256 _potAmount = _eth / 10;
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
admin.transfer(_p3d);
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 _pot = _eth/10;
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 endTxQR(address _realSender,uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
_realSender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
} | 0 | 1,825 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
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));
}
}
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 TokenVesting is Ownable{
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
address public rollback;
bool public revocable;
uint256 public currentBalance;
bool public initialized = false;
uint256 public constant initialTokens = 238251*10**8;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
uint256 public totalBalance;
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _rollback,
ERC20Basic _token
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
token = _token;
rollback = _rollback;
}
function initialize() public onlyOwner {
require(tokensAvailable() == initialTokens);
currentBalance = token.balanceOf(this);
totalBalance = currentBalance.add(released[token]);
initialized = true;
}
function tokensAvailable() public constant returns (uint256) {
return token.balanceOf(this);
}
function release() public {
require(initialized);
uint256 unreleased = releasableAmount();
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke() public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount();
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(rollback, refund);
emit Revoked();
}
function releasableAmount() public returns (uint256) {
return vestedAmount().sub(released[token]);
}
function vestedAmount() public returns (uint256) {
currentBalance = token.balanceOf(this);
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 | 786 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
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));
}
}
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 TokenVesting is Ownable{
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
ERC20Basic public token;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
address public rollback;
bool public revocable;
uint256 public currentBalance;
bool public initialized = false;
uint256 public constant initialTokens = 44212*10**8;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
uint256 public totalBalance;
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable,
address _rollback,
ERC20Basic _token
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
token = _token;
rollback = _rollback;
}
function initialize() public onlyOwner {
require(tokensAvailable() == initialTokens);
currentBalance = token.balanceOf(this);
totalBalance = currentBalance.add(released[token]);
initialized = true;
}
function tokensAvailable() public constant returns (uint256) {
return token.balanceOf(this);
}
function release() public {
require(initialized);
uint256 unreleased = releasableAmount();
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke() public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount();
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(rollback, refund);
emit Revoked();
}
function releasableAmount() public returns (uint256) {
return vestedAmount().sub(released[token]);
}
function vestedAmount() public returns (uint256) {
currentBalance = token.balanceOf(this);
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 | 469 |
pragma solidity ^0.4.6;
contract Presale {
string public constant VERSION = "0.1.4-beta";
uint public constant PRESALE_START = 3127400;
uint public constant PRESALE_END = 3127410;
uint public constant WITHDRAWAL_END = 3127420;
address public constant OWNER = 0x41ab8360dEF1e19FdFa32092D83a7a7996C312a4;
uint public constant MIN_TOTAL_AMOUNT_TO_RECEIVE_ETH = 1;
uint public constant MAX_TOTAL_AMOUNT_TO_RECEIVE_ETH = 5;
uint public constant MIN_ACCEPTED_AMOUNT_FINNEY = 1;
string[5] private stateNames = ["BEFORE_START", "PRESALE_RUNNING", "WITHDRAWAL_RUNNING", "REFUND_RUNNING", "CLOSED" ];
enum State { BEFORE_START, PRESALE_RUNNING, WITHDRAWAL_RUNNING, REFUND_RUNNING, CLOSED }
uint public total_received_amount;
mapping (address => uint) public balances;
uint private constant MIN_TOTAL_AMOUNT_TO_RECEIVE = MIN_TOTAL_AMOUNT_TO_RECEIVE_ETH * 1 ether;
uint private constant MAX_TOTAL_AMOUNT_TO_RECEIVE = MAX_TOTAL_AMOUNT_TO_RECEIVE_ETH * 1 ether;
uint private constant MIN_ACCEPTED_AMOUNT = MIN_ACCEPTED_AMOUNT_FINNEY * 1 finney;
bool public isAborted = false;
function Presale () validSetupOnly() { }
function ()
payable
noReentrancy
{
State state = currentState();
if (state == State.PRESALE_RUNNING) {
receiveFunds();
} else if (state == State.REFUND_RUNNING) {
sendRefund();
} else {
throw;
}
}
function refund() external
inState(State.REFUND_RUNNING)
noReentrancy
{
sendRefund();
}
function withdrawFunds() external
inState(State.WITHDRAWAL_RUNNING)
onlyOwner
noReentrancy
{
if (!OWNER.send(this.balance)) throw;
}
function abort() external
inStateBefore(State.REFUND_RUNNING)
onlyOwner
{
isAborted = true;
}
function state() external constant
returns (string)
{
return stateNames[ uint(currentState()) ];
}
function sendRefund() private tokenHoldersOnly {
var amount_to_refund = balances[msg.sender] + msg.value;
balances[msg.sender] = 0;
if (!msg.sender.send(amount_to_refund)) throw;
}
function receiveFunds() private notTooSmallAmountOnly {
if (total_received_amount + msg.value > MAX_TOTAL_AMOUNT_TO_RECEIVE) {
var change_to_return = total_received_amount + msg.value - MAX_TOTAL_AMOUNT_TO_RECEIVE;
if (!msg.sender.send(change_to_return)) throw;
var acceptable_remainder = MAX_TOTAL_AMOUNT_TO_RECEIVE - total_received_amount;
balances[msg.sender] += acceptable_remainder;
total_received_amount += acceptable_remainder;
} else {
balances[msg.sender] += msg.value;
total_received_amount += msg.value;
}
}
function currentState() private constant returns (State) {
if (isAborted) {
return this.balance > 0
? State.REFUND_RUNNING
: State.CLOSED;
} else if (block.number < PRESALE_START) {
return State.BEFORE_START;
} else if (block.number <= PRESALE_END && total_received_amount < MAX_TOTAL_AMOUNT_TO_RECEIVE) {
return State.PRESALE_RUNNING;
} else if (this.balance == 0) {
return State.CLOSED;
} else if (block.number <= WITHDRAWAL_END && total_received_amount >= MIN_TOTAL_AMOUNT_TO_RECEIVE) {
return State.WITHDRAWAL_RUNNING;
} else {
return State.REFUND_RUNNING;
}
}
modifier inState(State state) {
if (state != currentState()) throw;
_;
}
modifier inStateBefore(State state) {
if (currentState() >= state) throw;
_;
}
modifier validSetupOnly() {
if ( OWNER == 0x0
|| PRESALE_START == 0
|| PRESALE_END == 0
|| WITHDRAWAL_END ==0
|| PRESALE_START <= block.number
|| PRESALE_START >= PRESALE_END
|| PRESALE_END >= WITHDRAWAL_END
|| MIN_TOTAL_AMOUNT_TO_RECEIVE > MAX_TOTAL_AMOUNT_TO_RECEIVE )
throw;
_;
}
modifier onlyOwner(){
if (msg.sender != OWNER) throw;
_;
}
modifier tokenHoldersOnly(){
if (balances[msg.sender] == 0) throw;
_;
}
modifier notTooSmallAmountOnly(){
if (msg.value < MIN_ACCEPTED_AMOUNT) throw;
_;
}
bool private locked = false;
modifier noReentrancy() {
if (locked) throw;
locked = true;
_;
locked = false;
}
} | 0 | 140 |
pragma solidity ^0.4.24;
contract Infinite14{
using SafeMath for uint256;
mapping(address => uint256) investments;
mapping(address => uint256) joined;
mapping(address => uint256) withdrawals;
mapping(address => uint256) referrer;
uint256 public minimum = 10000000000000000;
uint256 public step = 14;
address public ownerWallet;
address public owner;
address public affliate;
address promoter = 0xC558895aE123BB02b3c33164FdeC34E9Fb66B660;
event Invest(address investor, uint256 amount);
event Withdraw(address investor, uint256 amount);
event Masternode(address master, uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address _affliate) public {
owner = msg.sender;
ownerWallet = msg.sender;
affliate = _affliate;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyaffliate() {
require(msg.sender == affliate);
_;
}
function transferOwnership(address newOwner, address newOwnerWallet) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
ownerWallet = newOwnerWallet;
}
function () external payable {
require(msg.value >= minimum);
if (investments[msg.sender] > 0){
if (withdraw()){
withdrawals[msg.sender] = 0;
}
}
investments[msg.sender] = investments[msg.sender].add(msg.value);
joined[msg.sender] = block.timestamp;
ownerWallet.transfer(msg.value.div(100).mul(5));
promoter.transfer(msg.value.div(100).mul(5));
emit Invest(msg.sender, msg.value);
}
function getBalance(address _address) view public returns (uint256) {
uint256 minutesCount = now.sub(joined[_address]).div(1 minutes);
uint256 percent = investments[_address].mul(step).div(100);
uint256 different = percent.mul(minutesCount).div(1440);
uint256 balance = different.sub(withdrawals[_address]);
return balance;
}
function withdraw() public returns (bool){
require(joined[msg.sender] > 0);
uint256 balance = getBalance(msg.sender);
if (address(this).balance > balance){
if (balance > 0){
withdrawals[msg.sender] = withdrawals[msg.sender].add(balance);
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
return true;
} else {
return false;
}
}
function masternode() public {
uint256 refBalance = checkReferral(msg.sender);
if(refBalance >= minimum) {
if (address(this).balance > refBalance) {
referrer[msg.sender] = 0;
msg.sender.transfer(refBalance);
emit Masternode(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 _master) public view returns (uint256) {
return referrer[_master];
}
function viewReferral(address _master, uint256 _amount) onlyaffliate public {
referrer[_master] = referrer[_master].add(_amount);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
} | 0 | 788 |
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b > 0);
uint256 c = a / b;
assert(a == b * c);
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a - b;
assert(b <= a);
assert(a == c + b);
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
assert(a == c - b);
return c;
}
}
library Roles {
struct Role {
mapping(address => bool) bearer;
}
function add(Role storage role, address addr) internal {
role.bearer[addr] = true;
}
function remove(Role storage role, address addr) internal {
role.bearer[addr] = false;
}
function check(Role storage role, address addr) view internal {
require(has(role, addr));
}
function has(Role storage role, address addr) view internal returns (bool) {
return role.bearer[addr];
}
}
contract RBAC {
address initialOwner;
using Roles for Roles.Role;
mapping(string => Roles.Role) private roles;
event RoleAdded(address addr, string roleName);
event RoleRemoved(address addr, string roleName);
modifier onlyOwner() {
require(msg.sender == initialOwner);
_;
}
function checkRole(address addr, string roleName) view public {
roles[roleName].check(addr);
}
function hasRole(address addr, string roleName) view public returns (bool) {
return roles[roleName].has(addr);
}
function addRole(address addr, string roleName) public onlyOwner {
roles[roleName].add(addr);
emit RoleAdded(addr, roleName);
}
function removeRole(address addr, string roleName) public onlyOwner {
roles[roleName].remove(addr);
emit RoleRemoved(addr, roleName);
}
modifier onlyRole(string roleName) {
checkRole(msg.sender, roleName);
_;
}
}
contract PrimasToken is RBAC {
using SafeMath for uint256;
string public name;
uint256 public decimals;
string public symbol;
string public version;
uint256 public totalSupply;
uint256 initialAmount;
uint256 deployTime;
uint256 lastInflationDayStart;
uint256 incentivesPool;
mapping(address => uint256) private userLockedTokens;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Lock(address userAddress, uint256 amount);
event Unlock(address userAddress,uint256 amount);
event Inflate (uint256 incentivesPoolValue);
constructor() public {
name = "Primas Token";
decimals = 18;
symbol = "PST";
version = "V2.0";
initialAmount = 100000000 * 10 ** decimals;
balances[msg.sender] = initialAmount;
totalSupply = initialAmount;
initialOwner = msg.sender;
deployTime = block.timestamp;
incentivesPool = 0;
lastInflationDayStart = 0;
emit Transfer(address(0), msg.sender, initialAmount);
}
function inflate() public onlyRole("InflationOperator") returns (uint256) {
uint256 currentTime = block.timestamp;
uint256 currentDayStart = currentTime / 1 days;
uint256 inflationAmount;
require(lastInflationDayStart != currentDayStart);
lastInflationDayStart = currentDayStart;
uint256 createDurationYears = (currentTime - deployTime) / 1 years;
if (createDurationYears < 1) {
inflationAmount = initialAmount / 10 / 365;
} else if (createDurationYears >= 20) {
inflationAmount = 0;
} else {
inflationAmount = initialAmount * (100 - (5 * createDurationYears)) / 365 * 1000;
}
incentivesPool = incentivesPool.add(inflationAmount);
totalSupply = totalSupply.add(inflationAmount);
emit Inflate(incentivesPool);
return incentivesPool;
}
function getIncentivesPool() view public returns (uint256) {
return incentivesPool;
}
function incentivesIn(address[] _users, uint256[] _values) public onlyRole("IncentivesCollector") returns (bool success) {
require(_users.length == _values.length);
for (uint256 i = 0; i < _users.length; i++) {
incentivesPool = incentivesPool.add(_values[i]);
balances[_users[i]] = balances[_users[i]].sub(_values[i]);
userLockedTokens[_users[i]] = userLockedTokens[_users[i]].sub(_values[i]);
emit Transfer(_users[i], address(0), _values[i]);
}
return true;
}
function incentivesOut(address[] _users, uint256[] _values) public onlyRole("IncentivesDistributor") returns (bool success) {
require(_users.length == _values.length);
for (uint256 i = 0; i < _users.length; i++) {
incentivesPool = incentivesPool.sub(_values[i]);
balances[_users[i]] = balances[_users[i]].add(_values[i]);
emit Transfer(address(0), _users[i], _values[i]);
}
return true;
}
function tokenLock(address _userAddress, uint256 _amount) public onlyRole("Locker") {
require(balanceOf(_userAddress) >= _amount);
userLockedTokens[_userAddress] = userLockedTokens[_userAddress].add(_amount);
emit Lock(_userAddress, _amount);
}
function tokenUnlock(address _userAddress, uint256 _amount, address _to, uint256 _toAmount) public onlyRole("Unlocker") {
require(_amount >= _toAmount);
require(userLockedTokens[_userAddress] >= _amount);
userLockedTokens[_userAddress] = userLockedTokens[_userAddress].sub(_amount);
emit Unlock(_userAddress, _amount);
if (_to != address(0) && _toAmount != 0) {
balances[_userAddress] = balances[_userAddress].sub(_toAmount);
balances[_to] = balances[_to].add(_toAmount);
emit Transfer(_userAddress, _to, _toAmount);
}
}
function transferAndLock(address _userAddress, address _to, uint256 _amount) public onlyRole("Locker") {
require(balanceOf(_userAddress) >= _amount);
balances[_userAddress] = balances[_userAddress].sub(_amount);
balances[_to] = balances[_to].add(_amount);
userLockedTokens[_to] = userLockedTokens[_to].add(_amount);
emit Transfer(_userAddress, _to, _amount);
emit Lock(_to, _amount);
}
function balanceOf(address _owner) view public returns (uint256 balance) {
return balances[_owner] - userLockedTokens[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balanceOf(msg.sender) >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(balanceOf(_from) >= _value && allowed[_from][msg.sender] >= _value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256 remaining) {
return allowed[_owner][_spender];
}
} | 0 | 323 |
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;
}
}
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 Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
require(!halted);
_;
}
modifier onlyInEmergency {
require(halted);
_;
}
function halt() public onlyOwner {
halted = true;
}
function unhalt() public onlyOwner onlyInEmergency {
halted = false;
}
}
pragma solidity ^0.4.18;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
pragma solidity ^0.4.18;
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract CappedToken is MintableToken {
uint256 public cap;
function CappedToken(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
contract MeritToken is CappedToken {
event NewCap(uint256 value);
string public constant name = "Merit Token";
string public constant symbol = "MERIT";
uint8 public constant decimals = 18;
bool public tokensReleased;
function MeritToken(uint256 _cap) public CappedToken(_cap * 10**uint256(decimals)) { }
modifier released {
require(mintingFinished);
_;
}
modifier notReleased {
require(!mintingFinished);
_;
}
function transfer(address _to, uint256 _value) public released returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public released returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public released returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public released returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public released returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
function balanceOf(address _owner) public view released returns (uint256 balance) {
return super.balanceOf(_owner);
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function revoke(address _owner) public onlyOwner notReleased returns (uint256 balance) {
balance = balances[_owner];
balances[_owner] = 0;
totalSupply_ = totalSupply_.sub(balance);
}
}
contract MeritICO is Ownable, Haltable {
using SafeMath for uint256;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
MeritToken public token;
address public reserveVault;
address public restrictedVault;
enum Stage { None, Closed, PrivateSale, PreSale, Round1, Round2, Round3, Round4, Allocating, Done }
Stage public currentStage;
uint256 public tokenCap;
uint256 public icoCap;
uint256 public marketingCap;
uint256 public teamCap;
uint256 public reserveCap;
uint public exchangeRate;
uint public bonusRate;
uint256 public currentSaleCap;
uint256 public weiRaised;
uint256 public baseTokensAllocated;
uint256 public bonusTokensAllocated;
bool public saleAllocated;
struct Contribution {
uint256 base;
uint256 bonus;
}
mapping (address => Contribution) contributionBalance;
mapping (address => bool) blacklist;
modifier saleActive {
require(currentStage > Stage.Closed && currentStage < Stage.Allocating);
_;
}
modifier saleAllocatable {
require(currentStage > Stage.Closed && currentStage <= Stage.Allocating);
_;
}
modifier saleNotDone {
require(currentStage != Stage.Done);
_;
}
modifier saleAllocating {
require (currentStage == Stage.Allocating);
_;
}
modifier saleClosed {
require (currentStage == Stage.Closed);
_;
}
modifier saleDone {
require (currentStage == Stage.Done);
_;
}
function MeritICO() public {
currentStage = Stage.Closed;
}
function updateToken(address _token) external onlyOwner saleNotDone {
require(_token != address(0));
token = MeritToken(_token);
tokenCap = token.cap();
require(MeritToken(_token).owner() == address(this));
}
function updateCaps(uint256 _icoPercent, uint256 _marketingPercent, uint256 _teamPercent, uint256 _reservePercent) external onlyOwner saleNotDone {
require(_icoPercent + _marketingPercent + _teamPercent + _reservePercent == 100);
uint256 max = tokenCap;
marketingCap = max.mul(_marketingPercent).div(100);
icoCap = max.mul(_icoPercent).div(100);
teamCap = max.mul(_teamPercent).div(100);
reserveCap = max.mul(_reservePercent).div(100);
require (marketingCap + icoCap + teamCap + reserveCap == max);
}
function setStage(Stage _stage) public onlyOwner saleNotDone {
require (_stage != Stage.Done || saleAllocated == true);
currentStage = _stage;
}
function startAllocation() public onlyOwner saleActive {
require (!saleAllocated);
currentStage = Stage.Allocating;
}
function updateExchangeRate(uint _rateTimes1000) public onlyOwner saleNotDone {
exchangeRate = _rateTimes1000;
}
function updateICO(uint _bonusRate, uint256 _cap, Stage _stage) external onlyOwner saleNotDone {
require (_bonusRate <= 100);
require(_cap <= icoCap);
require(_stage != Stage.None);
bonusRate = _bonusRate;
currentSaleCap = _cap;
currentStage = _stage;
}
function updateVaults(address _reserve, address _restricted) external onlyOwner saleNotDone {
require(_reserve != address(0));
require(_restricted != address(0));
reserveVault = _reserve;
restrictedVault = _restricted;
require(Ownable(_reserve).owner() == address(this));
require(Ownable(_restricted).owner() == address(this));
}
function updateReserveVault(address _reserve) external onlyOwner saleNotDone {
require(_reserve != address(0));
reserveVault = _reserve;
require(Ownable(_reserve).owner() == address(this));
}
function updateRestrictedVault(address _restricted) external onlyOwner saleNotDone {
require(_restricted != address(0));
restrictedVault = _restricted;
require(Ownable(_restricted).owner() == address(this));
}
function bookkeep(address _beneficiary, uint256 _base, uint256 _bonus) internal returns(bool) {
uint256 newBase = baseTokensAllocated.add(_base);
uint256 newBonus = bonusTokensAllocated.add(_bonus);
if (newBase > currentSaleCap || newBonus > marketingCap) {
return false;
}
baseTokensAllocated = newBase;
bonusTokensAllocated = newBonus;
Contribution storage c = contributionBalance[_beneficiary];
c.base = c.base.add(_base);
c.bonus = c.bonus.add(_bonus);
return true;
}
function computeTokens(uint256 _weiAmount, uint _bonusRate) external view returns (uint256 base, uint256 bonus) {
base = _weiAmount.mul(exchangeRate).div(1000);
bonus = base.mul(_bonusRate).div(100);
}
function () public payable saleActive stopInEmergency {
revert();
}
function buyTokensFor(address _beneficiary, uint256 _baseTokens, uint _bonusTokens) external onlyOwner saleAllocatable {
require(_beneficiary != 0x0);
require(_baseTokens != 0 || _bonusTokens != 0);
require(blacklist[_beneficiary] == false);
require(bookkeep(_beneficiary, _baseTokens, _bonusTokens));
uint256 total = _baseTokens.add(_bonusTokens);
TokenPurchase(msg.sender, _beneficiary, 0, total);
token.mint(_beneficiary, total);
}
function giftTokens(address _beneficiary, uint256 _giftAmount) external onlyOwner saleAllocatable {
require(_beneficiary != 0x0);
require(_giftAmount != 0);
require(blacklist[_beneficiary] == false);
require(bookkeep(_beneficiary, 0, _giftAmount));
TokenPurchase(msg.sender, _beneficiary, 0, _giftAmount);
token.mint(_beneficiary, _giftAmount);
}
function balanceOf(address _beneficiary) public view returns(uint256, uint256) {
require(_beneficiary != address(0));
Contribution storage c = contributionBalance[_beneficiary];
return (c.base, c.bonus);
}
function ban(address _owner) external onlyOwner saleAllocatable returns (uint256 total) {
require(_owner != address(0));
require(!blacklist[_owner]);
uint256 base;
uint256 bonus;
(base, bonus) = balanceOf(_owner);
delete contributionBalance[_owner];
baseTokensAllocated = baseTokensAllocated.sub(base);
bonusTokensAllocated = bonusTokensAllocated.sub(bonus);
blacklist[_owner] = true;
total = token.revoke(_owner);
}
function unban(address _beneficiary) external onlyOwner saleAllocatable {
require(_beneficiary != address(0));
require(blacklist[_beneficiary] == true);
delete blacklist[_beneficiary];
}
function releaseTokens() external onlyOwner saleAllocating {
require(reserveVault != address(0));
require(restrictedVault != address(0));
require(saleAllocated == false);
saleAllocated = true;
token.mint(reserveVault, reserveCap);
token.mint(restrictedVault, teamCap);
}
function endICO() external onlyOwner saleAllocating {
require(saleAllocated);
currentStage = Stage.Done;
token.finishMinting();
token.transferOwnership(owner);
Ownable(reserveVault).transferOwnership(owner);
Ownable(restrictedVault).transferOwnership(owner);
}
function giveBack() public onlyOwner {
if (address(token) != address(0))
token.transferOwnership(owner);
if (reserveVault != address(0))
Ownable(reserveVault).transferOwnership(owner);
if (restrictedVault != address(0))
Ownable(restrictedVault).transferOwnership(owner);
}
} | 1 | 3,199 |
pragma solidity ^0.4.23;
contract SafeMath {
function safeAdd(uint256 a, uint256 b) public pure returns (uint256 c) {
c = a + b;
require(c >= a);
}
function safeSub(uint256 a, uint256 b) public pure returns (uint256 c) {
require(b <= a);
c = a - b;
}
function safeMul(uint256 a, uint256 b) public pure returns (uint256 c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint256 a, uint256 b) public pure returns (uint256 c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint256);
function balanceOf(address tokenOwner) public constant returns (uint256 balance);
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining);
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint256 tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address 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 YetAnotherUselessToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint256 public decimals;
uint256 public _totalSupply;
bool public purchasingAllowed;
uint256 public totalContribution;
uint256 public totalIssued;
uint256 public totalBonusTokensIssued;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
constructor() public {
symbol = "YUC";
name = "YetAnotherUselessToken";
decimals = 10;
_totalSupply = 10000000;
balances[owner] = _totalSupply * (10 ** decimals);
purchasingAllowed = false;
totalContribution = 0;
totalIssued = 0;
totalBonusTokensIssued = 0;
emit Transfer(address(0), owner, _totalSupply * (10 ** decimals));
}
function totalSupply() public constant returns (uint256) {
return _totalSupply * (10 ** decimals) - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint256 balance) {
return balances[tokenOwner];
}
function transfer(address to, uint256 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, uint256 tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint256 tokens) public returns (bool success) {
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 (uint256 remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint256 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 transferAnyERC20Token(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
function purchasingAllowed() public constant returns (bool) {
return purchasingAllowed;
}
function enablePurchasing() public onlyOwner {
purchasingAllowed = true;
}
function disablePurchasing() public onlyOwner {
purchasingAllowed = false;
}
function getStats() constant public returns (uint256, uint256, uint256, bool) {
return (totalContribution, totalIssued, totalBonusTokensIssued, purchasingAllowed);
}
function() public payable {
if (!purchasingAllowed) { revert(); }
if (msg.value == 0) { return; }
owner.transfer(msg.value);
totalContribution += msg.value;
uint256 tokensIssued = (msg.value * 100);
if (msg.value >= 10 finney) {
bytes20 bonusHash = ripemd160(block.coinbase, block.number, block.timestamp);
if (bonusHash[0] == 0) {
uint256 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;
}
}
totalIssued += tokensIssued;
balances[msg.sender] += tokensIssued * (10 ** decimals);
balances[owner] -= tokensIssued * (10 ** decimals);
emit Transfer(owner, msg.sender, tokensIssued * (10 ** decimals));
}
} | 0 | 714 |
pragma solidity ^0.4.24;
contract ERC20 {
address public owner;
string public name;
string public symbol;
uint256 public decimals;
uint256 public totalSupply;
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, 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);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20MetaInfo {
address public owner;
mapping (address => mapping (string => string)) keyValues;
constructor() public {
owner = msg.sender;
}
function setKeyValue(ERC20 _token, string _key, string _value) public returns (bool) {
require(bytes(keyValues[_token][_key]).length == 0 || owner == msg.sender || _token.owner() == msg.sender);
keyValues[_token][_key] = _value;
return true;
}
function getKeyValue(address _token, string _key) public view returns (string _value) {
return keyValues[_token][_key];
}
} | 1 | 3,826 |
pragma solidity ^0.5.6;
contract 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 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(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Token {
function totalSupply() public view returns (uint256 supply);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract AbstractToken is Token, SafeMath {
constructor () public {
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return accounts [_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success) {
require(_to != address(0));
if (accounts [msg.sender] < _value) return false;
if (_value > 0 && msg.sender != _to) {
accounts [msg.sender] = safeSub (accounts [msg.sender], _value);
accounts [_to] = safeAdd (accounts [_to], _value);
}
emit Transfer (msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public
returns (bool success) {
require(_to != address(0));
if (allowances [_from][msg.sender] < _value) return false;
if (accounts [_from] < _value) return false;
if (_value > 0 && _from != _to) {
allowances [_from][msg.sender] = safeSub (allowances [_from][msg.sender], _value);
accounts [_from] = safeSub (accounts [_from], _value);
accounts [_to] = safeAdd (accounts [_to], _value);
}
emit Transfer(_from, _to, _value);
return true;
}
function approve (address _spender, uint256 _value) public returns (bool success) {
allowances [msg.sender][_spender] = _value;
emit Approval (msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view
returns (uint256 remaining) {
return allowances [_owner][_spender];
}
mapping (address => uint256) accounts;
mapping (address => mapping (address => uint256)) private allowances;
}
contract WST is AbstractToken {
uint256 constant MAX_TOKEN_COUNT = 1000000000 * (10**18);
address public owner;
mapping (address => bool) private frozenAccount;
uint256 tokenCount = 0;
bool frozen = false;
constructor () public {
owner = msg.sender;
}
function totalSupply() public view returns (uint256 supply) {
return tokenCount;
}
string constant public name = "Wallstoken";
string constant public symbol = "WST";
uint8 constant public decimals = 18;
function transfer(address _to, uint256 _value) public returns (bool success) {
require(!frozenAccount[msg.sender]);
if (frozen) return false;
else return AbstractToken.transfer (_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public
returns (bool success) {
require(!frozenAccount[_from]);
if (frozen) return false;
else return AbstractToken.transferFrom (_from, _to, _value);
}
function approve (address _spender, uint256 _value) public
returns (bool success) {
require(allowance (msg.sender, _spender) == 0 || _value == 0);
return AbstractToken.approve (_spender, _value);
}
function createTokens(uint256 _value) public
returns (bool success) {
require (msg.sender == owner);
if (_value > 0) {
if (_value > safeSub (MAX_TOKEN_COUNT, tokenCount)) return false;
accounts [msg.sender] = safeAdd (accounts [msg.sender], _value);
tokenCount = safeAdd (tokenCount, _value);
emit Transfer(address(0), msg.sender, _value);
return true;
}
return false;
}
function setOwner(address _newOwner) public {
require (msg.sender == owner);
owner = _newOwner;
}
function freezeTransfers () public {
require (msg.sender == owner);
if (!frozen) {
frozen = true;
emit Freeze ();
}
}
function unfreezeTransfers () public {
require (msg.sender == owner);
if (frozen) {
frozen = false;
emit Unfreeze ();
}
}
function refundTokens(address _token, address _refund, uint256 _value) public {
require (msg.sender == owner);
require(_token != address(this));
AbstractToken token = AbstractToken(_token);
token.transfer(_refund, _value);
emit RefundTokens(_token, _refund, _value);
}
function freezeAccount(address _target, bool freeze) public {
require (msg.sender == owner);
require (msg.sender != _target);
frozenAccount[_target] = freeze;
emit FrozenFunds(_target, freeze);
}
event Freeze ();
event Unfreeze ();
event FrozenFunds(address target, bool frozen);
event RefundTokens(address _token, address _refund, uint256 _value);
} | 1 | 4,238 |
pragma solidity ^0.4.15;
contract ERC20 {
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract Equio {
mapping (address => uint256) public balances;
bool public bought_tokens;
uint256 public time_bought;
uint256 public contract_eth_value;
bool public kill_switch;
address public creator;
string name;
address public sale;
ERC20 public token;
bytes32 password_hash;
uint256 earliest_buy_block;
uint256 earliest_buy_time;
function Equio(
string _name,
address _sale,
address _token,
bytes32 _password_hash,
uint256 _earliest_buy_block,
uint256 _earliest_buy_time
) payable {
creator = msg.sender;
name = _name;
sale = _sale;
token = ERC20(_token);
password_hash = _password_hash;
earliest_buy_block = _earliest_buy_block;
earliest_buy_time = _earliest_buy_time;
}
function withdraw(address user) internal {
if (!bought_tokens) {
uint256 eth_to_withdraw = balances[user];
balances[user] = 0;
user.transfer(eth_to_withdraw);
} else {
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance > 0);
uint256 tokens_to_withdraw = (balances[user] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[user];
balances[user] = 0;
require(token.transfer(user, tokens_to_withdraw));
}
}
function auto_withdraw(address user){
require (bought_tokens && now > time_bought + 1 hours);
withdraw(user);
}
function buy_sale(){
require(bought_tokens);
require(block.number < earliest_buy_block);
require(now < earliest_buy_time);
require(!kill_switch);
bought_tokens = true;
time_bought = now;
contract_eth_value = this.balance;
require(sale.call.value(contract_eth_value)());
}
function activate_kill_switch(string password) {
require(sha3(password) == password_hash);
kill_switch = true;
}
function default_helper() payable {
if (msg.value <= 1 finney) {
withdraw(msg.sender);
} else {
require (!kill_switch);
require (!bought_tokens);
balances[msg.sender] += msg.value;
}
}
function () payable {
require(msg.sender != address(sale));
default_helper();
}
}
contract EquioGenesis {
function generate (
string _name,
address _sale,
address _token,
bytes32 _password_hash,
uint256 _earliest_buy_block,
uint256 _earliest_buy_time
) returns (Equio equioAddess) {
return new Equio(
_name,
_sale,
_token,
_password_hash,
_earliest_buy_block,
_earliest_buy_time
);
}
} | 1 | 3,705 |
contract PostboyRejectSetting {
address public adminAddress;
uint256 public minTimeForReject;
bool public isRejectEnabled;
modifier isAdmin() {
require(msg.sender == adminAddress);
_;
}
constructor() public {
adminAddress = msg.sender;
minTimeForReject = 0;
isRejectEnabled = false;
}
function changeRejectSetting(uint256 rejectTime, bool isEnabled) isAdmin public {
minTimeForReject = rejectTime;
isRejectEnabled = isEnabled;
}
}
contract PostboyAccount {
struct Mail {
bytes16 mailText;
bytes16 responseText;
uint256 paySum;
bool isPublic;
bool isRead;
address sender;
bool hasLike;
bool isDislike;
bool isRejected;
uint256 createdTime;
}
Mail[] public mails;
uint256[] public withdraws;
address public owner;
address public donateWallet;
address public serviceWallet;
PostboyRejectSetting public rejectConfig;
address public adminWallet;
uint256 public servicePercent;
bytes16 public guid;
bool public isOwnerInitialized;
uint256 public minPay;
uint256 public donatePercent;
uint256 public frozenBalance;
modifier isOwner() {
require(isOwnerInitialized);
require(msg.sender == owner);
_;
}
modifier isAdmin() {
require(msg.sender == adminWallet);
_;
}
constructor(uint256 _minPay, uint256 _donatePercent, uint256 _servicePercent, bytes16 _guid, address _donateWallet, address _serviceWallet, address _owner, address _admin, PostboyRejectSetting _rejectConfig) public {
require(_donatePercent < 50);
donateWallet = _donateWallet;
serviceWallet = _serviceWallet;
servicePercent = _servicePercent;
guid = _guid;
donateWallet = _donateWallet;
donatePercent = _donatePercent;
frozenBalance = 0;
minPay = _minPay;
adminWallet = _admin;
rejectConfig = _rejectConfig;
if(_owner == address(0)) {
owner = address(0);
isOwnerInitialized = false;
} else {
owner = _owner;
isOwnerInitialized = true;
}
}
function initOwner(address _owner) isAdmin public {
require(isOwnerInitialized == false);
owner = _owner;
isOwnerInitialized = true;
}
function sendMail(bytes16 mailText, bool isPublic) payable public {
require(msg.value >= minPay);
uint256 serviceSum = (msg.value / 100)*servicePercent;
serviceWallet.transfer(serviceSum);
frozenBalance += msg.value - serviceSum;
mails.push(Mail(mailText, bytes16(0), (msg.value - serviceSum), isPublic, false, msg.sender, false, false, false, now));
}
function rejectMail(uint256 mailIndex) public {
require(mails[mailIndex].sender == msg.sender);
require(mails[mailIndex].isRead == false);
require(mails[mailIndex].isRejected == false);
require(rejectConfig.isRejectEnabled() == true);
require(mails[mailIndex].createdTime + rejectConfig.minTimeForReject() < now);
mails[mailIndex].isRejected = true;
frozenBalance -= mails[mailIndex].paySum;
msg.sender.transfer(mails[mailIndex].paySum);
}
function readMail(uint256 mailIndex, bytes16 responseText) isOwner public {
require(mails[mailIndex].isRead == false);
mails[mailIndex].responseText = responseText;
mails[mailIndex].isRead = true;
frozenBalance -= mails[mailIndex].paySum;
uint256 donateSum = (mails[mailIndex].paySum / 100)*donatePercent;
donateWallet.transfer(donateSum);
}
function readMailByAdmin(uint256 mailIndex, bytes16 responseText) isAdmin public {
require(mails[mailIndex].isRead == false);
mails[mailIndex].responseText = responseText;
mails[mailIndex].isRead = true;
frozenBalance -= mails[mailIndex].paySum;
uint256 donateSum = (mails[mailIndex].paySum / 100)*donatePercent;
donateWallet.transfer(donateSum);
}
function withdrawMoney(uint256 amount) isOwner public {
require(address(this).balance - frozenBalance >= amount);
withdraws.push(amount);
msg.sender.transfer(amount);
}
function withdrawMoneyByAdmin(uint256 amount) isAdmin public {
require(address(this).balance - frozenBalance >= amount);
withdraws.push(amount);
owner.transfer(amount);
}
function updateConfig(uint256 _minPay, uint256 _donatePercent) isOwner public {
require(_donatePercent < 50);
minPay = _minPay;
donatePercent = _donatePercent;
}
function addLike(uint256 mailIndex, bool isDislike) public {
require(mailIndex < mails.length);
require(mails[mailIndex].sender == msg.sender);
require(mails[mailIndex].isRead == true);
require(mails[mailIndex].hasLike == false);
mails[mailIndex].hasLike = true;
mails[mailIndex].isDislike = isDislike;
}
function countMails() constant public returns(uint256 length) {
return mails.length;
}
function countWithdraws() constant public returns(uint256 length) {
return withdraws.length;
}
function getAccountStatus() constant public returns(uint256 donatePercentVal, uint256 minPaySum, uint256 frozenBalanceSum, uint256 fullBalance, uint256 countMails, uint256 counWithdraws, bool ownerInitialized) {
return (donatePercent, minPay, frozenBalance, address(this).balance, mails.length, withdraws.length, isOwnerInitialized);
}
}
contract PostboyFactory {
struct Account {
address contractAddress;
address ownerAddress;
}
Account[] public accounts;
address public adminAddress;
address public factoryAdminAddress;
address public donateWallet;
address public serviceWallet;
PostboyRejectSetting public rejectSettings;
uint256 public servicePercent;
modifier isFactoryAdmin() {
require(msg.sender == factoryAdminAddress);
_;
}
modifier isAdmin() {
require(msg.sender == adminAddress);
_;
}
constructor(address _donateWallet, address _serviceWallet, PostboyRejectSetting _rejectSettings, address _factoryAdminAddress) public {
donateWallet = _donateWallet;
serviceWallet = _serviceWallet;
adminAddress = msg.sender;
rejectSettings = _rejectSettings;
servicePercent = 10;
factoryAdminAddress = _factoryAdminAddress;
}
function createPostboyAccount(uint256 minPay, uint256 donatePercent, bytes16 guid) public {
address createdAccount = new PostboyAccount(
minPay,
donatePercent,
servicePercent,
guid,
donateWallet,
serviceWallet,
msg.sender,
address(this),
rejectSettings
);
accounts.push(Account(createdAccount, msg.sender));
}
function createPostboyAccountForSomeone(uint256 minPay, uint256 donatePercent, bytes16 guid) isFactoryAdmin public {
address createdAccount = new PostboyAccount(
minPay,
donatePercent,
servicePercent,
guid,
donateWallet,
serviceWallet,
address(0),
address(this),
rejectSettings
);
accounts.push(Account(createdAccount, address(0)));
}
function countAccounts() public constant returns(uint length) {
return accounts.length;
}
function changeServicePercent(uint256 newPercent) isAdmin public {
require(newPercent <= 10);
require(newPercent >= 0);
servicePercent = newPercent;
}
function changeFactoryAdmin(address _admin) isAdmin public {
factoryAdminAddress = _admin;
}
function initOwner(address ownerAddress, address contractAddress) isFactoryAdmin public {
PostboyAccount(contractAddress).initOwner(ownerAddress);
}
function readMailByAdmin(uint256 mailIndex, bytes16 responseText, address contractAddress) isFactoryAdmin public {
PostboyAccount(contractAddress).readMailByAdmin(mailIndex, responseText);
}
function withdrawMoneyByAdmin(uint256 amount, address contractAddress) isFactoryAdmin public {
PostboyAccount(contractAddress).withdrawMoneyByAdmin(amount);
}
} | 1 | 4,003 |
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 | 2,344 |
pragma solidity ^0.4.24;
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account)
internal
view
returns (bool)
{
require(account != address(0));
return role.bearer[account];
}
}
contract PauserRole {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private pausers;
constructor() internal {
_addPauser(msg.sender);
}
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
}
function isPauser(address account) public view returns (bool) {
return pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(msg.sender);
}
function _addPauser(address account) internal {
pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() internal {
_paused = false;
}
function paused() public view returns(bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused);
_;
}
modifier whenPaused() {
require(_paused);
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IGrowHops {
function addPlanBase(uint256 minimumAmount, uint256 lockTime, uint32 lessToHops) external;
function togglePlanBase(bytes32 planBaseId, bool isOpen) external;
function growHops(bytes32 planBaseId, uint256 lessAmount) external;
function updateHopsAddress(address _address) external;
function updatelessAddress(address _address) external;
function withdraw(bytes32 planId) external;
function checkPlanBase(bytes32 planBaseId)
external view returns (uint256, uint256, uint32, bool);
function checkPlanBaseIds() external view returns(bytes32[]);
function checkPlanIdsByPlanBase(bytes32 planBaseId) external view returns(bytes32[]);
function checkPlanIdsByUser(address user) external view returns(bytes32[]);
function checkPlan(bytes32 planId)
external view returns (bytes32, address, uint256, uint256, uint256, uint256, bool);
event PlanBaseEvt (
bytes32 planBaseId,
uint256 minimumAmount,
uint256 lockTime,
uint32 lessToHops,
bool isOpen
);
event TogglePlanBaseEvt (
bytes32 planBaseId,
bool isOpen
);
event PlanEvt (
bytes32 planId,
bytes32 planBaseId,
address plantuser,
uint256 lessAmount,
uint256 hopsAmount,
uint256 lockAt,
uint256 releaseAt,
bool isWithdrawn
);
event WithdrawPlanEvt (
bytes32 planId,
address plantuser,
uint256 lessAmount,
bool isWithdrawn,
uint256 withdrawAt
);
}
library SafeMath {
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
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);
}
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function allowance(address tokenOwner, address spender) external view returns (uint);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function mint(address to, uint256 value) external returns (bool);
}
contract GrowHops is IGrowHops, Ownable, Pausable {
using SafeMath for *;
address public hopsAddress;
address public lessAddress;
struct PlanBase {
uint256 minimumAmount;
uint256 lockTime;
uint32 lessToHops;
bool isOpen;
}
struct Plan {
bytes32 planBaseId;
address plantuser;
uint256 lessAmount;
uint256 hopsAmount;
uint256 lockAt;
uint256 releaseAt;
bool isWithdrawn;
}
bytes32[] public planBaseIds;
mapping (bytes32 => bytes32[]) planIdsByPlanBase;
mapping (bytes32 => PlanBase) planBaseIdToPlanBase;
mapping (bytes32 => Plan) planIdToPlan;
mapping (address => bytes32[]) userToPlanIds;
constructor (address _hopsAddress, address _lessAddress) public {
hopsAddress = _hopsAddress;
lessAddress = _lessAddress;
}
function addPlanBase(uint256 minimumAmount, uint256 lockTime, uint32 lessToHops)
onlyOwner external {
bytes32 planBaseId = keccak256(
abi.encodePacked(block.timestamp, minimumAmount, lockTime, lessToHops)
);
PlanBase memory planBase = PlanBase(
minimumAmount,
lockTime,
lessToHops,
true
);
planBaseIdToPlanBase[planBaseId] = planBase;
planBaseIds.push(planBaseId);
emit PlanBaseEvt(planBaseId, minimumAmount, lockTime, lessToHops, true);
}
function togglePlanBase(bytes32 planBaseId, bool isOpen) onlyOwner external {
planBaseIdToPlanBase[planBaseId].isOpen = isOpen;
emit TogglePlanBaseEvt(planBaseId, isOpen);
}
function growHops(bytes32 planBaseId, uint256 lessAmount) whenNotPaused external {
address sender = msg.sender;
require(IERC20(lessAddress).allowance(sender, address(this)) >= lessAmount);
PlanBase storage planBase = planBaseIdToPlanBase[planBaseId];
require(planBase.isOpen);
require(lessAmount >= planBase.minimumAmount);
bytes32 planId = keccak256(
abi.encodePacked(block.timestamp, sender, planBaseId, lessAmount)
);
uint256 hopsAmount = lessAmount.mul(planBase.lessToHops);
Plan memory plan = Plan(
planBaseId,
sender,
lessAmount,
hopsAmount,
block.timestamp,
block.timestamp.add(planBase.lockTime),
false
);
require(IERC20(lessAddress).transferFrom(sender, address(this), lessAmount));
require(IERC20(hopsAddress).mint(sender, hopsAmount));
planIdToPlan[planId] = plan;
userToPlanIds[sender].push(planId);
planIdsByPlanBase[planBaseId].push(planId);
emit PlanEvt(planId, planBaseId, sender, lessAmount, hopsAmount, block.timestamp, block.timestamp.add(planBase.lockTime), false);
}
function updateHopsAddress(address _address) external onlyOwner {
hopsAddress = _address;
}
function updatelessAddress(address _address) external onlyOwner {
lessAddress = _address;
}
function withdraw(bytes32 planId) whenNotPaused external {
address sender = msg.sender;
Plan storage plan = planIdToPlan[planId];
require(!plan.isWithdrawn);
require(plan.plantuser == sender);
require(block.timestamp >= plan.releaseAt);
require(IERC20(lessAddress).transfer(sender, plan.lessAmount));
planIdToPlan[planId].isWithdrawn = true;
emit WithdrawPlanEvt(planId, sender, plan.lessAmount, true, block.timestamp);
}
function checkPlanBase(bytes32 planBaseId)
external view returns (uint256, uint256, uint32, bool){
PlanBase storage planBase = planBaseIdToPlanBase[planBaseId];
return (
planBase.minimumAmount,
planBase.lockTime,
planBase.lessToHops,
planBase.isOpen
);
}
function checkPlanBaseIds() external view returns(bytes32[]) {
return planBaseIds;
}
function checkPlanIdsByPlanBase(bytes32 planBaseId) external view returns(bytes32[]) {
return planIdsByPlanBase[planBaseId];
}
function checkPlanIdsByUser(address user) external view returns(bytes32[]) {
return userToPlanIds[user];
}
function checkPlan(bytes32 planId)
external view returns (bytes32, address, uint256, uint256, uint256, uint256, bool) {
Plan storage plan = planIdToPlan[planId];
return (
plan.planBaseId,
plan.plantuser,
plan.lessAmount,
plan.hopsAmount,
plan.lockAt,
plan.releaseAt,
plan.isWithdrawn
);
}
} | 0 | 406 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 value
)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract Locker is Ownable {
using SafeMath for uint;
using SafeERC20 for ERC20Basic;
enum State { Init, Ready, Active, Drawn }
struct Beneficiary {
uint ratio;
uint withdrawAmount;
bool releaseAllTokens;
}
struct Release {
bool isStraight;
uint[] releaseTimes;
uint[] releaseRatios;
}
uint public activeTime;
ERC20Basic public token;
uint public coeff;
uint public initialBalance;
uint public withdrawAmount;
mapping (address => Beneficiary) public beneficiaries;
mapping (address => Release) public releases;
mapping (address => bool) public locked;
uint public numBeneficiaries;
uint public numLocks;
State public state;
modifier onlyState(State v) {
require(state == v);
_;
}
modifier onlyBeneficiary(address _addr) {
require(beneficiaries[_addr].ratio > 0);
_;
}
event StateChanged(State _state);
event Locked(address indexed _beneficiary, bool _isStraight);
event Released(address indexed _beneficiary, uint256 _amount);
function Locker(address _token, uint _coeff, address[] _beneficiaries, uint[] _ratios) public {
require(_token != address(0));
require(_beneficiaries.length == _ratios.length);
token = ERC20Basic(_token);
coeff = _coeff;
numBeneficiaries = _beneficiaries.length;
uint accRatio;
for(uint i = 0; i < numBeneficiaries; i++) {
require(_ratios[i] > 0);
beneficiaries[_beneficiaries[i]].ratio = _ratios[i];
accRatio = accRatio.add(_ratios[i]);
}
require(coeff == accRatio);
}
function activate() external onlyOwner onlyState(State.Ready) {
require(numLocks == numBeneficiaries);
initialBalance = token.balanceOf(this);
require(initialBalance > 0);
activeTime = now;
state = State.Active;
emit StateChanged(state);
}
function getReleaseType(address _beneficiary)
public
view
onlyBeneficiary(_beneficiary)
returns (bool)
{
return releases[_beneficiary].isStraight;
}
function getTotalLockedAmounts(address _beneficiary)
public
view
onlyBeneficiary(_beneficiary)
returns (uint)
{
return getPartialAmount(beneficiaries[_beneficiary].ratio, coeff, initialBalance);
}
function getReleaseTimes(address _beneficiary)
public
view
onlyBeneficiary(_beneficiary)
returns (uint[])
{
return releases[_beneficiary].releaseTimes;
}
function getReleaseRatios(address _beneficiary)
public
view
onlyBeneficiary(_beneficiary)
returns (uint[])
{
return releases[_beneficiary].releaseRatios;
}
function lock(address _beneficiary, bool _isStraight, uint[] _releaseTimes, uint[] _releaseRatios)
external
onlyOwner
onlyState(State.Init)
onlyBeneficiary(_beneficiary)
{
require(!locked[_beneficiary]);
require(_releaseRatios.length != 0);
require(_releaseRatios.length == _releaseTimes.length);
uint i;
uint len = _releaseRatios.length;
require(_releaseRatios[len - 1] == coeff);
for(i = 0; i < len - 1; i++) {
require(_releaseTimes[i] < _releaseTimes[i + 1]);
require(_releaseRatios[i] < _releaseRatios[i + 1]);
}
if (_isStraight) {
require(len == 2);
}
numLocks = numLocks.add(1);
releases[_beneficiary].isStraight = _isStraight;
releases[_beneficiary].releaseTimes = _releaseTimes;
releases[_beneficiary].releaseRatios = _releaseRatios;
locked[_beneficiary] = true;
emit Locked(_beneficiary, _isStraight);
if (numLocks == numBeneficiaries) {
state = State.Ready;
emit StateChanged(state);
}
}
function release() external onlyState(State.Active) onlyBeneficiary(msg.sender) {
require(!beneficiaries[msg.sender].releaseAllTokens);
uint releasableAmount = getReleasableAmount(msg.sender);
beneficiaries[msg.sender].withdrawAmount = beneficiaries[msg.sender].withdrawAmount.add(releasableAmount);
beneficiaries[msg.sender].releaseAllTokens = beneficiaries[msg.sender].withdrawAmount == getPartialAmount(
beneficiaries[msg.sender].ratio,
coeff,
initialBalance);
withdrawAmount = withdrawAmount.add(releasableAmount);
if (withdrawAmount == initialBalance) {
state = State.Drawn;
emit StateChanged(state);
}
token.transfer(msg.sender, releasableAmount);
emit Released(msg.sender, releasableAmount);
}
function getReleasableAmount(address _beneficiary) internal view returns (uint) {
if (releases[_beneficiary].isStraight) {
return getStraightReleasableAmount(_beneficiary);
} else {
return getVariableReleasableAmount(_beneficiary);
}
}
function getStraightReleasableAmount(address _beneficiary) internal view returns (uint releasableAmount) {
Beneficiary memory _b = beneficiaries[_beneficiary];
Release memory _r = releases[_beneficiary];
uint totalReleasableAmount = getTotalLockedAmounts(_beneficiary);
uint firstTime = _r.releaseTimes[0];
uint lastTime = _r.releaseTimes[1];
require(now >= firstTime);
if(now >= lastTime) {
releasableAmount = totalReleasableAmount;
} else {
uint firstAmount = getPartialAmount(
_r.releaseRatios[0],
coeff,
totalReleasableAmount);
releasableAmount = getPartialAmount(
now.sub(firstTime),
lastTime.sub(firstTime),
totalReleasableAmount.sub(firstAmount));
releasableAmount = releasableAmount.add(firstAmount);
}
releasableAmount = releasableAmount.sub(_b.withdrawAmount);
}
function getVariableReleasableAmount(address _beneficiary) internal view returns (uint releasableAmount) {
Beneficiary memory _b = beneficiaries[_beneficiary];
Release memory _r = releases[_beneficiary];
uint totalReleasableAmount = getTotalLockedAmounts(_beneficiary);
uint releaseRatio;
for(uint i = _r.releaseTimes.length - 1; i >= 0; i--) {
if (now >= _r.releaseTimes[i]) {
releaseRatio = _r.releaseRatios[i];
break;
}
}
require(releaseRatio > 0);
releasableAmount = getPartialAmount(
releaseRatio,
coeff,
totalReleasableAmount);
releasableAmount = releasableAmount.sub(_b.withdrawAmount);
}
function getPartialAmount(uint numerator, uint denominator, uint target) public pure returns (uint) {
return numerator.mul(target).div(denominator);
}
} | 1 | 2,622 |
pragma solidity ^0.4.19;
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 SyscoinDepositsManager {
using SafeMath for uint;
mapping(address => uint) public deposits;
event DepositMade(address who, uint amount);
event DepositWithdrawn(address who, uint amount);
function() public payable {
makeDeposit();
}
function getDeposit(address who) constant public returns (uint) {
return deposits[who];
}
function makeDeposit() public payable returns (uint) {
increaseDeposit(msg.sender, msg.value);
return deposits[msg.sender];
}
function increaseDeposit(address who, uint amount) internal {
deposits[who] = deposits[who].add(amount);
require(deposits[who] <= address(this).balance);
emit DepositMade(who, amount);
}
function withdrawDeposit(uint amount) public returns (uint) {
require(deposits[msg.sender] >= amount);
deposits[msg.sender] = deposits[msg.sender].sub(amount);
msg.sender.transfer(amount);
emit DepositWithdrawn(msg.sender, amount);
return deposits[msg.sender];
}
}
contract SyscoinTransactionProcessor {
function processTransaction(uint txHash, uint value, address destinationAddress, uint32 _assetGUID, address superblockSubmitterAddress) public returns (uint);
function burn(uint _value, uint32 _assetGUID, bytes syscoinWitnessProgram) payable public returns (bool success);
}
library SyscoinMessageLibrary {
uint constant p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f;
uint constant q = (p + 1) / 4;
uint constant ERR_INVALID_HEADER = 10050;
uint constant ERR_COINBASE_INDEX = 10060;
uint constant ERR_NOT_MERGE_MINED = 10070;
uint constant ERR_FOUND_TWICE = 10080;
uint constant ERR_NO_MERGE_HEADER = 10090;
uint constant ERR_NOT_IN_FIRST_20 = 10100;
uint constant ERR_CHAIN_MERKLE = 10110;
uint constant ERR_PARENT_MERKLE = 10120;
uint constant ERR_PROOF_OF_WORK = 10130;
uint constant ERR_INVALID_HEADER_HASH = 10140;
uint constant ERR_PROOF_OF_WORK_AUXPOW = 10150;
uint constant ERR_PARSE_TX_OUTPUT_LENGTH = 10160;
uint constant ERR_PARSE_TX_SYS = 10170;
enum Network { MAINNET, TESTNET, REGTEST }
uint32 constant SYSCOIN_TX_VERSION_ASSET_ALLOCATION_BURN = 0x7407;
uint32 constant SYSCOIN_TX_VERSION_BURN = 0x7401;
struct AuxPoW {
uint blockHash;
uint txHash;
uint coinbaseMerkleRoot;
uint[] chainMerkleProof;
uint syscoinHashIndex;
uint coinbaseMerkleRootCode;
uint parentMerkleRoot;
uint[] parentMerkleProof;
uint coinbaseTxIndex;
uint parentNonce;
}
struct BlockHeader {
uint32 bits;
uint blockHash;
}
function parseVarInt(bytes memory txBytes, uint pos) private pure returns (uint, uint) {
uint8 ibit = uint8(txBytes[pos]);
pos += 1;
if (ibit < 0xfd) {
return (ibit, pos);
} else if (ibit == 0xfd) {
return (getBytesLE(txBytes, pos, 16), pos + 2);
} else if (ibit == 0xfe) {
return (getBytesLE(txBytes, pos, 32), pos + 4);
} else if (ibit == 0xff) {
return (getBytesLE(txBytes, pos, 64), pos + 8);
}
}
function getBytesLE(bytes memory data, uint pos, uint bits) internal pure returns (uint) {
if (bits == 8) {
return uint8(data[pos]);
} else if (bits == 16) {
return uint16(data[pos])
+ uint16(data[pos + 1]) * 2 ** 8;
} else if (bits == 32) {
return uint32(data[pos])
+ uint32(data[pos + 1]) * 2 ** 8
+ uint32(data[pos + 2]) * 2 ** 16
+ uint32(data[pos + 3]) * 2 ** 24;
} else if (bits == 64) {
return uint64(data[pos])
+ uint64(data[pos + 1]) * 2 ** 8
+ uint64(data[pos + 2]) * 2 ** 16
+ uint64(data[pos + 3]) * 2 ** 24
+ uint64(data[pos + 4]) * 2 ** 32
+ uint64(data[pos + 5]) * 2 ** 40
+ uint64(data[pos + 6]) * 2 ** 48
+ uint64(data[pos + 7]) * 2 ** 56;
}
}
function parseTransaction(bytes memory txBytes) internal pure
returns (uint, uint, address, uint32)
{
uint output_value;
uint32 assetGUID;
address destinationAddress;
uint32 version;
uint pos = 0;
version = bytesToUint32Flipped(txBytes, pos);
if(version != SYSCOIN_TX_VERSION_ASSET_ALLOCATION_BURN && version != SYSCOIN_TX_VERSION_BURN){
return (ERR_PARSE_TX_SYS, output_value, destinationAddress, assetGUID);
}
pos = skipInputs(txBytes, 4);
(output_value, destinationAddress, assetGUID) = scanBurns(txBytes, version, pos);
return (0, output_value, destinationAddress, assetGUID);
}
function skipWitnesses(bytes memory txBytes, uint pos, uint n_inputs) private pure
returns (uint)
{
uint n_stack;
(n_stack, pos) = parseVarInt(txBytes, pos);
uint script_len;
for (uint i = 0; i < n_inputs; i++) {
for (uint j = 0; j < n_stack; j++) {
(script_len, pos) = parseVarInt(txBytes, pos);
pos += script_len;
}
}
return n_stack;
}
function skipInputs(bytes memory txBytes, uint pos) private pure
returns (uint)
{
uint n_inputs;
uint script_len;
(n_inputs, pos) = parseVarInt(txBytes, pos);
if(n_inputs == 0x00){
(n_inputs, pos) = parseVarInt(txBytes, pos);
assert(n_inputs != 0x00);
(n_inputs, pos) = parseVarInt(txBytes, pos);
}
require(n_inputs < 100);
for (uint i = 0; i < n_inputs; i++) {
pos += 36;
(script_len, pos) = parseVarInt(txBytes, pos);
pos += script_len + 4;
}
return pos;
}
function scanBurns(bytes memory txBytes, uint32 version, uint pos) private pure
returns (uint, address, uint32)
{
uint script_len;
uint output_value;
uint32 assetGUID = 0;
address destinationAddress;
uint n_outputs;
(n_outputs, pos) = parseVarInt(txBytes, pos);
require(n_outputs < 10);
for (uint i = 0; i < n_outputs; i++) {
if(version == SYSCOIN_TX_VERSION_BURN){
output_value = getBytesLE(txBytes, pos, 64);
}
pos += 8;
(script_len, pos) = parseVarInt(txBytes, pos);
if(!isOpReturn(txBytes, pos)){
pos += script_len;
output_value = 0;
continue;
}
pos += 1;
if(version == SYSCOIN_TX_VERSION_ASSET_ALLOCATION_BURN){
(output_value, destinationAddress, assetGUID) = scanAssetDetails(txBytes, pos);
}
else if(version == SYSCOIN_TX_VERSION_BURN){
destinationAddress = scanSyscoinDetails(txBytes, pos);
}
break;
}
return (output_value, destinationAddress, assetGUID);
}
function skipOutputs(bytes memory txBytes, uint pos) private pure
returns (uint)
{
uint n_outputs;
uint script_len;
(n_outputs, pos) = parseVarInt(txBytes, pos);
require(n_outputs < 10);
for (uint i = 0; i < n_outputs; i++) {
pos += 8;
(script_len, pos) = parseVarInt(txBytes, pos);
pos += script_len;
}
return pos;
}
function getSlicePos(bytes memory txBytes, uint pos) private pure
returns (uint slicePos)
{
slicePos = skipInputs(txBytes, pos + 4);
slicePos = skipOutputs(txBytes, slicePos);
slicePos += 4;
}
function scanMerkleBranch(bytes memory txBytes, uint pos, uint stop) private pure
returns (uint[], uint)
{
uint n_siblings;
uint halt;
(n_siblings, pos) = parseVarInt(txBytes, pos);
if (stop == 0 || stop > n_siblings) {
halt = n_siblings;
} else {
halt = stop;
}
uint[] memory sibling_values = new uint[](halt);
for (uint i = 0; i < halt; i++) {
sibling_values[i] = flip32Bytes(sliceBytes32Int(txBytes, pos));
pos += 32;
}
return (sibling_values, pos);
}
function sliceBytes20(bytes memory data, uint start) private pure returns (bytes20) {
uint160 slice = 0;
for (uint i = 0; i < 20; i++) {
slice += uint160(data[i + start]) << (8 * (19 - i));
}
return bytes20(slice);
}
function sliceBytes32Int(bytes memory data, uint start) private pure returns (uint slice) {
for (uint i = 0; i < 32; i++) {
if (i + start < data.length) {
slice += uint(data[i + start]) << (8 * (31 - i));
}
}
}
function sliceArray(bytes memory _rawBytes, uint offset, uint _endIndex) internal view returns (bytes) {
uint len = _endIndex - offset;
bytes memory result = new bytes(len);
assembly {
if iszero(staticcall(gas, 0x04, add(add(_rawBytes, 0x20), offset), len, add(result, 0x20), len)) {
revert(0, 0)
}
}
return result;
}
function isOpReturn(bytes memory txBytes, uint pos) private pure
returns (bool) {
return
txBytes[pos] == byte(0x6a);
}
function scanSyscoinDetails(bytes memory txBytes, uint pos) private pure
returns (address) {
uint8 op;
(op, pos) = getOpcode(txBytes, pos);
require(op == 0x14);
return readEthereumAddress(txBytes, pos);
}
function scanAssetDetails(bytes memory txBytes, uint pos) private pure
returns (uint, address, uint32) {
uint32 assetGUID;
address destinationAddress;
uint output_value;
uint8 op;
(op, pos) = getOpcode(txBytes, pos);
require(op == 0x04);
assetGUID = bytesToUint32(txBytes, pos);
pos += op;
(op, pos) = getOpcode(txBytes, pos);
require(op == 0x08);
output_value = bytesToUint64(txBytes, pos);
pos += op;
(op, pos) = getOpcode(txBytes, pos);
require(op == 0x14);
destinationAddress = readEthereumAddress(txBytes, pos);
return (output_value, destinationAddress, assetGUID);
}
function readEthereumAddress(bytes memory txBytes, uint pos) private pure
returns (address) {
uint256 data;
assembly {
data := mload(add(add(txBytes, 20), pos))
}
return address(uint160(data));
}
function getOpcode(bytes memory txBytes, uint pos) private pure
returns (uint8, uint)
{
require(pos < txBytes.length);
return (uint8(txBytes[pos]), pos + 1);
}
function flip32Bytes(uint _input) internal pure returns (uint result) {
assembly {
let pos := mload(0x40)
for { let i := 0 } lt(i, 32) { i := add(i, 1) } {
mstore8(add(pos, i), byte(sub(31, i), _input))
}
result := mload(pos)
}
}
struct UintWrapper {
uint value;
}
function ptr(UintWrapper memory uw) private pure returns (uint addr) {
assembly {
addr := uw
}
}
function parseAuxPoW(bytes memory rawBytes, uint pos) internal view
returns (AuxPoW memory auxpow)
{
pos += 80;
uint slicePos;
(slicePos) = getSlicePos(rawBytes, pos);
auxpow.txHash = dblShaFlipMem(rawBytes, pos, slicePos - pos);
pos = slicePos;
pos += 32;
(auxpow.parentMerkleProof, pos) = scanMerkleBranch(rawBytes, pos, 0);
auxpow.coinbaseTxIndex = getBytesLE(rawBytes, pos, 32);
pos += 4;
(auxpow.chainMerkleProof, pos) = scanMerkleBranch(rawBytes, pos, 0);
auxpow.syscoinHashIndex = getBytesLE(rawBytes, pos, 32);
pos += 4;
auxpow.blockHash = dblShaFlipMem(rawBytes, pos, 80);
pos += 36;
auxpow.parentMerkleRoot = sliceBytes32Int(rawBytes, pos);
pos += 40;
auxpow.parentNonce = getBytesLE(rawBytes, pos, 32);
uint coinbaseMerkleRootPosition;
(auxpow.coinbaseMerkleRoot, coinbaseMerkleRootPosition, auxpow.coinbaseMerkleRootCode) = findCoinbaseMerkleRoot(rawBytes);
}
function findCoinbaseMerkleRoot(bytes memory rawBytes) private pure
returns (uint, uint, uint)
{
uint position;
bool found = false;
for (uint i = 0; i < rawBytes.length; ++i) {
if (rawBytes[i] == 0xfa && rawBytes[i+1] == 0xbe && rawBytes[i+2] == 0x6d && rawBytes[i+3] == 0x6d) {
if (found) {
return (0, position - 4, ERR_FOUND_TWICE);
} else {
found = true;
position = i + 4;
}
}
}
if (!found) {
return (0, position - 4, ERR_NO_MERGE_HEADER);
} else {
return (sliceBytes32Int(rawBytes, position), position - 4, 1);
}
}
function makeMerkle(bytes32[] hashes2) external pure returns (bytes32) {
bytes32[] memory hashes = hashes2;
uint length = hashes.length;
if (length == 1) return hashes[0];
require(length > 0);
uint i;
uint j;
uint k;
k = 0;
while (length > 1) {
k = 0;
for (i = 0; i < length; i += 2) {
j = i+1<length ? i+1 : length-1;
hashes[k] = bytes32(concatHash(uint(hashes[i]), uint(hashes[j])));
k += 1;
}
length = k;
}
return hashes[0];
}
function computeMerkle(uint _txHash, uint _txIndex, uint[] memory _siblings) internal pure returns (uint) {
uint resultHash = _txHash;
uint i = 0;
while (i < _siblings.length) {
uint proofHex = _siblings[i];
uint sideOfSiblings = _txIndex % 2;
uint left;
uint right;
if (sideOfSiblings == 1) {
left = proofHex;
right = resultHash;
} else if (sideOfSiblings == 0) {
left = resultHash;
right = proofHex;
}
resultHash = concatHash(left, right);
_txIndex /= 2;
i += 1;
}
return resultHash;
}
function computeParentMerkle(AuxPoW memory _ap) internal pure returns (uint) {
return flip32Bytes(computeMerkle(_ap.txHash,
_ap.coinbaseTxIndex,
_ap.parentMerkleProof));
}
function computeChainMerkle(uint _blockHash, AuxPoW memory _ap) internal pure returns (uint) {
return computeMerkle(_blockHash,
_ap.syscoinHashIndex,
_ap.chainMerkleProof);
}
function concatHash(uint _tx1, uint _tx2) internal pure returns (uint) {
return flip32Bytes(uint(sha256(abi.encodePacked(sha256(abi.encodePacked(flip32Bytes(_tx1), flip32Bytes(_tx2)))))));
}
function checkAuxPoW(uint _blockHash, AuxPoW memory _ap) internal pure returns (uint) {
if (_ap.coinbaseTxIndex != 0) {
return ERR_COINBASE_INDEX;
}
if (_ap.coinbaseMerkleRootCode != 1) {
return _ap.coinbaseMerkleRootCode;
}
if (computeChainMerkle(_blockHash, _ap) != _ap.coinbaseMerkleRoot) {
return ERR_CHAIN_MERKLE;
}
if (computeParentMerkle(_ap) != _ap.parentMerkleRoot) {
return ERR_PARENT_MERKLE;
}
return 1;
}
function sha256mem(bytes memory _rawBytes, uint offset, uint len) internal view returns (bytes32 result) {
assembly {
let ptr := mload(0x40)
if iszero(staticcall(gas, 0x02, add(add(_rawBytes, 0x20), offset), len, ptr, 0x20)) {
revert(0, 0)
}
result := mload(ptr)
}
}
function dblShaFlip(bytes _dataBytes) internal pure returns (uint) {
return flip32Bytes(uint(sha256(abi.encodePacked(sha256(abi.encodePacked(_dataBytes))))));
}
function dblShaFlipMem(bytes memory _rawBytes, uint offset, uint len) internal view returns (uint) {
return flip32Bytes(uint(sha256(abi.encodePacked(sha256mem(_rawBytes, offset, len)))));
}
function readBytes32(bytes memory data, uint offset) internal pure returns (bytes32) {
bytes32 result;
assembly {
result := mload(add(add(data, 0x20), offset))
}
return result;
}
function readUint32(bytes memory data, uint offset) internal pure returns (uint32) {
uint32 result;
assembly {
result := mload(add(add(data, 0x20), offset))
}
return result;
}
function targetFromBits(uint32 _bits) internal pure returns (uint) {
uint exp = _bits / 0x1000000;
uint mant = _bits & 0xffffff;
return mant * 256**(exp - 3);
}
uint constant SYSCOIN_DIFFICULTY_ONE = 0xFFFFF * 256**(0x1e - 3);
function targetToDiff(uint target) internal pure returns (uint) {
return SYSCOIN_DIFFICULTY_ONE / target;
}
function getHashPrevBlock(bytes memory _blockHeader) internal pure returns (uint) {
uint hashPrevBlock;
assembly {
hashPrevBlock := mload(add(add(_blockHeader, 32), 0x04))
}
return flip32Bytes(hashPrevBlock);
}
function getHeaderMerkleRoot(bytes memory _blockHeader) public pure returns (uint) {
uint merkle;
assembly {
merkle := mload(add(add(_blockHeader, 32), 0x24))
}
return flip32Bytes(merkle);
}
function getTimestamp(bytes memory _blockHeader) internal pure returns (uint32 time) {
return bytesToUint32Flipped(_blockHeader, 0x44);
}
function getBits(bytes memory _blockHeader) internal pure returns (uint32 bits) {
return bytesToUint32Flipped(_blockHeader, 0x48);
}
function parseHeaderBytes(bytes memory _rawBytes, uint pos) internal view returns (BlockHeader bh) {
bh.bits = getBits(_rawBytes);
bh.blockHash = dblShaFlipMem(_rawBytes, pos, 80);
}
uint32 constant VERSION_AUXPOW = (1 << 8);
function bytesToUint32Flipped(bytes memory input, uint pos) internal pure returns (uint32 result) {
result = uint32(input[pos]) + uint32(input[pos + 1])*(2**8) + uint32(input[pos + 2])*(2**16) + uint32(input[pos + 3])*(2**24);
}
function bytesToUint64(bytes memory input, uint pos) internal pure returns (uint64 result) {
result = uint64(input[pos+7]) + uint64(input[pos + 6])*(2**8) + uint64(input[pos + 5])*(2**16) + uint64(input[pos + 4])*(2**24) + uint64(input[pos + 3])*(2**32) + uint64(input[pos + 2])*(2**40) + uint64(input[pos + 1])*(2**48) + uint64(input[pos])*(2**56);
}
function bytesToUint32(bytes memory input, uint pos) internal pure returns (uint32 result) {
result = uint32(input[pos+3]) + uint32(input[pos + 2])*(2**8) + uint32(input[pos + 1])*(2**16) + uint32(input[pos])*(2**24);
}
function isMergeMined(bytes memory _rawBytes, uint pos) internal pure returns (bool) {
return bytesToUint32Flipped(_rawBytes, pos) & VERSION_AUXPOW != 0;
}
function verifyBlockHeader(bytes _blockHeaderBytes, uint _pos, uint _proposedBlockHash) external view returns (uint, bool) {
BlockHeader memory blockHeader = parseHeaderBytes(_blockHeaderBytes, _pos);
uint blockSha256Hash = blockHeader.blockHash;
if(blockSha256Hash != _proposedBlockHash){
return (ERR_INVALID_HEADER_HASH, true);
}
uint target = targetFromBits(blockHeader.bits);
if (_blockHeaderBytes.length > 80 && isMergeMined(_blockHeaderBytes, 0)) {
AuxPoW memory ap = parseAuxPoW(_blockHeaderBytes, _pos);
if (ap.blockHash > target) {
return (ERR_PROOF_OF_WORK_AUXPOW, true);
}
uint auxPoWCode = checkAuxPoW(blockSha256Hash, ap);
if (auxPoWCode != 1) {
return (auxPoWCode, true);
}
return (0, true);
} else {
if (_proposedBlockHash > target) {
return (ERR_PROOF_OF_WORK, false);
}
return (0, false);
}
}
int64 constant TARGET_TIMESPAN = int64(21600);
int64 constant TARGET_TIMESPAN_DIV_4 = TARGET_TIMESPAN / int64(4);
int64 constant TARGET_TIMESPAN_MUL_4 = TARGET_TIMESPAN * int64(4);
int64 constant TARGET_TIMESPAN_ADJUSTMENT = int64(360);
uint constant INITIAL_CHAIN_WORK = 0x100001;
uint constant POW_LIMIT = 0x00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
function diffFromBits(uint32 bits) external pure returns (uint) {
return targetToDiff(targetFromBits(bits))*INITIAL_CHAIN_WORK;
}
function difficultyAdjustmentInterval() external pure returns (int64) {
return TARGET_TIMESPAN_ADJUSTMENT;
}
function calculateDifficulty(int64 _actualTimespan, uint32 _bits) external pure returns (uint32 result) {
int64 actualTimespan = _actualTimespan;
if (_actualTimespan < TARGET_TIMESPAN_DIV_4) {
actualTimespan = TARGET_TIMESPAN_DIV_4;
} else if (_actualTimespan > TARGET_TIMESPAN_MUL_4) {
actualTimespan = TARGET_TIMESPAN_MUL_4;
}
uint bnNew = targetFromBits(_bits);
bnNew = bnNew * uint(actualTimespan);
bnNew = uint(bnNew) / uint(TARGET_TIMESPAN);
if (bnNew > POW_LIMIT) {
bnNew = POW_LIMIT;
}
return toCompactBits(bnNew);
}
function shiftRight(uint _val, uint _shift) private pure returns (uint) {
return _val / uint(2)**_shift;
}
function shiftLeft(uint _val, uint _shift) private pure returns (uint) {
return _val * uint(2)**_shift;
}
function bitLen(uint _val) private pure returns (uint length) {
uint int_type = _val;
while (int_type > 0) {
int_type = shiftRight(int_type, 1);
length += 1;
}
}
function toCompactBits(uint _val) private pure returns (uint32) {
uint nbytes = uint (shiftRight((bitLen(_val) + 7), 3));
uint32 compact = 0;
if (nbytes <= 3) {
compact = uint32 (shiftLeft((_val & 0xFFFFFF), 8 * (3 - nbytes)));
} else {
compact = uint32 (shiftRight(_val, 8 * (nbytes - 3)));
compact = uint32 (compact & 0xFFFFFF);
}
if ((compact & 0x00800000) > 0) {
compact = uint32(shiftRight(compact, 8));
nbytes += 1;
}
return compact | uint32(shiftLeft(nbytes, 24));
}
}
contract SyscoinErrorCodes {
uint constant ERR_SUPERBLOCK_OK = 0;
uint constant ERR_SUPERBLOCK_BAD_STATUS = 50020;
uint constant ERR_SUPERBLOCK_BAD_SYSCOIN_STATUS = 50025;
uint constant ERR_SUPERBLOCK_NO_TIMEOUT = 50030;
uint constant ERR_SUPERBLOCK_BAD_TIMESTAMP = 50035;
uint constant ERR_SUPERBLOCK_INVALID_MERKLE = 50040;
uint constant ERR_SUPERBLOCK_BAD_PARENT = 50050;
uint constant ERR_SUPERBLOCK_OWN_CHALLENGE = 50055;
uint constant ERR_SUPERBLOCK_MIN_DEPOSIT = 50060;
uint constant ERR_SUPERBLOCK_NOT_CLAIMMANAGER = 50070;
uint constant ERR_SUPERBLOCK_BAD_CLAIM = 50080;
uint constant ERR_SUPERBLOCK_VERIFICATION_PENDING = 50090;
uint constant ERR_SUPERBLOCK_CLAIM_DECIDED = 50100;
uint constant ERR_SUPERBLOCK_BAD_CHALLENGER = 50110;
uint constant ERR_SUPERBLOCK_BAD_ACCUMULATED_WORK = 50120;
uint constant ERR_SUPERBLOCK_BAD_BITS = 50130;
uint constant ERR_SUPERBLOCK_MISSING_CONFIRMATIONS = 50140;
uint constant ERR_SUPERBLOCK_BAD_LASTBLOCK = 50150;
uint constant ERR_SUPERBLOCK_BAD_BLOCKHEIGHT = 50160;
uint constant ERR_BAD_FEE = 20010;
uint constant ERR_CONFIRMATIONS = 20020;
uint constant ERR_CHAIN = 20030;
uint constant ERR_SUPERBLOCK = 20040;
uint constant ERR_MERKLE_ROOT = 20050;
uint constant ERR_TX_64BYTE = 20060;
uint constant ERR_RELAY_VERIFY = 30010;
uint constant public minReward = 1000000000000000000;
uint constant public superblockCost = 440000;
uint constant public challengeCost = 34000;
uint constant public minProposalDeposit = challengeCost + minReward;
uint constant public minChallengeDeposit = superblockCost + minReward;
uint constant public respondMerkleRootHashesCost = 378000;
uint constant public respondBlockHeaderCost = 40000;
uint constant public verifySuperblockCost = 220000;
}
contract SyscoinSuperblocks is SyscoinErrorCodes {
enum Status { Unitialized, New, InBattle, SemiApproved, Approved, Invalid }
struct SuperblockInfo {
bytes32 blocksMerkleRoot;
uint accumulatedWork;
uint timestamp;
uint prevTimestamp;
bytes32 lastHash;
bytes32 parentId;
address submitter;
bytes32 ancestors;
uint32 lastBits;
uint32 index;
uint32 height;
uint32 blockHeight;
Status status;
}
mapping (bytes32 => SuperblockInfo) superblocks;
mapping (uint32 => bytes32) private indexSuperblock;
struct ProcessTransactionParams {
uint value;
address destinationAddress;
uint32 assetGUID;
address superblockSubmitterAddress;
SyscoinTransactionProcessor untrustedTargetContract;
}
mapping (uint => ProcessTransactionParams) private txParams;
uint32 indexNextSuperblock;
bytes32 public bestSuperblock;
uint public bestSuperblockAccumulatedWork;
event NewSuperblock(bytes32 superblockHash, address who);
event ApprovedSuperblock(bytes32 superblockHash, address who);
event ChallengeSuperblock(bytes32 superblockHash, address who);
event SemiApprovedSuperblock(bytes32 superblockHash, address who);
event InvalidSuperblock(bytes32 superblockHash, address who);
event ErrorSuperblock(bytes32 superblockHash, uint err);
event VerifyTransaction(bytes32 txHash, uint returnCode);
event RelayTransaction(bytes32 txHash, uint returnCode);
address public trustedClaimManager;
modifier onlyClaimManager() {
require(msg.sender == trustedClaimManager);
_;
}
constructor() public {}
function setClaimManager(address _claimManager) public {
require(address(trustedClaimManager) == 0x0 && _claimManager != 0x0);
trustedClaimManager = _claimManager;
}
function initialize(
bytes32 _blocksMerkleRoot,
uint _accumulatedWork,
uint _timestamp,
uint _prevTimestamp,
bytes32 _lastHash,
uint32 _lastBits,
bytes32 _parentId,
uint32 _blockHeight
) public returns (uint, bytes32) {
require(bestSuperblock == 0);
require(_parentId == 0);
bytes32 superblockHash = calcSuperblockHash(_blocksMerkleRoot, _accumulatedWork, _timestamp, _prevTimestamp, _lastHash, _lastBits, _parentId, _blockHeight);
SuperblockInfo storage superblock = superblocks[superblockHash];
require(superblock.status == Status.Unitialized);
indexSuperblock[indexNextSuperblock] = superblockHash;
superblock.blocksMerkleRoot = _blocksMerkleRoot;
superblock.accumulatedWork = _accumulatedWork;
superblock.timestamp = _timestamp;
superblock.prevTimestamp = _prevTimestamp;
superblock.lastHash = _lastHash;
superblock.parentId = _parentId;
superblock.submitter = msg.sender;
superblock.index = indexNextSuperblock;
superblock.height = 1;
superblock.lastBits = _lastBits;
superblock.status = Status.Approved;
superblock.ancestors = 0x0;
superblock.blockHeight = _blockHeight;
indexNextSuperblock++;
emit NewSuperblock(superblockHash, msg.sender);
bestSuperblock = superblockHash;
bestSuperblockAccumulatedWork = _accumulatedWork;
emit ApprovedSuperblock(superblockHash, msg.sender);
return (ERR_SUPERBLOCK_OK, superblockHash);
}
function propose(
bytes32 _blocksMerkleRoot,
uint _accumulatedWork,
uint _timestamp,
uint _prevTimestamp,
bytes32 _lastHash,
uint32 _lastBits,
bytes32 _parentId,
uint32 _blockHeight,
address submitter
) public returns (uint, bytes32) {
if (msg.sender != trustedClaimManager) {
emit ErrorSuperblock(0, ERR_SUPERBLOCK_NOT_CLAIMMANAGER);
return (ERR_SUPERBLOCK_NOT_CLAIMMANAGER, 0);
}
SuperblockInfo storage parent = superblocks[_parentId];
if (parent.status != Status.SemiApproved && parent.status != Status.Approved) {
emit ErrorSuperblock(superblockHash, ERR_SUPERBLOCK_BAD_PARENT);
return (ERR_SUPERBLOCK_BAD_PARENT, 0);
}
bytes32 superblockHash = calcSuperblockHash(_blocksMerkleRoot, _accumulatedWork, _timestamp, _prevTimestamp, _lastHash, _lastBits, _parentId, _blockHeight);
SuperblockInfo storage superblock = superblocks[superblockHash];
if (superblock.status == Status.Unitialized) {
indexSuperblock[indexNextSuperblock] = superblockHash;
superblock.blocksMerkleRoot = _blocksMerkleRoot;
superblock.accumulatedWork = _accumulatedWork;
superblock.timestamp = _timestamp;
superblock.prevTimestamp = _prevTimestamp;
superblock.lastHash = _lastHash;
superblock.parentId = _parentId;
superblock.submitter = submitter;
superblock.index = indexNextSuperblock;
superblock.height = parent.height + 1;
superblock.lastBits = _lastBits;
superblock.status = Status.New;
superblock.blockHeight = _blockHeight;
superblock.ancestors = updateAncestors(parent.ancestors, parent.index, parent.height);
indexNextSuperblock++;
emit NewSuperblock(superblockHash, submitter);
}
return (ERR_SUPERBLOCK_OK, superblockHash);
}
function confirm(bytes32 _superblockHash, address _validator) public returns (uint, bytes32) {
if (msg.sender != trustedClaimManager) {
emit ErrorSuperblock(_superblockHash, ERR_SUPERBLOCK_NOT_CLAIMMANAGER);
return (ERR_SUPERBLOCK_NOT_CLAIMMANAGER, 0);
}
SuperblockInfo storage superblock = superblocks[_superblockHash];
if (superblock.status != Status.New && superblock.status != Status.SemiApproved) {
emit ErrorSuperblock(_superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return (ERR_SUPERBLOCK_BAD_STATUS, 0);
}
SuperblockInfo storage parent = superblocks[superblock.parentId];
if (parent.status != Status.Approved) {
emit ErrorSuperblock(_superblockHash, ERR_SUPERBLOCK_BAD_PARENT);
return (ERR_SUPERBLOCK_BAD_PARENT, 0);
}
superblock.status = Status.Approved;
if (superblock.accumulatedWork > bestSuperblockAccumulatedWork) {
bestSuperblock = _superblockHash;
bestSuperblockAccumulatedWork = superblock.accumulatedWork;
}
emit ApprovedSuperblock(_superblockHash, _validator);
return (ERR_SUPERBLOCK_OK, _superblockHash);
}
function challenge(bytes32 _superblockHash, address _challenger) public returns (uint, bytes32) {
if (msg.sender != trustedClaimManager) {
emit ErrorSuperblock(_superblockHash, ERR_SUPERBLOCK_NOT_CLAIMMANAGER);
return (ERR_SUPERBLOCK_NOT_CLAIMMANAGER, 0);
}
SuperblockInfo storage superblock = superblocks[_superblockHash];
if (superblock.status != Status.New && superblock.status != Status.InBattle) {
emit ErrorSuperblock(_superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return (ERR_SUPERBLOCK_BAD_STATUS, 0);
}
if(superblock.submitter == _challenger){
emit ErrorSuperblock(_superblockHash, ERR_SUPERBLOCK_OWN_CHALLENGE);
return (ERR_SUPERBLOCK_OWN_CHALLENGE, 0);
}
superblock.status = Status.InBattle;
emit ChallengeSuperblock(_superblockHash, _challenger);
return (ERR_SUPERBLOCK_OK, _superblockHash);
}
function semiApprove(bytes32 _superblockHash, address _validator) public returns (uint, bytes32) {
if (msg.sender != trustedClaimManager) {
emit ErrorSuperblock(_superblockHash, ERR_SUPERBLOCK_NOT_CLAIMMANAGER);
return (ERR_SUPERBLOCK_NOT_CLAIMMANAGER, 0);
}
SuperblockInfo storage superblock = superblocks[_superblockHash];
if (superblock.status != Status.InBattle && superblock.status != Status.New) {
emit ErrorSuperblock(_superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return (ERR_SUPERBLOCK_BAD_STATUS, 0);
}
superblock.status = Status.SemiApproved;
emit SemiApprovedSuperblock(_superblockHash, _validator);
return (ERR_SUPERBLOCK_OK, _superblockHash);
}
function invalidate(bytes32 _superblockHash, address _validator) public returns (uint, bytes32) {
if (msg.sender != trustedClaimManager) {
emit ErrorSuperblock(_superblockHash, ERR_SUPERBLOCK_NOT_CLAIMMANAGER);
return (ERR_SUPERBLOCK_NOT_CLAIMMANAGER, 0);
}
SuperblockInfo storage superblock = superblocks[_superblockHash];
if (superblock.status != Status.InBattle && superblock.status != Status.SemiApproved) {
emit ErrorSuperblock(_superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return (ERR_SUPERBLOCK_BAD_STATUS, 0);
}
superblock.status = Status.Invalid;
emit InvalidSuperblock(_superblockHash, _validator);
return (ERR_SUPERBLOCK_OK, _superblockHash);
}
function relayTx(
bytes memory _txBytes,
uint _txIndex,
uint[] _txSiblings,
bytes memory _syscoinBlockHeader,
uint _syscoinBlockIndex,
uint[] memory _syscoinBlockSiblings,
bytes32 _superblockHash,
SyscoinTransactionProcessor _untrustedTargetContract
) public returns (uint) {
if (bytes32(SyscoinMessageLibrary.computeMerkle(SyscoinMessageLibrary.dblShaFlip(_syscoinBlockHeader), _syscoinBlockIndex, _syscoinBlockSiblings))
!= getSuperblockMerkleRoot(_superblockHash)) {
emit RelayTransaction(bytes32(0), ERR_SUPERBLOCK);
return ERR_SUPERBLOCK;
}
uint txHash = verifyTx(_txBytes, _txIndex, _txSiblings, _syscoinBlockHeader, _superblockHash);
if (txHash != 0) {
uint ret = parseTxHelper(_txBytes, txHash, _untrustedTargetContract);
if(ret != 0){
emit RelayTransaction(bytes32(0), ret);
return ret;
}
ProcessTransactionParams memory params = txParams[txHash];
params.superblockSubmitterAddress = superblocks[_superblockHash].submitter;
txParams[txHash] = params;
return verifyTxHelper(txHash);
}
emit RelayTransaction(bytes32(0), ERR_RELAY_VERIFY);
return(ERR_RELAY_VERIFY);
}
function parseTxHelper(bytes memory _txBytes, uint txHash, SyscoinTransactionProcessor _untrustedTargetContract) private returns (uint) {
uint value;
address destinationAddress;
uint32 _assetGUID;
uint ret;
(ret, value, destinationAddress, _assetGUID) = SyscoinMessageLibrary.parseTransaction(_txBytes);
if(ret != 0){
return ret;
}
ProcessTransactionParams memory params;
params.value = value;
params.destinationAddress = destinationAddress;
params.assetGUID = _assetGUID;
params.untrustedTargetContract = _untrustedTargetContract;
txParams[txHash] = params;
return 0;
}
function verifyTxHelper(uint txHash) private returns (uint) {
ProcessTransactionParams memory params = txParams[txHash];
uint returnCode = params.untrustedTargetContract.processTransaction(txHash, params.value, params.destinationAddress, params.assetGUID, params.superblockSubmitterAddress);
emit RelayTransaction(bytes32(txHash), returnCode);
return (returnCode);
}
function verifyTx(
bytes memory _txBytes,
uint _txIndex,
uint[] memory _siblings,
bytes memory _txBlockHeaderBytes,
bytes32 _txsuperblockHash
) public returns (uint) {
uint txHash = SyscoinMessageLibrary.dblShaFlip(_txBytes);
if (_txBytes.length == 64) {
emit VerifyTransaction(bytes32(txHash), ERR_TX_64BYTE);
return 0;
}
if (helperVerifyHash(txHash, _txIndex, _siblings, _txBlockHeaderBytes, _txsuperblockHash) == 1) {
return txHash;
} else {
return 0;
}
}
function helperVerifyHash(
uint256 _txHash,
uint _txIndex,
uint[] memory _siblings,
bytes memory _blockHeaderBytes,
bytes32 _txsuperblockHash
) private returns (uint) {
if (!isApproved(_txsuperblockHash) || !inMainChain(_txsuperblockHash)) {
emit VerifyTransaction(bytes32(_txHash), ERR_CHAIN);
return (ERR_CHAIN);
}
uint merkle = SyscoinMessageLibrary.getHeaderMerkleRoot(_blockHeaderBytes);
if (SyscoinMessageLibrary.computeMerkle(_txHash, _txIndex, _siblings) != merkle) {
emit VerifyTransaction(bytes32(_txHash), ERR_MERKLE_ROOT);
return (ERR_MERKLE_ROOT);
}
emit VerifyTransaction(bytes32(_txHash), 1);
return (1);
}
function calcSuperblockHash(
bytes32 _blocksMerkleRoot,
uint _accumulatedWork,
uint _timestamp,
uint _prevTimestamp,
bytes32 _lastHash,
uint32 _lastBits,
bytes32 _parentId,
uint32 _blockHeight
) public pure returns (bytes32) {
return keccak256(abi.encodePacked(
_blocksMerkleRoot,
_accumulatedWork,
_timestamp,
_prevTimestamp,
_lastHash,
_lastBits,
_parentId,
_blockHeight
));
}
function getBestSuperblock() public view returns (bytes32) {
return bestSuperblock;
}
function getSuperblock(bytes32 superblockHash) public view returns (
bytes32 _blocksMerkleRoot,
uint _accumulatedWork,
uint _timestamp,
uint _prevTimestamp,
bytes32 _lastHash,
uint32 _lastBits,
bytes32 _parentId,
address _submitter,
Status _status,
uint32 _blockHeight
) {
SuperblockInfo storage superblock = superblocks[superblockHash];
return (
superblock.blocksMerkleRoot,
superblock.accumulatedWork,
superblock.timestamp,
superblock.prevTimestamp,
superblock.lastHash,
superblock.lastBits,
superblock.parentId,
superblock.submitter,
superblock.status,
superblock.blockHeight
);
}
function getSuperblockHeight(bytes32 superblockHash) public view returns (uint32) {
return superblocks[superblockHash].height;
}
function getSuperblockIndex(bytes32 superblockHash) public view returns (uint32) {
return superblocks[superblockHash].index;
}
function getSuperblockAncestors(bytes32 superblockHash) public view returns (bytes32) {
return superblocks[superblockHash].ancestors;
}
function getSuperblockMerkleRoot(bytes32 _superblockHash) public view returns (bytes32) {
return superblocks[_superblockHash].blocksMerkleRoot;
}
function getSuperblockTimestamp(bytes32 _superblockHash) public view returns (uint) {
return superblocks[_superblockHash].timestamp;
}
function getSuperblockPrevTimestamp(bytes32 _superblockHash) public view returns (uint) {
return superblocks[_superblockHash].prevTimestamp;
}
function getSuperblockLastHash(bytes32 _superblockHash) public view returns (bytes32) {
return superblocks[_superblockHash].lastHash;
}
function getSuperblockParentId(bytes32 _superblockHash) public view returns (bytes32) {
return superblocks[_superblockHash].parentId;
}
function getSuperblockAccumulatedWork(bytes32 _superblockHash) public view returns (uint) {
return superblocks[_superblockHash].accumulatedWork;
}
function getSuperblockStatus(bytes32 _superblockHash) public view returns (Status) {
return superblocks[_superblockHash].status;
}
function getIndexNextSuperblock() public view returns (uint32) {
return indexNextSuperblock;
}
function makeMerkle(bytes32[] hashes) public pure returns (bytes32) {
return SyscoinMessageLibrary.makeMerkle(hashes);
}
function isApproved(bytes32 _superblockHash) public view returns (bool) {
return (getSuperblockStatus(_superblockHash) == Status.Approved);
}
function getChainHeight() public view returns (uint) {
return superblocks[bestSuperblock].height;
}
function writeUint32(bytes32 _word, uint _position, uint32 _fourBytes) private pure returns (bytes32) {
bytes32 result;
assembly {
let pointer := mload(0x40)
mstore(pointer, _word)
mstore8(add(pointer, _position), byte(28, _fourBytes))
mstore8(add(pointer, add(_position,1)), byte(29, _fourBytes))
mstore8(add(pointer, add(_position,2)), byte(30, _fourBytes))
mstore8(add(pointer, add(_position,3)), byte(31, _fourBytes))
result := mload(pointer)
}
return result;
}
uint constant ANCESTOR_STEP = 5;
uint constant NUM_ANCESTOR_DEPTHS = 8;
function updateAncestors(bytes32 ancestors, uint32 index, uint height) internal pure returns (bytes32) {
uint step = ANCESTOR_STEP;
ancestors = writeUint32(ancestors, 0, index);
uint i = 1;
while (i<NUM_ANCESTOR_DEPTHS && (height % step == 1)) {
ancestors = writeUint32(ancestors, 4*i, index);
step *= ANCESTOR_STEP;
++i;
}
return ancestors;
}
function getSuperblockLocator() public view returns (bytes32[9]) {
bytes32[9] memory locator;
locator[0] = bestSuperblock;
bytes32 ancestors = getSuperblockAncestors(bestSuperblock);
uint i = NUM_ANCESTOR_DEPTHS;
while (i > 0) {
locator[i] = indexSuperblock[uint32(ancestors & 0xFFFFFFFF)];
ancestors >>= 32;
--i;
}
return locator;
}
function getSuperblockAncestor(bytes32 superblockHash, uint index) internal view returns (bytes32) {
bytes32 ancestors = superblocks[superblockHash].ancestors;
uint32 ancestorsIndex =
uint32(ancestors[4*index + 0]) * 0x1000000 +
uint32(ancestors[4*index + 1]) * 0x10000 +
uint32(ancestors[4*index + 2]) * 0x100 +
uint32(ancestors[4*index + 3]) * 0x1;
return indexSuperblock[ancestorsIndex];
}
function getAncDepth(uint _index) private pure returns (uint) {
return ANCESTOR_STEP**(uint(_index));
}
function getSuperblockAt(uint _height) public view returns (bytes32) {
bytes32 superblockHash = bestSuperblock;
uint index = NUM_ANCESTOR_DEPTHS - 1;
while (getSuperblockHeight(superblockHash) > _height) {
while (getSuperblockHeight(superblockHash) - _height < getAncDepth(index) && index > 0) {
index -= 1;
}
superblockHash = getSuperblockAncestor(superblockHash, index);
}
return superblockHash;
}
function inMainChain(bytes32 _superblockHash) internal view returns (bool) {
uint height = getSuperblockHeight(_superblockHash);
if (height == 0) return false;
return (getSuperblockAt(height) == _superblockHash);
}
}
contract SyscoinClaimManager is SyscoinDepositsManager, SyscoinErrorCodes {
using SafeMath for uint;
struct SuperblockClaim {
bytes32 superblockHash;
address submitter;
uint createdAt;
address[] challengers;
mapping (address => uint) bondedDeposits;
uint currentChallenger;
mapping (address => bytes32) sessions;
uint challengeTimeout;
bool verificationOngoing;
bool decided;
bool invalid;
}
mapping (bytes32 => SuperblockClaim) public claims;
SyscoinSuperblocks public trustedSuperblocks;
SyscoinBattleManager public trustedSyscoinBattleManager;
uint public superblockConfirmations;
uint public battleReward;
uint public superblockDelay;
uint public superblockTimeout;
event DepositBonded(bytes32 superblockHash, address account, uint amount);
event DepositUnbonded(bytes32 superblockHash, address account, uint amount);
event SuperblockClaimCreated(bytes32 superblockHash, address submitter);
event SuperblockClaimChallenged(bytes32 superblockHash, address challenger);
event SuperblockBattleDecided(bytes32 sessionId, address winner, address loser);
event SuperblockClaimSuccessful(bytes32 superblockHash, address submitter);
event SuperblockClaimPending(bytes32 superblockHash, address submitter);
event SuperblockClaimFailed(bytes32 superblockHash, address submitter);
event VerificationGameStarted(bytes32 superblockHash, address submitter, address challenger, bytes32 sessionId);
event ErrorClaim(bytes32 superblockHash, uint err);
modifier onlyBattleManager() {
require(msg.sender == address(trustedSyscoinBattleManager));
_;
}
modifier onlyMeOrBattleManager() {
require(msg.sender == address(trustedSyscoinBattleManager) || msg.sender == address(this));
_;
}
constructor(
SyscoinSuperblocks _superblocks,
SyscoinBattleManager _syscoinBattleManager,
uint _superblockDelay,
uint _superblockTimeout,
uint _superblockConfirmations,
uint _battleReward
) public {
trustedSuperblocks = _superblocks;
trustedSyscoinBattleManager = _syscoinBattleManager;
superblockDelay = _superblockDelay;
superblockTimeout = _superblockTimeout;
superblockConfirmations = _superblockConfirmations;
battleReward = _battleReward;
}
function bondDeposit(bytes32 superblockHash, address account, uint amount) onlyMeOrBattleManager external returns (uint, uint) {
SuperblockClaim storage claim = claims[superblockHash];
if (!claimExists(claim)) {
return (ERR_SUPERBLOCK_BAD_CLAIM, 0);
}
if (deposits[account] < amount) {
return (ERR_SUPERBLOCK_MIN_DEPOSIT, deposits[account]);
}
deposits[account] = deposits[account].sub(amount);
claim.bondedDeposits[account] = claim.bondedDeposits[account].add(amount);
emit DepositBonded(superblockHash, account, amount);
return (ERR_SUPERBLOCK_OK, claim.bondedDeposits[account]);
}
function getBondedDeposit(bytes32 superblockHash, address account) public view returns (uint) {
SuperblockClaim storage claim = claims[superblockHash];
require(claimExists(claim));
return claim.bondedDeposits[account];
}
function getDeposit(address account) public view returns (uint) {
return deposits[account];
}
function unbondDeposit(bytes32 superblockHash, address account) internal returns (uint, uint) {
SuperblockClaim storage claim = claims[superblockHash];
if (!claimExists(claim)) {
return (ERR_SUPERBLOCK_BAD_CLAIM, 0);
}
if (!claim.decided) {
return (ERR_SUPERBLOCK_BAD_STATUS, 0);
}
uint bondedDeposit = claim.bondedDeposits[account];
delete claim.bondedDeposits[account];
deposits[account] = deposits[account].add(bondedDeposit);
emit DepositUnbonded(superblockHash, account, bondedDeposit);
return (ERR_SUPERBLOCK_OK, bondedDeposit);
}
function proposeSuperblock(
bytes32 _blocksMerkleRoot,
uint _accumulatedWork,
uint _timestamp,
uint _prevTimestamp,
bytes32 _lastHash,
uint32 _lastBits,
bytes32 _parentHash,
uint32 _blockHeight
) public returns (uint, bytes32) {
require(address(trustedSuperblocks) != 0);
if (deposits[msg.sender] < minProposalDeposit) {
emit ErrorClaim(0, ERR_SUPERBLOCK_MIN_DEPOSIT);
return (ERR_SUPERBLOCK_MIN_DEPOSIT, 0);
}
if (_timestamp + superblockDelay > block.timestamp) {
emit ErrorClaim(0, ERR_SUPERBLOCK_BAD_TIMESTAMP);
return (ERR_SUPERBLOCK_BAD_TIMESTAMP, 0);
}
uint err;
bytes32 superblockHash;
(err, superblockHash) = trustedSuperblocks.propose(_blocksMerkleRoot, _accumulatedWork,
_timestamp, _prevTimestamp, _lastHash, _lastBits, _parentHash, _blockHeight,msg.sender);
if (err != 0) {
emit ErrorClaim(superblockHash, err);
return (err, superblockHash);
}
SuperblockClaim storage claim = claims[superblockHash];
if (claimExists(claim)) {
bool allowed = claim.invalid == true && claim.decided == true && claim.submitter != msg.sender;
if(allowed){
if(trustedSuperblocks.getSuperblockStatus(_parentHash) == SyscoinSuperblocks.Status.Approved){
allowed = trustedSuperblocks.getBestSuperblock() == _parentHash;
}
else if(trustedSuperblocks.getSuperblockStatus(_parentHash) == SyscoinSuperblocks.Status.SemiApproved){
allowed = true;
}
else{
allowed = false;
}
}
if(!allowed){
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_CLAIM);
return (ERR_SUPERBLOCK_BAD_CLAIM, superblockHash);
}
}
claim.superblockHash = superblockHash;
claim.submitter = msg.sender;
claim.currentChallenger = 0;
claim.decided = false;
claim.invalid = false;
claim.verificationOngoing = false;
claim.createdAt = block.timestamp;
claim.challengeTimeout = block.timestamp + superblockTimeout;
claim.challengers.length = 0;
(err, ) = this.bondDeposit(superblockHash, msg.sender, battleReward);
assert(err == ERR_SUPERBLOCK_OK);
emit SuperblockClaimCreated(superblockHash, msg.sender);
return (ERR_SUPERBLOCK_OK, superblockHash);
}
function challengeSuperblock(bytes32 superblockHash) public returns (uint, bytes32) {
require(address(trustedSuperblocks) != 0);
SuperblockClaim storage claim = claims[superblockHash];
if (!claimExists(claim)) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_CLAIM);
return (ERR_SUPERBLOCK_BAD_CLAIM, superblockHash);
}
if (claim.decided) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_CLAIM_DECIDED);
return (ERR_SUPERBLOCK_CLAIM_DECIDED, superblockHash);
}
if (deposits[msg.sender] < minChallengeDeposit) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_MIN_DEPOSIT);
return (ERR_SUPERBLOCK_MIN_DEPOSIT, superblockHash);
}
uint err;
(err, ) = trustedSuperblocks.challenge(superblockHash, msg.sender);
if (err != 0) {
emit ErrorClaim(superblockHash, err);
return (err, 0);
}
(err, ) = this.bondDeposit(superblockHash, msg.sender, battleReward);
assert(err == ERR_SUPERBLOCK_OK);
claim.challengeTimeout = block.timestamp + superblockTimeout;
claim.challengers.push(msg.sender);
emit SuperblockClaimChallenged(superblockHash, msg.sender);
if (!claim.verificationOngoing) {
runNextBattleSession(superblockHash);
}
return (ERR_SUPERBLOCK_OK, superblockHash);
}
function runNextBattleSession(bytes32 superblockHash) internal returns (bool) {
SuperblockClaim storage claim = claims[superblockHash];
if (!claimExists(claim)) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_CLAIM);
return false;
}
if (claim.decided || claim.invalid) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_CLAIM_DECIDED);
return false;
}
if (claim.verificationOngoing) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_VERIFICATION_PENDING);
return false;
}
if (claim.currentChallenger < claim.challengers.length) {
bytes32 sessionId = trustedSyscoinBattleManager.beginBattleSession(superblockHash, claim.submitter,
claim.challengers[claim.currentChallenger]);
claim.sessions[claim.challengers[claim.currentChallenger]] = sessionId;
emit VerificationGameStarted(superblockHash, claim.submitter,
claim.challengers[claim.currentChallenger], sessionId);
claim.verificationOngoing = true;
claim.currentChallenger += 1;
}
return true;
}
function checkClaimFinished(bytes32 superblockHash) public returns (bool) {
SuperblockClaim storage claim = claims[superblockHash];
if (!claimExists(claim)) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_CLAIM);
return false;
}
if (claim.verificationOngoing) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_VERIFICATION_PENDING);
return false;
}
if (claim.invalid) {
claim.decided = true;
trustedSuperblocks.invalidate(claim.superblockHash, msg.sender);
emit SuperblockClaimFailed(superblockHash, claim.submitter);
doPayChallengers(superblockHash, claim);
return false;
}
if (block.timestamp <= claim.challengeTimeout) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_NO_TIMEOUT);
return false;
}
if (claim.currentChallenger < claim.challengers.length) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_VERIFICATION_PENDING);
return false;
}
claim.decided = true;
bool confirmImmediately = false;
if (claim.challengers.length == 0) {
bytes32 parentId = trustedSuperblocks.getSuperblockParentId(claim.superblockHash);
SyscoinSuperblocks.Status status = trustedSuperblocks.getSuperblockStatus(parentId);
if (status == SyscoinSuperblocks.Status.Approved) {
confirmImmediately = true;
}
}
if (confirmImmediately) {
trustedSuperblocks.confirm(claim.superblockHash, msg.sender);
unbondDeposit(superblockHash, claim.submitter);
emit SuperblockClaimSuccessful(superblockHash, claim.submitter);
} else {
trustedSuperblocks.semiApprove(claim.superblockHash, msg.sender);
emit SuperblockClaimPending(superblockHash, claim.submitter);
}
return true;
}
function confirmClaim(bytes32 superblockHash, bytes32 descendantId) public returns (bool) {
uint numSuperblocks = 0;
bool confirmDescendants = true;
bytes32 id = descendantId;
SuperblockClaim storage claim = claims[id];
while (id != superblockHash) {
if (!claimExists(claim)) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_CLAIM);
return false;
}
if (trustedSuperblocks.getSuperblockStatus(id) != SyscoinSuperblocks.Status.SemiApproved) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return false;
}
if (confirmDescendants && claim.challengers.length > 0) {
confirmDescendants = false;
}
id = trustedSuperblocks.getSuperblockParentId(id);
claim = claims[id];
numSuperblocks += 1;
}
if (numSuperblocks < superblockConfirmations) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_MISSING_CONFIRMATIONS);
return false;
}
if (trustedSuperblocks.getSuperblockStatus(id) != SyscoinSuperblocks.Status.SemiApproved) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return false;
}
bytes32 parentId = trustedSuperblocks.getSuperblockParentId(superblockHash);
if (trustedSuperblocks.getSuperblockStatus(parentId) != SyscoinSuperblocks.Status.Approved) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return false;
}
(uint err, ) = trustedSuperblocks.confirm(superblockHash, msg.sender);
if (err != ERR_SUPERBLOCK_OK) {
emit ErrorClaim(superblockHash, err);
return false;
}
emit SuperblockClaimSuccessful(superblockHash, claim.submitter);
doPaySubmitter(superblockHash, claim);
unbondDeposit(superblockHash, claim.submitter);
if (confirmDescendants) {
bytes32[] memory descendants = new bytes32[](numSuperblocks);
id = descendantId;
uint idx = 0;
while (id != superblockHash) {
descendants[idx] = id;
id = trustedSuperblocks.getSuperblockParentId(id);
idx += 1;
}
while (idx > 0) {
idx -= 1;
id = descendants[idx];
claim = claims[id];
(err, ) = trustedSuperblocks.confirm(id, msg.sender);
require(err == ERR_SUPERBLOCK_OK);
emit SuperblockClaimSuccessful(id, claim.submitter);
doPaySubmitter(id, claim);
unbondDeposit(id, claim.submitter);
}
}
return true;
}
function rejectClaim(bytes32 superblockHash) public returns (bool) {
SuperblockClaim storage claim = claims[superblockHash];
if (!claimExists(claim)) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_CLAIM);
return false;
}
uint height = trustedSuperblocks.getSuperblockHeight(superblockHash);
bytes32 id = trustedSuperblocks.getBestSuperblock();
if (trustedSuperblocks.getSuperblockHeight(id) < height + superblockConfirmations) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_MISSING_CONFIRMATIONS);
return false;
}
id = trustedSuperblocks.getSuperblockAt(height);
if (id != superblockHash) {
SyscoinSuperblocks.Status status = trustedSuperblocks.getSuperblockStatus(superblockHash);
if (status != SyscoinSuperblocks.Status.SemiApproved) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return false;
}
if (!claim.decided) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_CLAIM_DECIDED);
return false;
}
trustedSuperblocks.invalidate(superblockHash, msg.sender);
emit SuperblockClaimFailed(superblockHash, claim.submitter);
doPayChallengers(superblockHash, claim);
return true;
}
return false;
}
function sessionDecided(bytes32 sessionId, bytes32 superblockHash, address winner, address loser) public onlyBattleManager {
SuperblockClaim storage claim = claims[superblockHash];
require(claimExists(claim));
claim.verificationOngoing = false;
if (claim.submitter == loser) {
claim.invalid = true;
} else if (claim.submitter == winner) {
runNextBattleSession(superblockHash);
} else {
revert();
}
emit SuperblockBattleDecided(sessionId, winner, loser);
}
function doPayChallengers(bytes32 superblockHash, SuperblockClaim storage claim) internal {
uint rewards = claim.bondedDeposits[claim.submitter];
claim.bondedDeposits[claim.submitter] = 0;
uint totalDeposits = 0;
uint idx = 0;
for (idx = 0; idx < claim.currentChallenger; ++idx) {
totalDeposits = totalDeposits.add(claim.bondedDeposits[claim.challengers[idx]]);
}
address challenger;
uint reward = 0;
if(totalDeposits == 0 && claim.currentChallenger > 0){
reward = rewards.div(claim.currentChallenger);
}
for (idx = 0; idx < claim.currentChallenger; ++idx) {
reward = 0;
challenger = claim.challengers[idx];
if(totalDeposits > 0){
reward = rewards.mul(claim.bondedDeposits[challenger]).div(totalDeposits);
}
claim.bondedDeposits[challenger] = claim.bondedDeposits[challenger].add(reward);
}
uint bondedDeposit;
for (idx = 0; idx < claim.challengers.length; ++idx) {
challenger = claim.challengers[idx];
bondedDeposit = claim.bondedDeposits[challenger];
deposits[challenger] = deposits[challenger].add(bondedDeposit);
claim.bondedDeposits[challenger] = 0;
emit DepositUnbonded(superblockHash, challenger, bondedDeposit);
}
}
function doPaySubmitter(bytes32 superblockHash, SuperblockClaim storage claim) internal {
address challenger;
uint bondedDeposit;
for (uint idx=0; idx < claim.challengers.length; ++idx) {
challenger = claim.challengers[idx];
bondedDeposit = claim.bondedDeposits[challenger];
claim.bondedDeposits[challenger] = 0;
claim.bondedDeposits[claim.submitter] = claim.bondedDeposits[claim.submitter].add(bondedDeposit);
}
unbondDeposit(superblockHash, claim.submitter);
}
function getInBattleAndSemiApprovable(bytes32 superblockHash) public view returns (bool) {
SuperblockClaim storage claim = claims[superblockHash];
return (trustedSuperblocks.getSuperblockStatus(superblockHash) == SyscoinSuperblocks.Status.InBattle &&
!claim.invalid && !claim.verificationOngoing && block.timestamp > claim.challengeTimeout
&& claim.currentChallenger >= claim.challengers.length);
}
function claimExists(SuperblockClaim claim) private pure returns (bool) {
return (claim.submitter != 0x0);
}
function getClaimSubmitter(bytes32 superblockHash) public view returns (address) {
return claims[superblockHash].submitter;
}
function getNewSuperblockEventTimestamp(bytes32 superblockHash) public view returns (uint) {
return claims[superblockHash].createdAt;
}
function getClaimExists(bytes32 superblockHash) public view returns (bool) {
return claimExists(claims[superblockHash]);
}
function getClaimDecided(bytes32 superblockHash) public view returns (bool) {
return claims[superblockHash].decided;
}
function getClaimInvalid(bytes32 superblockHash) public view returns (bool) {
return claims[superblockHash].invalid;
}
function getClaimVerificationOngoing(bytes32 superblockHash) public view returns (bool) {
return claims[superblockHash].verificationOngoing;
}
function getClaimChallengeTimeout(bytes32 superblockHash) public view returns (uint) {
return claims[superblockHash].challengeTimeout;
}
function getClaimRemainingChallengers(bytes32 superblockHash) public view returns (uint) {
SuperblockClaim storage claim = claims[superblockHash];
return claim.challengers.length - (claim.currentChallenger);
}
function getSession(bytes32 superblockHash, address challenger) public view returns(bytes32) {
return claims[superblockHash].sessions[challenger];
}
function getClaimChallengers(bytes32 superblockHash) public view returns (address[]) {
SuperblockClaim storage claim = claims[superblockHash];
return claim.challengers;
}
function getSuperblockInfo(bytes32 superblockHash) internal view returns (
bytes32 _blocksMerkleRoot,
uint _accumulatedWork,
uint _timestamp,
uint _prevTimestamp,
bytes32 _lastHash,
uint32 _lastBits,
bytes32 _parentId,
address _submitter,
SyscoinSuperblocks.Status _status,
uint32 _height
) {
return trustedSuperblocks.getSuperblock(superblockHash);
}
}
contract SyscoinBattleManager is SyscoinErrorCodes {
enum ChallengeState {
Unchallenged,
Challenged,
QueryMerkleRootHashes,
RespondMerkleRootHashes,
QueryBlockHeader,
RespondBlockHeader,
PendingVerification,
SuperblockVerified,
SuperblockFailed
}
enum BlockInfoStatus {
Uninitialized,
Requested,
Verified
}
struct BlockInfo {
bytes32 prevBlock;
uint64 timestamp;
uint32 bits;
BlockInfoStatus status;
bytes powBlockHeader;
bytes32 blockHash;
}
struct BattleSession {
bytes32 id;
bytes32 superblockHash;
address submitter;
address challenger;
uint lastActionTimestamp;
uint lastActionClaimant;
uint lastActionChallenger;
uint actionsCounter;
bytes32[] blockHashes;
uint countBlockHeaderQueries;
uint countBlockHeaderResponses;
mapping (bytes32 => BlockInfo) blocksInfo;
ChallengeState challengeState;
}
mapping (bytes32 => BattleSession) public sessions;
uint public sessionsCount = 0;
uint public superblockDuration;
uint public superblockTimeout;
SyscoinMessageLibrary.Network private net;
SyscoinClaimManager trustedSyscoinClaimManager;
SyscoinSuperblocks trustedSuperblocks;
event NewBattle(bytes32 superblockHash, bytes32 sessionId, address submitter, address challenger);
event ChallengerConvicted(bytes32 superblockHash, bytes32 sessionId, address challenger);
event SubmitterConvicted(bytes32 superblockHash, bytes32 sessionId, address submitter);
event QueryMerkleRootHashes(bytes32 superblockHash, bytes32 sessionId, address submitter);
event RespondMerkleRootHashes(bytes32 superblockHash, bytes32 sessionId, address challenger, bytes32[] blockHashes);
event QueryBlockHeader(bytes32 superblockHash, bytes32 sessionId, address submitter, bytes32 blockSha256Hash);
event RespondBlockHeader(bytes32 superblockHash, bytes32 sessionId, address challenger, bytes blockHeader, bytes powBlockHeader);
event ErrorBattle(bytes32 sessionId, uint err);
modifier onlyFrom(address sender) {
require(msg.sender == sender);
_;
}
modifier onlyClaimant(bytes32 sessionId) {
require(msg.sender == sessions[sessionId].submitter);
_;
}
modifier onlyChallenger(bytes32 sessionId) {
require(msg.sender == sessions[sessionId].challenger);
_;
}
constructor(
SyscoinMessageLibrary.Network _network,
SyscoinSuperblocks _superblocks,
uint _superblockDuration,
uint _superblockTimeout
) public {
net = _network;
trustedSuperblocks = _superblocks;
superblockDuration = _superblockDuration;
superblockTimeout = _superblockTimeout;
}
function setSyscoinClaimManager(SyscoinClaimManager _syscoinClaimManager) public {
require(address(trustedSyscoinClaimManager) == 0x0 && address(_syscoinClaimManager) != 0x0);
trustedSyscoinClaimManager = _syscoinClaimManager;
}
function beginBattleSession(bytes32 superblockHash, address submitter, address challenger)
onlyFrom(trustedSyscoinClaimManager) public returns (bytes32) {
bytes32 sessionId = keccak256(abi.encode(superblockHash, msg.sender, sessionsCount));
BattleSession storage session = sessions[sessionId];
session.id = sessionId;
session.superblockHash = superblockHash;
session.submitter = submitter;
session.challenger = challenger;
session.lastActionTimestamp = block.timestamp;
session.lastActionChallenger = 0;
session.lastActionClaimant = 1;
session.actionsCounter = 1;
session.challengeState = ChallengeState.Challenged;
sessionsCount += 1;
emit NewBattle(superblockHash, sessionId, submitter, challenger);
return sessionId;
}
function doQueryMerkleRootHashes(BattleSession storage session) internal returns (uint) {
if (!hasDeposit(msg.sender, respondMerkleRootHashesCost)) {
return ERR_SUPERBLOCK_MIN_DEPOSIT;
}
if (session.challengeState == ChallengeState.Challenged) {
session.challengeState = ChallengeState.QueryMerkleRootHashes;
assert(msg.sender == session.challenger);
(uint err, ) = bondDeposit(session.superblockHash, msg.sender, respondMerkleRootHashesCost);
if (err != ERR_SUPERBLOCK_OK) {
return err;
}
return ERR_SUPERBLOCK_OK;
}
return ERR_SUPERBLOCK_BAD_STATUS;
}
function queryMerkleRootHashes(bytes32 superblockHash, bytes32 sessionId) onlyChallenger(sessionId) public {
BattleSession storage session = sessions[sessionId];
uint err = doQueryMerkleRootHashes(session);
if (err != ERR_SUPERBLOCK_OK) {
emit ErrorBattle(sessionId, err);
} else {
session.actionsCounter += 1;
session.lastActionTimestamp = block.timestamp;
session.lastActionChallenger = session.actionsCounter;
emit QueryMerkleRootHashes(superblockHash, sessionId, session.submitter);
}
}
function doVerifyMerkleRootHashes(BattleSession storage session, bytes32[] blockHashes) internal returns (uint) {
if (!hasDeposit(msg.sender, verifySuperblockCost)) {
return ERR_SUPERBLOCK_MIN_DEPOSIT;
}
require(session.blockHashes.length == 0);
if (session.challengeState == ChallengeState.QueryMerkleRootHashes) {
(bytes32 merkleRoot, , , , bytes32 lastHash, , , ,,) = getSuperblockInfo(session.superblockHash);
if (lastHash != blockHashes[blockHashes.length - 1]){
return ERR_SUPERBLOCK_BAD_LASTBLOCK;
}
if (merkleRoot != SyscoinMessageLibrary.makeMerkle(blockHashes)) {
return ERR_SUPERBLOCK_INVALID_MERKLE;
}
(uint err, ) = bondDeposit(session.superblockHash, msg.sender, verifySuperblockCost);
if (err != ERR_SUPERBLOCK_OK) {
return err;
}
session.blockHashes = blockHashes;
session.challengeState = ChallengeState.RespondMerkleRootHashes;
return ERR_SUPERBLOCK_OK;
}
return ERR_SUPERBLOCK_BAD_STATUS;
}
function respondMerkleRootHashes(bytes32 superblockHash, bytes32 sessionId, bytes32[] blockHashes) onlyClaimant(sessionId) public {
BattleSession storage session = sessions[sessionId];
uint err = doVerifyMerkleRootHashes(session, blockHashes);
if (err != 0) {
emit ErrorBattle(sessionId, err);
} else {
session.actionsCounter += 1;
session.lastActionTimestamp = block.timestamp;
session.lastActionClaimant = session.actionsCounter;
emit RespondMerkleRootHashes(superblockHash, sessionId, session.challenger, blockHashes);
}
}
function doQueryBlockHeader(BattleSession storage session, bytes32 blockHash) internal returns (uint) {
if (!hasDeposit(msg.sender, respondBlockHeaderCost)) {
return ERR_SUPERBLOCK_MIN_DEPOSIT;
}
if ((session.countBlockHeaderQueries == 0 && session.challengeState == ChallengeState.RespondMerkleRootHashes) ||
(session.countBlockHeaderQueries > 0 && session.challengeState == ChallengeState.RespondBlockHeader)) {
require(session.countBlockHeaderQueries < session.blockHashes.length);
require(session.blocksInfo[blockHash].status == BlockInfoStatus.Uninitialized);
(uint err, ) = bondDeposit(session.superblockHash, msg.sender, respondBlockHeaderCost);
if (err != ERR_SUPERBLOCK_OK) {
return err;
}
session.countBlockHeaderQueries += 1;
session.blocksInfo[blockHash].status = BlockInfoStatus.Requested;
session.challengeState = ChallengeState.QueryBlockHeader;
return ERR_SUPERBLOCK_OK;
}
return ERR_SUPERBLOCK_BAD_STATUS;
}
function queryBlockHeader(bytes32 superblockHash, bytes32 sessionId, bytes32 blockHash) onlyChallenger(sessionId) public {
BattleSession storage session = sessions[sessionId];
uint err = doQueryBlockHeader(session, blockHash);
if (err != ERR_SUPERBLOCK_OK) {
emit ErrorBattle(sessionId, err);
} else {
session.actionsCounter += 1;
session.lastActionTimestamp = block.timestamp;
session.lastActionChallenger = session.actionsCounter;
emit QueryBlockHeader(superblockHash, sessionId, session.submitter, blockHash);
}
}
function verifyTimestamp(bytes32 superblockHash, bytes blockHeader) internal view returns (bool) {
uint blockTimestamp = SyscoinMessageLibrary.getTimestamp(blockHeader);
uint superblockTimestamp;
(, , superblockTimestamp, , , , , ,,) = getSuperblockInfo(superblockHash);
return (blockTimestamp <= superblockTimestamp)
&& (blockTimestamp / superblockDuration >= superblockTimestamp / superblockDuration - 1);
}
function verifyBlockAuxPoW(
BlockInfo storage blockInfo,
bytes32 blockHash,
bytes blockHeader
) internal returns (uint, bytes) {
(uint err, bool isMergeMined) =
SyscoinMessageLibrary.verifyBlockHeader(blockHeader, 0, uint(blockHash));
if (err != 0) {
return (err, new bytes(0));
}
bytes memory powBlockHeader = (isMergeMined) ?
SyscoinMessageLibrary.sliceArray(blockHeader, blockHeader.length - 80, blockHeader.length) :
SyscoinMessageLibrary.sliceArray(blockHeader, 0, 80);
blockInfo.timestamp = SyscoinMessageLibrary.getTimestamp(blockHeader);
blockInfo.bits = SyscoinMessageLibrary.getBits(blockHeader);
blockInfo.prevBlock = bytes32(SyscoinMessageLibrary.getHashPrevBlock(blockHeader));
blockInfo.blockHash = blockHash;
blockInfo.powBlockHeader = powBlockHeader;
return (ERR_SUPERBLOCK_OK, powBlockHeader);
}
function doVerifyBlockHeader(
BattleSession storage session,
bytes memory blockHeader
) internal returns (uint, bytes) {
if (!hasDeposit(msg.sender, respondBlockHeaderCost)) {
return (ERR_SUPERBLOCK_MIN_DEPOSIT, new bytes(0));
}
if (session.challengeState == ChallengeState.QueryBlockHeader) {
bytes32 blockSha256Hash = bytes32(SyscoinMessageLibrary.dblShaFlipMem(blockHeader, 0, 80));
BlockInfo storage blockInfo = session.blocksInfo[blockSha256Hash];
if (blockInfo.status != BlockInfoStatus.Requested) {
return (ERR_SUPERBLOCK_BAD_SYSCOIN_STATUS, new bytes(0));
}
if (!verifyTimestamp(session.superblockHash, blockHeader)) {
return (ERR_SUPERBLOCK_BAD_TIMESTAMP, new bytes(0));
}
(uint err, bytes memory powBlockHeader) =
verifyBlockAuxPoW(blockInfo, blockSha256Hash, blockHeader);
if (err != ERR_SUPERBLOCK_OK) {
return (err, new bytes(0));
}
blockInfo.status = BlockInfoStatus.Verified;
(err, ) = bondDeposit(session.superblockHash, msg.sender, respondBlockHeaderCost);
if (err != ERR_SUPERBLOCK_OK) {
return (err, new bytes(0));
}
session.countBlockHeaderResponses += 1;
if (session.countBlockHeaderResponses == session.blockHashes.length) {
session.challengeState = ChallengeState.PendingVerification;
} else {
session.challengeState = ChallengeState.RespondBlockHeader;
}
return (ERR_SUPERBLOCK_OK, powBlockHeader);
}
return (ERR_SUPERBLOCK_BAD_STATUS, new bytes(0));
}
function respondBlockHeader(
bytes32 superblockHash,
bytes32 sessionId,
bytes memory blockHeader
) onlyClaimant(sessionId) public {
BattleSession storage session = sessions[sessionId];
(uint err, bytes memory powBlockHeader) = doVerifyBlockHeader(session, blockHeader);
if (err != 0) {
emit ErrorBattle(sessionId, err);
} else {
session.actionsCounter += 1;
session.lastActionTimestamp = block.timestamp;
session.lastActionClaimant = session.actionsCounter;
emit RespondBlockHeader(superblockHash, sessionId, session.challenger, blockHeader, powBlockHeader);
}
}
function validateLastBlocks(BattleSession storage session) internal view returns (uint) {
if (session.blockHashes.length <= 0) {
return ERR_SUPERBLOCK_BAD_LASTBLOCK;
}
uint lastTimestamp;
uint prevTimestamp;
uint32 lastBits;
bytes32 parentId;
(, , lastTimestamp, prevTimestamp, , lastBits, parentId,,,) = getSuperblockInfo(session.superblockHash);
bytes32 blockSha256Hash = session.blockHashes[session.blockHashes.length - 1];
if (session.blocksInfo[blockSha256Hash].timestamp != lastTimestamp) {
return ERR_SUPERBLOCK_BAD_TIMESTAMP;
}
if (session.blocksInfo[blockSha256Hash].bits != lastBits) {
return ERR_SUPERBLOCK_BAD_BITS;
}
if (prevTimestamp > lastTimestamp) {
return ERR_SUPERBLOCK_BAD_TIMESTAMP;
}
return ERR_SUPERBLOCK_OK;
}
function validateProofOfWork(BattleSession storage session) internal view returns (uint) {
uint accWork;
bytes32 prevBlock;
uint32 prevHeight;
uint32 proposedHeight;
uint prevTimestamp;
(, accWork, , prevTimestamp, , , prevBlock, ,,proposedHeight) = getSuperblockInfo(session.superblockHash);
uint parentTimestamp;
uint32 prevBits;
uint work;
(, work, parentTimestamp, , prevBlock, prevBits, , , ,prevHeight) = getSuperblockInfo(prevBlock);
if (proposedHeight != (prevHeight+uint32(session.blockHashes.length))) {
return ERR_SUPERBLOCK_BAD_BLOCKHEIGHT;
}
uint ret = validateSuperblockProofOfWork(session, parentTimestamp, prevHeight, work, accWork, prevTimestamp, prevBits, prevBlock);
if(ret != 0){
return ret;
}
return ERR_SUPERBLOCK_OK;
}
function validateSuperblockProofOfWork(BattleSession storage session, uint parentTimestamp, uint32 prevHeight, uint work, uint accWork, uint prevTimestamp, uint32 prevBits, bytes32 prevBlock) internal view returns (uint){
uint32 idx = 0;
while (idx < session.blockHashes.length) {
bytes32 blockSha256Hash = session.blockHashes[idx];
uint32 bits = session.blocksInfo[blockSha256Hash].bits;
if (session.blocksInfo[blockSha256Hash].prevBlock != prevBlock) {
return ERR_SUPERBLOCK_BAD_PARENT;
}
if (net != SyscoinMessageLibrary.Network.REGTEST) {
uint32 newBits;
if (net == SyscoinMessageLibrary.Network.TESTNET && session.blocksInfo[blockSha256Hash].timestamp - parentTimestamp > 120) {
newBits = 0x1e0fffff;
}
else if((prevHeight+idx+1) % SyscoinMessageLibrary.difficultyAdjustmentInterval() != 0){
newBits = prevBits;
}
else{
newBits = SyscoinMessageLibrary.calculateDifficulty(int64(parentTimestamp) - int64(prevTimestamp), prevBits);
prevTimestamp = parentTimestamp;
prevBits = bits;
}
if (bits != newBits) {
return ERR_SUPERBLOCK_BAD_BITS;
}
}
work += SyscoinMessageLibrary.diffFromBits(bits);
prevBlock = blockSha256Hash;
parentTimestamp = session.blocksInfo[blockSha256Hash].timestamp;
idx += 1;
}
if (net != SyscoinMessageLibrary.Network.REGTEST && work != accWork) {
return ERR_SUPERBLOCK_BAD_ACCUMULATED_WORK;
}
return 0;
}
function doVerifySuperblock(BattleSession storage session, bytes32 sessionId) internal returns (uint) {
if (session.challengeState == ChallengeState.PendingVerification) {
uint err;
err = validateLastBlocks(session);
if (err != 0) {
emit ErrorBattle(sessionId, err);
return 2;
}
err = validateProofOfWork(session);
if (err != 0) {
emit ErrorBattle(sessionId, err);
return 2;
}
return 1;
} else if (session.challengeState == ChallengeState.SuperblockFailed) {
return 2;
}
return 0;
}
function verifySuperblock(bytes32 sessionId) public {
BattleSession storage session = sessions[sessionId];
uint status = doVerifySuperblock(session, sessionId);
if (status == 1) {
convictChallenger(sessionId, session.challenger, session.superblockHash);
} else if (status == 2) {
convictSubmitter(sessionId, session.submitter, session.superblockHash);
}
}
function timeout(bytes32 sessionId) public returns (uint) {
BattleSession storage session = sessions[sessionId];
if (session.challengeState == ChallengeState.SuperblockFailed ||
(session.lastActionChallenger > session.lastActionClaimant &&
block.timestamp > session.lastActionTimestamp + superblockTimeout)) {
convictSubmitter(sessionId, session.submitter, session.superblockHash);
return ERR_SUPERBLOCK_OK;
} else if (session.lastActionClaimant > session.lastActionChallenger &&
block.timestamp > session.lastActionTimestamp + superblockTimeout) {
convictChallenger(sessionId, session.challenger, session.superblockHash);
return ERR_SUPERBLOCK_OK;
}
emit ErrorBattle(sessionId, ERR_SUPERBLOCK_NO_TIMEOUT);
return ERR_SUPERBLOCK_NO_TIMEOUT;
}
function convictChallenger(bytes32 sessionId, address challenger, bytes32 superblockHash) internal {
BattleSession storage session = sessions[sessionId];
sessionDecided(sessionId, superblockHash, session.submitter, session.challenger);
disable(sessionId);
emit ChallengerConvicted(superblockHash, sessionId, challenger);
}
function convictSubmitter(bytes32 sessionId, address submitter, bytes32 superblockHash) internal {
BattleSession storage session = sessions[sessionId];
sessionDecided(sessionId, superblockHash, session.challenger, session.submitter);
disable(sessionId);
emit SubmitterConvicted(superblockHash, sessionId, submitter);
}
function disable(bytes32 sessionId) internal {
delete sessions[sessionId];
}
function getChallengerHitTimeout(bytes32 sessionId) public view returns (bool) {
BattleSession storage session = sessions[sessionId];
return (session.lastActionClaimant > session.lastActionChallenger &&
block.timestamp > session.lastActionTimestamp + superblockTimeout);
}
function getSubmitterHitTimeout(bytes32 sessionId) public view returns (bool) {
BattleSession storage session = sessions[sessionId];
return (session.lastActionChallenger > session.lastActionClaimant &&
block.timestamp > session.lastActionTimestamp + superblockTimeout);
}
function getSyscoinBlockHashes(bytes32 sessionId) public view returns (bytes32[]) {
return sessions[sessionId].blockHashes;
}
function sessionDecided(bytes32 sessionId, bytes32 superblockHash, address winner, address loser) internal {
trustedSyscoinClaimManager.sessionDecided(sessionId, superblockHash, winner, loser);
}
function getSuperblockInfo(bytes32 superblockHash) internal view returns (
bytes32 _blocksMerkleRoot,
uint _accumulatedWork,
uint _timestamp,
uint _prevTimestamp,
bytes32 _lastHash,
uint32 _lastBits,
bytes32 _parentId,
address _submitter,
SyscoinSuperblocks.Status _status,
uint32 _height
) {
return trustedSuperblocks.getSuperblock(superblockHash);
}
function hasDeposit(address who, uint amount) internal view returns (bool) {
return trustedSyscoinClaimManager.getDeposit(who) >= amount;
}
function bondDeposit(bytes32 superblockHash, address account, uint amount) internal returns (uint, uint) {
return trustedSyscoinClaimManager.bondDeposit(superblockHash, account, amount);
}
} | 0 | 1,004 |
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 finneyCostOfEachToken,
address addressOfTokenUsedAsReward) {
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
deadline = now + durationInMinutes * 1 minutes;
price = finneyCostOfEachToken * 1 finney;
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 | 890 |
pragma solidity ^0.4.24;
interface token {
function transfer(address receiver, uint amount) external returns (bool);
function balanceOf(address who) external returns (uint256);
}
interface AddressRegistry {
function getAddr(string AddrName) external returns(address);
}
contract Registry {
address public RegistryAddress;
modifier onlyAdmin() {
require(msg.sender == getAddress("admin"));
_;
}
function getAddress(string AddressName) internal view returns(address) {
AddressRegistry aRegistry = AddressRegistry(RegistryAddress);
address realAddress = aRegistry.getAddr(AddressName);
require(realAddress != address(0));
return realAddress;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
}
}
contract StandardToken is ERC20, BasicToken, BurnableToken {
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 Pausable is Registry {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyAdmin whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyAdmin whenPaused public {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract MoatUnit is PausableToken {
constructor(address rAddress) public {
RegistryAddress = rAddress;
}
string public constant name = "MoatUnit";
string public constant symbol = "MTUv2";
uint8 public constant decimals = 0;
function MintToken(uint NoOfMTU) onlyAdmin public {
totalSupply_ = totalSupply_.add(NoOfMTU);
address fundAddress = getAddress("fund");
balances[fundAddress] = balances[fundAddress].add(NoOfMTU);
emit Transfer(0, fundAddress, NoOfMTU);
}
function SendERC20ToAsset(address tokenAddress) onlyAdmin public {
token tokenFunctions = token(tokenAddress);
uint256 tokenBal = tokenFunctions.balanceOf(address(this));
tokenFunctions.transfer(getAddress("asset"), tokenBal);
}
} | 1 | 2,980 |
pragma solidity ^0.4.17;
contract AvPresale {
string public constant RELEASE = "0.2.3_AviaTest";
uint public constant PRESALE_START = 5307620;
uint public constant PRESALE_END = 5314027;
uint public constant WITHDRAWAL_END = 5314987;
address public constant OWNER = 0x32Bac79f4B6395DEa37f0c2B68b6e26ce24a59EA;
uint public constant MIN_TOTAL_AMOUNT_GET_ETH = 1;
uint public constant MAX_TOTAL_AMOUNT_GET_ETH = 2;
uint public constant MIN_GET_AMOUNT_FINNEY = 10;
string[5] private standingNames = ["BEFORE_START", "PRESALE_RUNNING", "WITHDRAWAL_RUNNING", "MONEY_BACK_RUNNING", "CLOSED" ];
enum State { BEFORE_START, PRESALE_RUNNING, WITHDRAWAL_RUNNING, MONEY_BACK_RUNNING, CLOSED }
uint public total_amount = 0;
uint public total_money_back = 0;
mapping (address => uint) public balances;
uint private constant MIN_TOTAL_AMOUNT_GET = MIN_TOTAL_AMOUNT_GET_ETH * 1 ether;
uint private constant MAX_TOTAL_AMOUNT_GET = MAX_TOTAL_AMOUNT_GET_ETH * 1 ether;
uint private constant MIN_GET_AMOUNT = MIN_GET_AMOUNT_FINNEY * 1 finney;
bool public isTerminated = false;
bool public isStopped = false;
function AvPresale () public checkSettings() { }
function sendMoneyOwner() external
inStanding(State.WITHDRAWAL_RUNNING)
onlyOwner
noReentrancy
{
OWNER.transfer(this.balance);
}
function moneyBack() external
inStanding(State.MONEY_BACK_RUNNING)
noReentrancy
{
sendMoneyBack();
}
function ()
payable
noReentrancy
public
{
State state = currentStanding();
if (state == State.PRESALE_RUNNING) {
getMoney();
} else if (state == State.MONEY_BACK_RUNNING) {
sendMoneyBack();
} else {
revert();
}
}
function termination() external
inStandingBefore(State.MONEY_BACK_RUNNING)
onlyOwner
{
isTerminated = true;
}
function stop() external
inStanding(State.PRESALE_RUNNING)
onlyOwner
{
isStopped = true;
}
function standing() external constant
returns (string)
{
return standingNames[ uint(currentStanding()) ];
}
function getMoney() private notTooSmallAmountOnly {
if (total_amount + msg.value > MAX_TOTAL_AMOUNT_GET) {
var change_to_return = total_amount + msg.value - MAX_TOTAL_AMOUNT_GET;
var acceptable_remainder = MAX_TOTAL_AMOUNT_GET - total_amount;
balances[msg.sender] += acceptable_remainder;
total_amount += acceptable_remainder;
msg.sender.transfer(change_to_return);
} else {
balances[msg.sender] += msg.value;
total_amount += msg.value;
}
}
function sendMoneyBack() private tokenHoldersOnly {
uint amount_to_money_back = min(balances[msg.sender], this.balance - msg.value) ;
balances[msg.sender] -= amount_to_money_back;
total_money_back += amount_to_money_back;
msg.sender.transfer(amount_to_money_back + msg.value);
}
function currentStanding() private constant returns (State) {
if (isTerminated) {
return this.balance > 0
? State.MONEY_BACK_RUNNING
: State.CLOSED;
} else if (block.number < PRESALE_START) {
return State.BEFORE_START;
} else if (block.number <= PRESALE_END && total_amount < MAX_TOTAL_AMOUNT_GET && !isStopped) {
return State.PRESALE_RUNNING;
} else if (this.balance == 0) {
return State.CLOSED;
} else if (block.number <= WITHDRAWAL_END && total_amount >= MIN_TOTAL_AMOUNT_GET) {
return State.WITHDRAWAL_RUNNING;
} else {
return State.MONEY_BACK_RUNNING;
}
}
function min(uint a, uint b) pure private returns (uint) {
return a < b ? a : b;
}
modifier inStanding(State state) {
require(state == currentStanding());
_;
}
modifier inStandingBefore(State state) {
require(currentStanding() < state);
_;
}
modifier tokenHoldersOnly(){
require(balances[msg.sender] > 0);
_;
}
modifier notTooSmallAmountOnly(){
require(msg.value >= MIN_GET_AMOUNT);
_;
}
bool private lock = false;
modifier noReentrancy() {
require(!lock);
lock = true;
_;
lock = false;
}
modifier checkSettings() {
if ( OWNER == 0x0
|| PRESALE_START == 0
|| PRESALE_END == 0
|| WITHDRAWAL_END ==0
|| PRESALE_START <= block.number
|| PRESALE_START >= PRESALE_END
|| PRESALE_END >= WITHDRAWAL_END
|| MIN_TOTAL_AMOUNT_GET > MAX_TOTAL_AMOUNT_GET )
revert();
_;
}
modifier onlyOwner(){
require(msg.sender == OWNER);
_;
}
} | 1 | 3,064 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.